package fake

import (
	"ai-operator/internal/ai"
	"ai-operator/internal/media"
	"context"
	"sync"
	"time"
)

type Provider struct {
	events      chan ai.VoiceEvent
	mu          sync.Mutex
	stats       ai.VoiceProviderStats
	callID      string
	toolResults []ai.ToolResult
	closed      bool
}

func New() *Provider { return &Provider{events: make(chan ai.VoiceEvent, 16)} }
func (p *Provider) StartSession(ctx context.Context, cfg ai.VoiceSessionConfig) error {
	p.mu.Lock()
	p.events = make(chan ai.VoiceEvent, 16)
	p.closed = false
	p.stats = ai.VoiceProviderStats{}
	now := time.Now().UTC()
	p.stats.StartedAt = &now
	p.callID = cfg.CallID
	p.mu.Unlock()
	p.emit(ai.VoiceEvent{Type: ai.VoiceEventSessionStarted, CallID: cfg.CallID, At: now})
	p.emit(ai.VoiceEvent{Type: ai.VoiceEventAssistantTranscriptDelta, CallID: cfg.CallID, Text: "test provider connected", At: now})
	return nil
}
func (p *Provider) SendAudio(ctx context.Context, ch media.AudioChunk) error {
	p.mu.Lock()
	p.stats.InputAudioFrames++
	p.stats.InputAudioBytes += int64(len(ch.Data))
	p.mu.Unlock()
	return nil
}
func (p *Provider) SendToolResult(ctx context.Context, r ai.ToolResult) error {
	p.mu.Lock()
	p.toolResults = append(p.toolResults, r)
	p.stats.EventsSent++
	p.mu.Unlock()
	return nil
}
func (p *Provider) Close(ctx context.Context) error {
	p.mu.Lock()
	now := time.Now().UTC()
	p.stats.ClosedAt = &now
	callID := p.callID
	p.mu.Unlock()
	p.emit(ai.VoiceEvent{Type: ai.VoiceEventClosed, CallID: callID, At: now})
	p.closeEvents()
	return nil
}
func (p *Provider) Events() <-chan ai.VoiceEvent { return p.events }
func (p *Provider) Stats() ai.VoiceProviderStats { p.mu.Lock(); defer p.mu.Unlock(); return p.stats }
func (p *Provider) ToolResults() []ai.ToolResult {
	p.mu.Lock()
	defer p.mu.Unlock()
	out := make([]ai.ToolResult, len(p.toolResults))
	copy(out, p.toolResults)
	return out
}
func (p *Provider) EmitForTest(e ai.VoiceEvent) { p.emit(e) }
func (p *Provider) emit(e ai.VoiceEvent) {
	p.mu.Lock()
	defer p.mu.Unlock()
	p.stats.EventsSent++
	if p.closed {
		return
	}
	select {
	case p.events <- e:
	default:
	}
}
func (p *Provider) closeEvents() {
	p.mu.Lock()
	defer p.mu.Unlock()
	if !p.closed {
		close(p.events)
		p.closed = true
	}
}