package main

import (
	"fmt"
	"slices"
	"sort"
	"sync"

	"github.com/fatih/color"
)

func fetchAndDisplay(pkgName string) *statistics {
	fmt.Print("\033[s")
	showLoadingPrompt(fmt.Sprintf("What the heck is \"%s\"", pkgName))

	stat := initStat(pkgName)

	fmlChan := make(chan *FormulaInfo)
	caskChan := make(chan *CaskInfo)
	rvsChan := make(chan []string)
	fetchData(pkgName, fmlChan, caskChan, rvsChan)

	var wg sync.WaitGroup
	wg.Add(1)
	go func() {
		defer wg.Done()
		var fml *FormulaInfo
		var cask *CaskInfo
		var rvs []string
		remaining := 3
		for remaining > 0 {
			select {
			case v := <-fmlChan:
				fml = v
				remaining--
			case v := <-caskChan:
				cask = v
				remaining--
			case v := <-rvsChan:
				rvs = v
				remaining--
			}
			fmt.Print("\033[u\033[J")
			stat = NewStatistics(fml, cask, pkgName, rvs)
			stat.Print()
		}
	}()
	wg.Wait()

	return stat
}

func initStat(pkgName string) *statistics {
	if NoCache {
		return &statistics{PkgName: pkgName}
	}
	stat := NewStatisticsFromCache(pkgName)
	if stat == nil {
		return &statistics{PkgName: pkgName}
	}
	return stat
}

func runList() error {
	depmap := GetBrewDeps()
	list := GetBrewList()

	keys := []string{}
	for k := range depmap {
		if !slices.Contains(list, k) {
			delete(depmap, k)
		} else {
			keys = append(keys, k)
		}
	}

	if ListAscend {
		sort.Slice(keys, func(i, j int) bool {
			return len(depmap[keys[i]]) > len(depmap[keys[j]])
		})
	} else if ListDescend {
		sort.Slice(keys, func(i, j int) bool {
			return len(depmap[keys[i]]) < len(depmap[keys[j]])
		})
	} else {
		sort.Strings(keys)
	}

	for _, pkg := range keys {
		deps := depmap[pkg]
		count := len(deps)

		color.New(color.FgBlue).Printf("%s", pkg)
		if count > 1 {
			fmt.Printf(" (%d dependencies)\n", count)
		} else {
			fmt.Printf(" (%d dependency)\n", count)
		}

		if ListNoDep {
			continue
		}
		for _, dep := range deps {
			fmt.Printf("  ► %s\n", dep)
		}
	}
	return nil
}