package app

import (
	"cmp"
	"context"
	"slices"

	"albedo/cli/internal/daemon"
)

type ProxyProvider struct {
	Name   string
	Models []string
}

type PreparedProxy struct {
	Connection  *daemon.Connection
	Enabled     bool
	Providers   []ProxyProvider
	Unavailable []string
}

// PrepareProxy reads the global extension choice and its advertised models.
func (s *Service) PrepareProxy(ctx context.Context) (PreparedProxy, error) {
	conn, err := s.Connect(ctx)
	if err != nil {
		return PreparedProxy{}, err
	}
	settings, err := daemon.GetSettings(ctx, conn)
	if err != nil {
		return PreparedProxy{}, err
	}
	prepared := PreparedProxy{Connection: conn, Enabled: settings.Extensions["proxy"]}
	if !prepared.Enabled {
		return prepared, nil
	}
	catalog, err := daemon.ListProxyModels(ctx, conn)
	if err != nil {
		return PreparedProxy{}, err
	}
	groups := map[string][]string{}
	for _, model := range catalog.Data {
		groups[model.Provider] = append(groups[model.Provider], model.ID)
	}
	for name, models := range groups {
		slices.Sort(models)
		prepared.Providers = append(prepared.Providers, ProxyProvider{Name: name, Models: slices.Compact(models)})
	}
	slices.SortFunc(prepared.Providers, func(a, b ProxyProvider) int { return cmp.Compare(a.Name, b.Name) })
	for _, failure := range catalog.Errors {
		prepared.Unavailable = append(prepared.Unavailable, failure.Profile)
	}
	slices.Sort(prepared.Unavailable)
	return prepared, nil
}