package backthink

import (
	"context"
	"database/sql"
	"io"
	"log/slog"
	"sync"
	"testing"
	"time"

	"git.yeij.top/AskaEth/Cyrene_v2/internal/channel/adapter"
	"git.yeij.top/AskaEth/Cyrene_v2/internal/db"
)

// mockThinker 记录每次 Think 调用并返回固定结论。它
// 尊重 ctx 取消，好让 Stop 能排空挂住的轮次。
type mockThinker struct {
	mu    sync.Mutex
	text  string
	err   error
	sleep time.Duration
	calls int
	last  string
}

func (m *mockThinker) Think(ctx context.Context, sessionID, trigger string) (string, error) {
	if err := ctx.Err(); err != nil {
		return "", err
	}
	if m.sleep > 0 {
		select {
		case <-ctx.Done():
			return "", ctx.Err()
		case <-time.After(m.sleep):
		}
	}
	m.mu.Lock()
	m.calls++
	m.last = trigger
	m.mu.Unlock()
	return m.text, m.err
}

func (m *mockThinker) count() int          { m.mu.Lock(); defer m.mu.Unlock(); return m.calls }
func (m *mockThinker) lastTrigger() string { m.mu.Lock(); defer m.mu.Unlock(); return m.last }

// mockState 返回固定的 UserState。
type mockState struct{ state UserState }

func (m *mockState) Current(context.Context) (UserState, error) { return m.state, nil }

// mockPusher 记录 Push 调用并返回固定结果。
type mockPusher struct {
	mu       sync.Mutex
	result   PushResult
	calls    int
	lastMsg  adapter.UnifiedMessage
	lastHint string
}

func (p *mockPusher) Push(ctx context.Context, req PushRequest) PushResult {
	p.mu.Lock()
	p.calls++
	p.lastMsg = req.Message
	p.lastHint = req.ChannelHint
	p.mu.Unlock()
	return p.result
}

func (p *mockPusher) count() int { p.mu.Lock(); defer p.mu.Unlock(); return p.calls }

// mockActive 实现 ActiveClient。
type mockActive struct {
	mu        sync.Mutex
	n         int
	persisted bool
	err       error
	calls     int
	last      adapter.UnifiedMessage
}

func (m *mockActive) SendProactive(ctx context.Context, msg adapter.UnifiedMessage) (ProactiveDelivery, error) {
	m.mu.Lock()
	m.calls++
	m.last = msg
	n, persisted, err := m.n, m.persisted, m.err
	m.mu.Unlock()
	return ProactiveDelivery{Connections: n, Persisted: persisted}, err
}

// mockIMAdapter 实现 IMAdapter。
type mockIMAdapter struct {
	mu    sync.Mutex
	err   error
	calls int
	last  adapter.UnifiedMessage
}

func (m *mockIMAdapter) SendProactive(ctx context.Context, msg adapter.UnifiedMessage) error {
	m.mu.Lock()
	m.calls++
	m.last = msg
	m.mu.Unlock()
	return m.err
}

func (m *mockIMAdapter) count() int { m.mu.Lock(); defer m.mu.Unlock(); return m.calls }

// mockGate 实现 PushGate。
type mockGate struct{ allow bool }

func (g *mockGate) Allow(context.Context, PushKind) bool { return g.allow }
func (g *mockGate) RecordPush(PushKind)                  {}

// newTestDB 为单个测试打开一个隔离的内存 SQLite 句柄，并在
// 清理时关闭它。
func newTestDB(t *testing.T) *sql.DB {
	t.Helper()
	h, err := db.Open(context.Background(), ":memory:", nil)
	if err != nil {
		t.Fatalf("open test db: %v", err)
	}
	t.Cleanup(func() { _ = h.Close() })
	return h
}

// discardLog 返回一个什么都不写的日志器。
func discardLog() *slog.Logger {
	return slog.New(slog.NewTextHandler(io.Discard, nil))
}

// eventually 轮询 cond 直到它为真或超过期限。
func eventually(t *testing.T, timeout time.Duration, cond func() bool) {
	t.Helper()
	deadline := time.Now().Add(timeout)
	for time.Now().Before(deadline) {
		if cond() {
			return
		}
		time.Sleep(5 * time.Millisecond)
	}
	t.Fatalf("condition not met within %v", timeout)
}