package agentteambridge

import (
	"context"
	"sync"
)

type ModelCache struct {
	mu       sync.RWMutex
	models   []string
	provider ModelProvider
}

func NewModelCache(provider ModelProvider) *ModelCache {
	return &ModelCache{provider: provider}
}

func (mc *ModelCache) Initialize() error {
	return mc.RefreshModels()
}

func (mc *ModelCache) RefreshModels() error {
	if mc == nil || mc.provider == nil {
		return nil
	}
	models, err := mc.provider.FetchModels(context.Background())
	if err != nil {
		return err
	}
	mc.mu.Lock()
	defer mc.mu.Unlock()
	mc.models = append([]string(nil), models...)
	return nil
}

func (mc *ModelCache) Models() []string {
	if mc == nil {
		return nil
	}
	mc.mu.RLock()
	defer mc.mu.RUnlock()
	return append([]string(nil), mc.models...)
}

type StaticModelProvider struct {
	models []string
}

func NewStaticModelProvider(models []string) *StaticModelProvider {
	return &StaticModelProvider{models: append([]string(nil), models...)}
}

func (provider *StaticModelProvider) FetchModels(_ context.Context) ([]string, error) {
	return append([]string(nil), provider.models...), nil
}

func (provider *StaticModelProvider) NeedsPeriodicRefresh() bool {
	return false
}