refactored & audited, real analizer added

internal/releaseparser/groups/moonblood/analyzer.go

@@ -0,0 +1,103 @@
+package moonblood
+
+import (
+	"bufio"
+	"os"
+	"sort"
+	"strings"
+
+	"git.kplus.net.ua/yevhen/resource-scraper/internal/releaseparser"
+)
+
+type GroupStats struct {
+	Total                int
+	YearDistribution     map[int]int
+	SourceDistribution   map[string]int
+	BitDepthDistribution map[string]int
+	ResolutionDistribution map[string]int
+	LanguageDistribution map[string]int
+	EditionDistribution  map[string]int
+	UnknownTokens        []releaseparser.UnknownTokenStats
+	AvgConfidence        float64
+}
+
+func AnalyzeGroup() (GroupStats, error) {
+	stats := GroupStats{
+		YearDistribution:     make(map[int]int),
+		SourceDistribution:   make(map[string]int),
+		BitDepthDistribution: make(map[string]int),
+		ResolutionDistribution: make(map[string]int),
+		LanguageDistribution: make(map[string]int),
+		EditionDistribution:  make(map[string]int),
+		UnknownTokens:        []releaseparser.UnknownTokenStats{},
+	}
+
+	file, err := os.Open("internal/releaseparser/resources/moonblood.txt")
+	if err != nil {
+		return stats, err
+	}
+	defer file.Close()
+
+	scanner := bufio.NewScanner(file)
+	totalConfidence := 0.0
+
+	unknownMap := make(map[string]*releaseparser.UnknownTokenStats)
+
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if line == "" {
+			continue
+		}
+
+		result := Parse(line)
+		stats.Total++
+
+		if result.Year != 0 {
+			stats.YearDistribution[result.Year]++
+		}
+		if result.Source != "" {
+			stats.SourceDistribution[result.Source]++
+		}
+		if result.BitDepth != "" {
+			stats.BitDepthDistribution[result.BitDepth]++
+		}
+		if result.Resolution != "" {
+			stats.ResolutionDistribution[result.Resolution]++
+		}
+		if result.Language != "" {
+			stats.LanguageDistribution[result.Language]++
+		}
+		if result.Edition != "" {
+			stats.EditionDistribution[result.Edition]++
+		}
+
+		for _, unknown := range result.UnknownTokens {
+			if _, exists := unknownMap[unknown]; !exists {
+				unknownMap[unknown] = &releaseparser.UnknownTokenStats{
+					Token:    unknown,
+					Count:    0,
+					Releases: []string{},
+				}
+			}
+			unknownMap[unknown].Count++
+			unknownMap[unknown].Releases = append(unknownMap[unknown].Releases, line)
+		}
+
+		totalConfidence += result.Confidence
+	}
+
+	// Convert map to slice and sort by count
+	for _, tokenStats := range unknownMap {
+		stats.UnknownTokens = append(stats.UnknownTokens, *tokenStats)
+	}
+
+	sort.Slice(stats.UnknownTokens, func(i, j int) bool {
+		return stats.UnknownTokens[i].Count > stats.UnknownTokens[j].Count
+	})
+
+	if stats.Total > 0 {
+		stats.AvgConfidence = totalConfidence / float64(stats.Total)
+	}
+
+	return stats, nil
+}