package repo

import (
	"context"
	"testing"

	"github.com/agentmail/gateway/internal/db"
	"github.com/google/uuid"
)

/*
已读语义：**按读者**记录，而不是邮件行上的一个全局列。

2026-09-13 线上实测：`jianf → dsh` 那封打了招呼、抄送 pi/opencode/zcode/homeagent 的
邮件里，pi 最先回复 ⇒ 它读过了 ⇒ 这封对 dsh 也变成 `read` ⇒ dsh 的
`read_inbox`（默认 unread）返回空，它只能按提示词里的 mail_id 直接读，并在回信里
写下"收件箱列表未展示它，直接按 mail_id 读取成功"。

同一封邮件**对每个读者各自算未读**，是这一组判据要钉住的不变量。
*/

// unreadList 返回 ListInbox 在 unread 过滤下给出的邮件 id。
func unreadList(t *testing.T, reader string) []uuid.UUID {
	t.Helper()
	mails, err := ListInbox(context.Background(), reader, "unread", 50)
	if err != nil {
		t.Fatal(err)
	}
	out := []uuid.UUID{}
	for _, m := range mails {
		out = append(out, m.ID)
	}
	return out
}

func hasID(list []uuid.UUID, id uuid.UUID) bool {
	for _, x := range list {
		if x == id {
			return true
		}
	}
	return false
}

// statusSeenBy 返回 ListInbox 在 all 过滤下、某个读者看到的那封邮件的 status。
func statusSeenBy(t *testing.T, reader string, id uuid.UUID) string {
	t.Helper()
	mails, err := ListInbox(context.Background(), reader, "all", 50)
	if err != nil {
		t.Fatal(err)
	}
	for _, m := range mails {
		if m.ID == id {
			return m.Status
		}
	}
	t.Fatalf("读者 %s 的收件箱里没有 %s", reader, id)
	return ""
}

func TestReadStateIsPerRecipient(t *testing.T) {
	setupTestDB(t)
	ctx := context.Background()

	// 一封主收件人 alice、抄送 bob 的邮件 —— 正是线上那封信的形状
	id := seedMailTo(t, "alice", "bob")

	// 初始：两边都未读
	if n, _ := CountUnread(ctx, "alice"); n != 1 {
		t.Fatalf("alice 初始未读 = %d，期望 1", n)
	}
	if n, _ := CountUnread(ctx, "bob"); n != 1 {
		t.Fatalf("bob 初始未读 = %d，期望 1", n)
	}

	// alice 读掉它
	if err := MarkMailRead(ctx, id, "alice"); err != nil {
		t.Fatal(err)
	}

	// ★ 核心判据：alice 的未读清了，bob 的**必须还在**
	if n, _ := CountUnread(ctx, "alice"); n != 0 {
		t.Fatalf("alice 读过后未读 = %d，期望 0", n)
	}
	if n, _ := CountUnread(ctx, "bob"); n != 1 {
		t.Fatalf("★ bob 没读，未读却变成了 %d —— 这正是要修的缺陷（任一收件人读掉，所有人变已读）", n)
	}
	if !hasID(unreadList(t, "bob"), id) {
		t.Fatal("★ bob 的 unread 收件箱里必须还能看到这封信")
	}
	if hasID(unreadList(t, "alice"), id) {
		t.Fatal("alice 自己读过了，unread 收件箱不该再有它")
	}

	// 同一封邮件，两个读者看到的状态不同 —— 这就是"按读者"的直接证据
	if got := statusSeenBy(t, "alice", id); got != "read" {
		t.Fatalf("alice 看到的 status = %q，期望 read", got)
	}
	if got := statusSeenBy(t, "bob", id); got != "unread" {
		t.Fatalf("★ bob 看到的 status = %q，期望 unread（同一封邮件，按读者算）", got)
	}

	// 反向对照：bob 也读掉 → 两边都清
	if err := MarkMailRead(ctx, id, "bob"); err != nil {
		t.Fatal(err)
	}
	if n, _ := CountUnread(ctx, "bob"); n != 0 {
		t.Fatalf("bob 读过后未读 = %d，期望 0", n)
	}
}

// CountUnreadInSession 是会话列表徽标用的，同样必须按读者算。
func TestCountUnreadInSessionIsPerRecipient(t *testing.T) {
	setupTestDB(t)
	ctx := context.Background()

	id := seedMailTo(t, "alice", "bob")
	var sid uuid.UUID
	if err := db.DB.QueryRowContext(ctx, `SELECT session_id FROM mails WHERE mail_id = $1`, id).Scan(&sid); err != nil {
		t.Fatal(err)
	}

	if err := MarkMailRead(ctx, id, "alice"); err != nil {
		t.Fatal(err)
	}
	if n, _ := CountUnreadInSession(ctx, "alice", sid); n != 0 {
		t.Fatalf("alice 会话内未读 = %d，期望 0", n)
	}
	if n, _ := CountUnreadInSession(ctx, "bob", sid); n != 1 {
		t.Fatalf("★ bob 会话内未读 = %d，期望 1（徽标不能因为别人读过就归零）", n)
	}
}

// 批量标已读（Agent 的 /mail/read）同样只影响调用者自己。
func TestBulkMarkReadOnlyAffectsCaller(t *testing.T) {
	setupTestDB(t)
	ctx := context.Background()

	id := seedMailTo(t, "alice", "bob")
	if _, err := MarkMailsReadFor(ctx, "alice", []uuid.UUID{id}); err != nil {
		t.Fatal(err)
	}
	if n, _ := CountUnread(ctx, "bob"); n != 1 {
		t.Fatalf("★ 批量标已读后 bob 未读 = %d，期望 1", n)
	}

	// 全部标已读（不带 id）也只能标自己收件箱里的
	if _, err := MarkAllInboxReadFor(ctx, "alice"); err != nil {
		t.Fatal(err)
	}
	if n, _ := CountUnread(ctx, "bob"); n != 1 {
		t.Fatalf("★ 全标已读后 bob 未读 = %d，期望 1", n)
	}
}

// 归档是**会话级**的全局状态：归档后对所有人都不可见（unread 与 all 都不给），
// 而且不能因为"没人读过"就把它算成未读。
func TestArchivedStaysArchivedForEveryone(t *testing.T) {
	setupTestDB(t)
	ctx := context.Background()

	id := seedMailTo(t, "alice", "bob")
	var sid uuid.UUID
	if err := db.DB.QueryRowContext(ctx, `SELECT session_id FROM mails WHERE mail_id = $1`, id).Scan(&sid); err != nil {
		t.Fatal(err)
	}
	if err := ArchiveSession(ctx, sid); err != nil {
		t.Fatal(err)
	}

	if n, _ := CountUnread(ctx, "bob"); n != 0 {
		t.Fatalf("归档会话里的邮件不该计入未读，实际 %d", n)
	}
	if hasID(unreadList(t, "bob"), id) {
		t.Fatal("归档邮件的 status 是 archived，不该出现在 unread 收件箱")
	}
	// ListInbox 会整体排除归档会话（`s.status <> 'archived'`），所以它在
	// `all` 里也不出现 —— 归档是"从收件箱拿走"，不是"标成已读"。
	mails, err := ListInbox(ctx, "bob", "all", 50)
	if err != nil {
		t.Fatal(err)
	}
	for _, m := range mails {
		if m.ID == id {
			t.Fatal("归档会话里的邮件不该出现在收件箱列表（all 也不该有）")
		}
	}
}

// 权限决策把邮件记成**决策人**已读：同一条线索上其他收件人不受影响。
func TestPermissionDecisionMarksOnlyDecider(t *testing.T) {
	setupTestDB(t)
	ctx := context.Background()

	// 一封 alice 收、bob 抄送的权限邮件
	id := seedMailTo(t, "alice", "bob")
	if _, err := db.DB.ExecContext(ctx,
		`INSERT INTO permission_requests (mail_id, session_id, agent_name, question, options, kind)
		 SELECT mail_id, session_id, 'bot', 'q', '["同意","拒绝"]', 'permission' FROM mails WHERE mail_id = $1`,
		id); err != nil {
		t.Fatal(err)
	}
	if _, err := DecidePermission(ctx, id, "alice", "同意"); err != nil {
		t.Fatal(err)
	}
	if n, _ := CountUnread(ctx, "alice"); n != 0 {
		t.Fatalf("决策人 alice 未读 = %d，期望 0", n)
	}
	if n, _ := CountUnread(ctx, "bob"); n != 1 {
		t.Fatalf("★ bob 未读 = %d，期望 1（决策是 alice 做的，不该替他标记已读）", n)
	}
}