package channelbridge

import (
	"context"
	"strings"
	"testing"
	"time"

	"git.yeij.top/AskaEth/Cyrene_v2/internal/channel/adapter"
	"git.yeij.top/AskaEth/Cyrene_v2/internal/channel/session"
	"git.yeij.top/AskaEth/Cyrene_v2/internal/runtime/history"
	"git.yeij.top/AskaEth/Cyrene_v2/internal/runtime/loop"
	"git.yeij.top/AskaEth/Cyrene_v2/internal/runtime/model"
	"git.yeij.top/AskaEth/Cyrene_v2/internal/user"
)

// stubLightJudge 是可配置的 LightJudge，记录自己被咨询了多少次。
type stubLightJudge struct {
	resp  LightDecision
	err   error
	calls int
}

func (s *stubLightJudge) Judge(context.Context, LightInput) (LightDecision, error) {
	s.calls++
	return s.resp, s.err
}

// nonOwnerGroupMsg 返回一条来自成员发送者的第三方群消息，带
// 指定的提及。内容不做加工，便于测试自行控制信号。
func nonOwnerGroupMsg(content string, mentions ...adapter.Mention) adapter.UnifiedMessage {
	return adapter.UnifiedMessage{
		Platform: "telegram", ChannelID: "-20", ChannelType: adapter.ChannelGroup,
		GroupID: "-20", GroupName: "Gang", SenderID: "9", SenderName: "张三",
		Sender: adapter.Actor{Role: adapter.RoleMember}, Mentions: mentions,
		Content: content, ContentType: adapter.ContentText,
	}
}

// nonOwnerSession 是非主人测试所用的受限（群聊 / 陌生人）会话
// 绑定：记忆只读、无主人。
func nonOwnerSession() session.Session {
	return session.Session{SessionID: "sess-g", IsGroup: true, Owner: false, MemWritable: false}
}

func TestNonOwnerSilencedRegisteredOnly(t *testing.T) {
	t.Parallel()

	chat := &stubChatter{res: &loop.Result{Text: "不该回"}}
	sess := &stubSessions{sess: nonOwnerSession()}
	hist := &captureHistory{}
	b, err := New(Options{
		Loop: chat, Sessions: sess, Owner: &user.OwnerProfile{}, History: hist,
		Now: func() time.Time { return time.Date(2026, 1, 1, 12, 0, 0, 0, time.UTC) },
	})
	if err != nil {
		t.Fatalf("New: %v", err)
	}

	// 无 @/关键词/名字信号的非主人消息被静默（设计/12 §6 策略二）：
	// 它只登记到隔离会话日志，绝不驱动循环。
	b.process(context.Background(), nonOwnerGroupMsg("hello all"))

	if chat.sessionID != "" || len(chat.messages) != 0 {
		t.Fatalf("loop ran for a no-signal non-owner message: session=%q messages=%+v", chat.sessionID, chat.messages)
	}
	recs := hist.records()
	if len(recs) != 1 {
		t.Fatalf("records = %d, want 1 (inbound registered, no assistant reply)", len(recs))
	}
	if recs[0].SessionID != "sess-g" || recs[0].Role != history.RoleUser || recs[0].Content != "hello all" {
		t.Fatalf("registered record = %+v, want isolated sess-g user 'hello all'", recs[0])
	}
}

func TestNonOwnerMentionResponds(t *testing.T) {
	t.Parallel()

	chat := &stubChatter{res: &loop.Result{Text: "收到"}}
	sess := &stubSessions{sess: nonOwnerSession()}
	hist := &captureHistory{}
	b, err := New(Options{
		Loop: chat, Sessions: sess, Owner: &user.OwnerProfile{}, History: hist,
		Now: func() time.Time { return time.Date(2026, 1, 1, 12, 0, 0, 0, time.UTC) },
	})
	if err != nil {
		t.Fatalf("New: %v", err)
	}

	// 被点名（提及）的非主人消息值得回复（策略二），因此它
	// 针对隔离群会话驱动完整循环。
	b.process(context.Background(), nonOwnerGroupMsg("hello", adapter.Mention{UserID: "bot"}))

	if chat.sessionID != "sess-g" {
		t.Fatalf("loop session = %q, want isolated sess-g", chat.sessionID)
	}
	// 受限群上下文 → 第三方边界系统消息加上
	// 用户消息（design/16 §4.6 §1），与 TestGroupMessageThirdPartySenderNameAndBoundary 一致。
	if len(chat.messages) != 2 || chat.messages[1].Role != model.RoleUser {
		t.Fatalf("loop messages = %+v, want boundary + user", chat.messages)
	}
	if chat.messages[1].Content[0].Text != "hello" {
		t.Fatalf("loop user text = %q, want undecorated 'hello'", chat.messages[1].Content[0].Text)
	}
	if !strings.Contains(chat.messages[0].Content[0].Text, "群「Gang」") {
		t.Fatalf("origin/boundary system = %q, want group Gang", chat.messages[0].Content[0].Text)
	}
}

func TestNonOwnerHighValueKeywordResponds(t *testing.T) {
	t.Parallel()

	chat := &stubChatter{res: &loop.Result{Text: "我看看"}}
	sess := &stubSessions{sess: nonOwnerSession()}
	b, err := New(Options{
		Loop: chat, Sessions: sess, Owner: &user.OwnerProfile{},
		Now: func() time.Time { return time.Date(2026, 1, 1, 12, 0, 0, 0, time.UTC) },
	})
	if err != nil {
		t.Fatalf("New: %v", err)
	}

	// 高价值关键词（求助）即使没有 @ 也值得回复（策略二）。
	b.process(context.Background(), nonOwnerGroupMsg("有人在吗，紧急求助"))
	if chat.sessionID != "sess-g" {
		t.Fatalf("loop session = %q, want isolated sess-g for a high-value keyword", chat.sessionID)
	}
}

func TestNonOwnerQuietHoursSilenced(t *testing.T) {
	t.Parallel()

	chat := &stubChatter{res: &loop.Result{Text: "不该回"}}
	sess := &stubSessions{sess: nonOwnerSession()}
	hist := &captureHistory{}
	b, err := New(Options{
		Loop: chat, Sessions: sess, Owner: &user.OwnerProfile{}, History: hist,
		QuietStartHour: 23, QuietEndHour: 7,
		Now: func() time.Time { return time.Date(2026, 1, 1, 2, 0, 0, 0, time.UTC) },
	})
	if err != nil {
		t.Fatalf("New: %v", err)
	}

	// 策略五：安静时段内无信号的非主人消息被静默——
	// 只登记、不回复。
	b.process(context.Background(), nonOwnerGroupMsg("hello all"))

	if chat.sessionID != "" || len(chat.messages) != 0 {
		t.Fatalf("loop ran during quiet hours for a no-signal message: session=%q messages=%+v", chat.sessionID, chat.messages)
	}
	if len(hist.records()) != 1 {
		t.Fatalf("records = %d, want 1 (registered, no reply)", len(hist.records()))
	}
}

func TestNonOwnerQuietHoursMentionResponds(t *testing.T) {
	t.Parallel()

	chat := &stubChatter{res: &loop.Result{Text: "在的"}}
	sess := &stubSessions{sess: nonOwnerSession()}
	b, err := New(Options{
		Loop: chat, Sessions: sess, Owner: &user.OwnerProfile{},
		QuietStartHour: 23, QuietEndHour: 7,
		Now: func() time.Time { return time.Date(2026, 1, 1, 2, 0, 0, 0, time.UTC) },
	})
	if err != nil {
		t.Fatalf("New: %v", err)
	}

	// 策略五不是硬性静默：被直接点名的消息在安静时段
	// 仍会得到回复。
	b.process(context.Background(), nonOwnerGroupMsg("在吗", adapter.Mention{UserID: "bot"}))
	if chat.sessionID != "sess-g" {
		t.Fatalf("loop session = %q, want sess-g (mention should break quiet-hours silence)", chat.sessionID)
	}
}

func TestOwnerUnaffectedInQuietHours(t *testing.T) {
	t.Parallel()

	chat := &stubChatter{res: &loop.Result{Text: "主人好"}}
	sess := &stubSessions{sess: session.Session{SessionID: "sess-1", Owner: true, MemWritable: true}}
	ad := &fakeAdapter{name: "telegram"}
	b, err := New(Options{
		Loop: chat, Sessions: sess, Owner: testOwnerProfile("telegram", "100"), History: &captureHistory{},
		QuietStartHour: 23, QuietEndHour: 7,
		Now: func() time.Time { return time.Date(2026, 1, 1, 2, 0, 0, 0, time.UTC) },
	})
	if err != nil {
		t.Fatalf("New: %v", err)
	}
	b.Add(ad)

	// 主人消息绝不被拦，即使处于安静时段（策略五只管
	// 非主人流量）：主人私聊仍路由到 Web 主会话
	// 并回复。
	b.process(context.Background(), directMessage())

	if chat.sessionID != history.MainSessionID {
		t.Fatalf("owner loop session = %q, want %q", chat.sessionID, history.MainSessionID)
	}
	if len(ad.sends) != 1 || ad.sends[0].Content != "主人好" {
		t.Fatalf("owner reply = %+v, want '主人好'", ad.sends)
	}
}

func TestLightJudgeConsultedWhenInconclusive(t *testing.T) {
	t.Parallel()

	// 白天无信号的消息对规则而言无结论，因此注入的
	// LightJudge 获得一次判断机会（设计/12 §6 策略二：规则不确定才轻 LLM）。
	judge := &stubLightJudge{resp: LightDecision{Respond: true, Reason: "值得回"}}
	chat := &stubChatter{res: &loop.Result{Text: "嗯"}}
	sess := &stubSessions{sess: nonOwnerSession()}
	b, err := New(Options{
		Loop: chat, Sessions: sess, Owner: &user.OwnerProfile{},
		Light: judge,
		Now:   func() time.Time { return time.Date(2026, 1, 1, 12, 0, 0, 0, time.UTC) },
	})
	if err != nil {
		t.Fatalf("New: %v", err)
	}

	b.process(context.Background(), nonOwnerGroupMsg("今天天气不错"))
	if judge.calls != 1 {
		t.Fatalf("light judge calls = %d, want 1 (inconclusive rules escalated)", judge.calls)
	}
	if chat.sessionID != "sess-g" {
		t.Fatalf("loop session = %q, want sess-g (judge said respond)", chat.sessionID)
	}
}

func TestLightJudgeSilenceIsRespected(t *testing.T) {
	t.Parallel()

	judge := &stubLightJudge{resp: LightDecision{Respond: false, Reason: "不值得"}}
	chat := &stubChatter{res: &loop.Result{Text: "不该回"}}
	sess := &stubSessions{sess: nonOwnerSession()}
	hist := &captureHistory{}
	b, err := New(Options{
		Loop: chat, Sessions: sess, Owner: &user.OwnerProfile{}, History: hist,
		Light: judge,
		Now:   func() time.Time { return time.Date(2026, 1, 1, 12, 0, 0, 0, time.UTC) },
	})
	if err != nil {
		t.Fatalf("New: %v", err)
	}

	b.process(context.Background(), nonOwnerGroupMsg("今天天气不错"))
	if judge.calls != 1 {
		t.Fatalf("light judge calls = %d, want 1", judge.calls)
	}
	if chat.sessionID != "" {
		t.Fatalf("loop ran after the judge said silence: session=%q", chat.sessionID)
	}
	if len(hist.records()) != 1 {
		t.Fatalf("records = %d, want 1 (registered, no reply)", len(hist.records()))
	}
}

func TestLightJudgeErrorFailsClosedToSilence(t *testing.T) {
	t.Parallel()

	judge := &stubLightJudge{err: context.DeadlineExceeded}
	chat := &stubChatter{res: &loop.Result{Text: "不该回"}}
	sess := &stubSessions{sess: nonOwnerSession()}
	hist := &captureHistory{}
	b, err := New(Options{
		Loop: chat, Sessions: sess, Owner: &user.OwnerProfile{}, History: hist,
		Light: judge,
		Now:   func() time.Time { return time.Date(2026, 1, 1, 12, 0, 0, 0, time.UTC) },
	})
	if err != nil {
		t.Fatalf("New: %v", err)
	}

	// 轻量判定器出错时失败关闭为静默（不打扰为第一原则）。
	b.process(context.Background(), nonOwnerGroupMsg("今天天气不错"))
	if judge.calls != 1 {
		t.Fatalf("light judge calls = %d, want 1", judge.calls)
	}
	if chat.sessionID != "" || len(chat.messages) != 0 {
		t.Fatalf("loop ran after judge error: session=%q messages=%+v", chat.sessionID, chat.messages)
	}
	if len(hist.records()) != 1 {
		t.Fatalf("records = %d, want 1 (registered, no reply)", len(hist.records()))
	}
}