package history

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

// seedMessages appends msgs and returns them with their store-assigned ids.
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},
	)

	// Newest-first page of two hits; the non-matching message is skipped.
	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 cursor walks to the older hits.
	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)
	}

	// An empty query yields an empty (non-nil) slice, not the whole session.
	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 case-insensitive 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)
	}

	// A literal % must not act as a wildcard (else it would match every row).
	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)
	}

	// A literal _ must match only the underscore, not any single character.
	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 is the red-line guard: a search is scoped to
// one session, so an isolated group/stranger session's content can never surface in
// the main session's results (or vice versa).
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)
	}

	// The edit is persisted, not just echoed.
	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)
	}

	// An unknown id returns the sentinel.
	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)
	}

	// Baseline: main first, subs oldest-first.
	assertSessionOrder(t, st, []string{MainSessionID, first, second})

	// Pinning the newest sub floats it above the main session.
	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])
	}

	// Unpinning restores the baseline order.
	if err := st.SetPinned(ctx, second, false); err != nil {
		t.Fatalf("unpin: %v", err)
	}
	assertSessionOrder(t, st, []string{MainSessionID, first, second})

	// An unknown session id is a not-found error.
	if err := st.SetPinned(ctx, "web:missing", true); !errors.Is(err, ErrSessionNotFound) {
		t.Fatalf("pin missing err = %v, want ErrSessionNotFound", err)
	}
}

// listMetas returns ListSessions output for order/pin assertions.
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 fails unless ListSessions returns exactly ids in order.
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)
		}
	}
}