package agentteambridge

import (
	"strings"
	"sync"
	"time"
)

type TokenState struct {
	Label      string
	Token      string
	Enabled    bool
	LastUsedAt time.Time
}

type TokenSelector interface {
	Select([]TokenState) (TokenState, bool)
}

type TokenPool struct {
	mu       sync.RWMutex
	tokens   []TokenState
	selector TokenSelector
}

func NewTokenPool(tokens []TokenState, selector TokenSelector) *TokenPool {
	if selector == nil {
		selector = RandomSelector{}
	}
	normalized := make([]TokenState, 0, len(tokens))
	for _, token := range tokens {
		token.Token = strings.TrimSpace(token.Token)
		if token.Token == "" {
			continue
		}
		if !token.Enabled {
			token.Enabled = true
		}
		normalized = append(normalized, token)
	}
	return &TokenPool{tokens: normalized, selector: selector}
}

func (pool *TokenPool) SelectToken() (string, bool) {
	if pool == nil {
		return "", false
	}
	pool.mu.Lock()
	defer pool.mu.Unlock()

	enabled := make([]TokenState, 0, len(pool.tokens))
	for _, token := range pool.tokens {
		if token.Enabled && strings.TrimSpace(token.Token) != "" {
			enabled = append(enabled, token)
		}
	}
	selected, ok := pool.selector.Select(enabled)
	if !ok {
		return "", false
	}
	for i := range pool.tokens {
		if pool.tokens[i].Token == selected.Token {
			pool.tokens[i].LastUsedAt = time.Now().UTC()
			break
		}
	}
	return selected.Token, true
}