package history

import (
	"context"
	"errors"
	"testing"
)

// seedMessages 追加 msgs 并返回它们（带存储分配的 id）。
func seedMessages(t *testing.T, st *Store, msgs ...Message) []Message {
	t.Helper()
	out := make([]Message, 0, len(msgs))
	for _, m := range msgs {
		if err := st.Append(context.Background(), m); err != nil {
			t.Fatalf("append %q: %v", m.Content, err)
		}
		out = append(out, m)
	}
	return out
}

func TestSearchSessionScopedNewestFirstAndPaged(t *testing.T) {
	t.Parallel()
	st := newStore(t)
	ctx := context.Background()
	seedMessages(t, st,
		Message{SessionID: MainSessionID, Role: RoleUser, Content: "hit one", CreatedAt: 1000},
		Message{SessionID: MainSessionID, Role: RoleAssistant, Content: "miss", CreatedAt: 1500},
		Message{SessionID: MainSessionID, Role: RoleUser, Content: "hit two", CreatedAt: 2000},
		Message{SessionID: MainSessionID, Role: RoleUser, Content: "hit three", CreatedAt: 3000},
		Message{SessionID: MainSessionID, Role: RoleUser, Content: "hit four", CreatedAt: 4000},
	)

	// 最新优先、两条命中的一页；不匹配的消息被跳过。
	page, err := st.Search(ctx, MainSessionID, "hit", 0, 2)
	if err != nil {
		t.Fatalf("search: %v", err)
	}
	if len(page) != 2 || page[0].CreatedAt != 4000 || page[1].CreatedAt != 3000 {
		t.Fatalf("page = %+v, want [4000 3000]", page)
	}

	// before 游标走到更旧的命中。
	older, err := st.Search(ctx, MainSessionID, "hit", 3000, 2)
	if err != nil {
		t.Fatalf("search older: %v", err)
	}
	if len(older) != 2 || older[0].CreatedAt != 2000 || older[1].CreatedAt != 1000 {
		t.Fatalf("older = %+v, want [2000 1000]", older)
	}

	// 空查询得到空（非 nil）切片，而不是整个会话。
	empty, err := st.Search(ctx, MainSessionID, "", 0, 10)
	if err != nil {
		t.Fatalf("search empty: %v", err)
	}
	if empty == nil || len(empty) != 0 {
		t.Fatalf("empty query = %#v, want empty non-nil", empty)
	}
}

func TestSearchCaseInsensitiveAndLiteralWildcards(t *testing.T) {
	t.Parallel()
	st := newStore(t)
	ctx := context.Background()
	seedMessages(t, st,
		Message{SessionID: MainSessionID, Role: RoleUser, Content: "Hello World", CreatedAt: 1000},
		Message{SessionID: MainSessionID, Role: RoleUser, Content: "100% done", CreatedAt: 2000},
		Message{SessionID: MainSessionID, Role: RoleUser, Content: "under_score", CreatedAt: 3000},
	)

	// ASCII 大小写不敏感的 LIKE。
	got, err := st.Search(ctx, MainSessionID, "hello", 0, 10)
	if err != nil {
		t.Fatalf("search hello: %v", err)
	}
	if len(got) != 1 || got[0].Content != "Hello World" {
		t.Fatalf("hello = %+v, want [Hello World]", got)
	}

	// 字面 % 不得充当通配符（否则它会匹配每一行）。
	pct, err := st.Search(ctx, MainSessionID, "100%", 0, 10)
	if err != nil {
		t.Fatalf("search 100%%: %v", err)
	}
	if len(pct) != 1 || pct[0].Content != "100% done" {
		t.Fatalf("100%% = %+v, want [100%% done]", pct)
	}

	// 字面 _ 只能匹配下划线，不能匹配任意单字符。
	us, err := st.Search(ctx, MainSessionID, "under_", 0, 10)
	if err != nil {
		t.Fatalf("search under_: %v", err)
	}
	if len(us) != 1 || us[0].Content != "under_score" {
		t.Fatalf("under_ = %+v, want [under_score]", us)
	}
}

// TestSearchNeverCrossesSessionBoundary 是红线守卫：搜索限定在单个会话内，因此
// 隔离的群聊/陌生人会话内容绝不浮现在主会话的结果里（反之亦然）。
func TestSearchNeverCrossesSessionBoundary(t *testing.T) {
	t.Parallel()
	st := newStore(t)
	ctx := context.Background()
	sub, err := st.NewSubSession(ctx, "owner")
	if err != nil {
		t.Fatalf("new sub: %v", err)
	}
	seedMessages(t, st,
		Message{SessionID: MainSessionID, Role: RoleUser, Content: "secret-token main", CreatedAt: 1000},
		Message{SessionID: sub, Role: RoleUser, Content: "secret-token sub", CreatedAt: 2000},
		Message{SessionID: "sess-group", Role: RoleUser, Content: "secret-token group", CreatedAt: 3000, SenderName: "第三方"},
	)

	main, err := st.Search(ctx, MainSessionID, "secret-token", 0, 10)
	if err != nil {
		t.Fatalf("search main: %v", err)
	}
	if len(main) != 1 || main[0].SessionID != MainSessionID {
		t.Fatalf("main search = %+v, want only the main-session hit", main)
	}
	subHits, err := st.Search(ctx, sub, "secret-token", 0, 10)
	if err != nil {
		t.Fatalf("search sub: %v", err)
	}
	if len(subHits) != 1 || subHits[0].SessionID != sub {
		t.Fatalf("sub search = %+v, want only the sub hit", subHits)
	}
}

func TestUpdateMessageContentOnly(t *testing.T) {
	t.Parallel()
	st := newStore(t)
	ctx := context.Background()
	seedMessages(t, st, Message{ID: "m1", SessionID: MainSessionID, Role: RoleUser, Content: "before", CreatedAt: 1000})

	got, err := st.UpdateMessage(ctx, "m1", "after")
	if err != nil {
		t.Fatalf("update: %v", err)
	}
	if got.ID != "m1" || got.Content != "after" || got.Role != RoleUser || got.CreatedAt != 1000 || got.SessionID != MainSessionID {
		t.Fatalf("updated = %+v, want content=after with role/ts/session preserved", got)
	}

	// 编辑要落盘，不能只是回显。
	listed, err := st.List(ctx, MainSessionID, 0, 10, "")
	if err != nil {
		t.Fatalf("list: %v", err)
	}
	if len(listed) != 1 || listed[0].Content != "after" {
		t.Fatalf("listed = %+v, want content=after", listed)
	}

	// 未知 id 返回哨兵错误。
	if _, err := st.UpdateMessage(ctx, "missing", "x"); !errors.Is(err, ErrMessageNotFound) {
		t.Fatalf("update missing err = %v, want ErrMessageNotFound", err)
	}
}

func TestDeleteMessage(t *testing.T) {
	t.Parallel()
	st := newStore(t)
	ctx := context.Background()
	seedMessages(t, st,
		Message{ID: "m1", SessionID: MainSessionID, Role: RoleUser, Content: "keep", CreatedAt: 1000},
		Message{ID: "m2", SessionID: MainSessionID, Role: RoleAssistant, Content: "drop", CreatedAt: 2000},
	)

	if err := st.DeleteMessage(ctx, "m2"); err != nil {
		t.Fatalf("delete: %v", err)
	}
	listed, err := st.List(ctx, MainSessionID, 0, 10, "")
	if err != nil {
		t.Fatalf("list: %v", err)
	}
	if len(listed) != 1 || listed[0].ID != "m1" {
		t.Fatalf("listed = %+v, want only m1", listed)
	}
	if err := st.DeleteMessage(ctx, "m2"); !errors.Is(err, ErrMessageNotFound) {
		t.Fatalf("delete again err = %v, want ErrMessageNotFound", err)
	}
}

func TestSetPinnedOrdersSessions(t *testing.T) {
	t.Parallel()
	st := newStore(t)
	ctx := context.Background()
	first, err := st.NewSubSession(ctx, "owner")
	if err != nil {
		t.Fatalf("new sub 1: %v", err)
	}
	second, err := st.NewSubSession(ctx, "owner")
	if err != nil {
		t.Fatalf("new sub 2: %v", err)
	}

	// 基线：主会话在前，子会话最旧优先。
	assertSessionOrder(t, st, []string{MainSessionID, first, second})

	// 置顶最新的子会话会把它浮到主会话之上。
	if err := st.SetPinned(ctx, second, true); err != nil {
		t.Fatalf("pin: %v", err)
	}
	assertSessionOrder(t, st, []string{second, MainSessionID, first})
	if metas := listMetas(t, st); !metas[0].Pinned {
		t.Fatalf("pinned session meta = %+v, want Pinned=true", metas[0])
	}

	// 取消置顶恢复基线顺序。
	if err := st.SetPinned(ctx, second, false); err != nil {
		t.Fatalf("unpin: %v", err)
	}
	assertSessionOrder(t, st, []string{MainSessionID, first, second})

	// 未知会话 id 是 not-found 错误。
	if err := st.SetPinned(ctx, "web:missing", true); !errors.Is(err, ErrSessionNotFound) {
		t.Fatalf("pin missing err = %v, want ErrSessionNotFound", err)
	}
}

// listMetas 返回 ListSessions 的结果，用于顺序/置顶断言。
func listMetas(t *testing.T, st *Store) []SessionMeta {
	t.Helper()
	metas, err := st.ListSessions(context.Background())
	if err != nil {
		t.Fatalf("list sessions: %v", err)
	}
	return metas
}

// assertSessionOrder 在 ListSessions 没有严格按 ids 的顺序返回时使测试失败。
func assertSessionOrder(t *testing.T, st *Store, ids []string) {
	t.Helper()
	metas := listMetas(t, st)
	got := make([]string, 0, len(metas))
	for _, m := range metas {
		got = append(got, m.ID)
	}
	if len(got) != len(ids) {
		t.Fatalf("session order = %v, want %v", got, ids)
	}
	for i := range ids {
		if got[i] != ids[i] {
			t.Fatalf("session order = %v, want %v", got, ids)
		}
	}
}