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
}