package gateway

import (
	"context"
	"encoding/json"
	"io"
	"log/slog"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"

	"git.yeij.top/AskaEth/Cyrene_v2/internal/auth"
	"git.yeij.top/AskaEth/Cyrene_v2/internal/db"
	"git.yeij.top/AskaEth/Cyrene_v2/internal/runtime/history"
	"git.yeij.top/AskaEth/Cyrene_v2/internal/runtime/model"
)

// testLogger returns a logger that writes nowhere, keeping test output clean.
func testLogger() *slog.Logger {
	return slog.New(slog.NewTextHandler(io.Discard, nil))
}

// newHistoryEnv builds a Server wired with a real in-memory history store, returning the
// httptest server, the JWT service and the underlying history store.
func newHistoryEnv(t *testing.T) (*Server, *httptest.Server, *auth.JWTService, *history.Store) {
	t.Helper()
	ctx := context.Background()
	conn, err := db.Open(ctx, ":memory:", testLogger())
	if err != nil {
		t.Fatalf("open memory db: %v", err)
	}
	t.Cleanup(func() { _ = conn.Close() })
	st, err := history.NewStore(ctx, conn, testLogger())
	if err != nil {
		t.Fatalf("new history store: %v", err)
	}
	srv, ts, jwt := buildEnv(t, cfgDefault(), Deps{History: st})
	return srv, ts, jwt, st
}

// decodeDataSlice decodes the {data:[...]} envelope into the given slice target.
func decodeDataSlice(t *testing.T, body []byte, out any) {
	t.Helper()
	if err := json.Unmarshal(decodeBody(t, body)["data"], out); err != nil {
		t.Fatalf("decode data: %v (body=%s)", err, body)
	}
}

func TestHistoryCreateAndListSessions(t *testing.T) {
	t.Parallel()
	_, ts, jwt, _ := newHistoryEnv(t)
	tok := signAny(t, jwt, "acct", auth.RoleOwner)

	// Fresh store always lists the main session.
	resp, body := doReq(t, http.MethodGet, ts.URL+"/api/v1/sessions", nil, tok)
	if resp.StatusCode != http.StatusOK {
		t.Fatalf("list status = %d, want 200 (body=%s)", resp.StatusCode, body)
	}
	var initial []historySessionSummary
	decodeDataSlice(t, body, &initial)
	if len(initial) != 1 || initial[0].ID != history.MainSessionID || initial[0].Type != history.SessionMain {
		t.Fatalf("initial sessions = %+v, want [main web]", initial)
	}

	// Create a sub session.
	resp, body = doReq(t, http.MethodPost, ts.URL+"/api/v1/sessions", nil, tok)
	if resp.StatusCode != http.StatusCreated {
		t.Fatalf("create status = %d, want 201 (body=%s)", resp.StatusCode, body)
	}
	var created struct {
		SessionID string `json:"sessionId"`
	}
	if err := json.Unmarshal(decodeBody(t, body)["data"], &created); err != nil {
		t.Fatalf("decode create data: %v (body=%s)", err, body)
	}
	if !strings.HasPrefix(created.SessionID, history.MainSessionID+":") {
		t.Fatalf("sessionId = %q, want prefix web:", created.SessionID)
	}

	// Now main first, then the sub.
	resp, body = doReq(t, http.MethodGet, ts.URL+"/api/v1/sessions", nil, tok)
	if resp.StatusCode != http.StatusOK {
		t.Fatalf("list status = %d, want 200 (body=%s)", resp.StatusCode, body)
	}
	var sessions []historySessionSummary
	decodeDataSlice(t, body, &sessions)
	if len(sessions) != 2 || sessions[0].ID != history.MainSessionID || sessions[0].Type != history.SessionMain {
		t.Fatalf("sessions[0] = %+v, want main web first", sessions[0])
	}
	if sessions[1].ID != created.SessionID || sessions[1].Type != history.SessionSub {
		t.Fatalf("sessions[1] = %+v, want sub %s", sessions[1], created.SessionID)
	}
}

func TestHistoryListMessagesPagination(t *testing.T) {
	t.Parallel()
	_, ts, jwt, st := newHistoryEnv(t)
	ctx := context.Background()
	// Seed the main session with messages at ascending ms timestamps.
	for _, ts := range []int64{1000, 2000, 3000, 4000} {
		if err := st.Append(ctx, history.Message{SessionID: history.MainSessionID, Role: history.RoleUser, Content: "x", CreatedAt: ts}); err != nil {
			t.Fatalf("seed %d: %v", ts, err)
		}
	}
	tok := signAny(t, jwt, "acct", auth.RoleOwner)

	// Newest page of 2.
	resp, body := doReq(t, http.MethodGet, ts.URL+"/api/v1/sessions/"+history.MainSessionID+"/messages?limit=2", nil, tok)
	if resp.StatusCode != http.StatusOK {
		t.Fatalf("first page status = %d, want 200 (body=%s)", resp.StatusCode, body)
	}
	var page []historyMessage
	decodeDataSlice(t, body, &page)
	if len(page) != 2 || page[0].CreatedAt != 4000 || page[1].CreatedAt != 3000 {
		t.Fatalf("first page = %+v, want [4000 3000]", page)
	}

	// Cursor before the page's oldest (3000) → older page [2000 1000].
	resp, body = doReq(t, http.MethodGet, ts.URL+"/api/v1/sessions/"+history.MainSessionID+"/messages?before=3000&limit=2", nil, tok)
	if resp.StatusCode != http.StatusOK {
		t.Fatalf("older page status = %d, want 200 (body=%s)", resp.StatusCode, body)
	}
	var older []historyMessage
	decodeDataSlice(t, body, &older)
	if len(older) != 2 || older[0].CreatedAt != 2000 || older[1].CreatedAt != 1000 {
		t.Fatalf("older page = %+v, want [2000 1000]", older)
	}

	// Invalid limit/before → 400.
	resp, body = doReq(t, http.MethodGet, ts.URL+"/api/v1/sessions/"+history.MainSessionID+"/messages?limit=abc", nil, tok)
	if resp.StatusCode != http.StatusBadRequest {
		t.Fatalf("invalid limit status = %d, want 400 (body=%s)", resp.StatusCode, body)
	}
}

func TestHistoryListMessagesPlatformFilter(t *testing.T) {
	t.Parallel()
	_, ts, jwt, st := newHistoryEnv(t)
	ctx := context.Background()
	if err := st.Append(ctx, history.Message{SessionID: history.MainSessionID, Role: history.RoleUser, Content: "web", Platform: history.PlatformWeb, CreatedAt: 1000}); err != nil {
		t.Fatalf("seed web: %v", err)
	}
	if err := st.Append(ctx, history.Message{SessionID: history.MainSessionID, Role: history.RoleUser, Content: "tg", Platform: "telegram", CreatedAt: 2000}); err != nil {
		t.Fatalf("seed tg: %v", err)
	}
	tok := signAny(t, jwt, "acct", auth.RoleOwner)

	// No platform → the full main session (both lanes).
	resp, body := doReq(t, http.MethodGet, ts.URL+"/api/v1/sessions/"+history.MainSessionID+"/messages?limit=10", nil, tok)
	if resp.StatusCode != http.StatusOK {
		t.Fatalf("all status = %d, want 200 (body=%s)", resp.StatusCode, body)
	}
	var all []historyMessage
	decodeDataSlice(t, body, &all)
	if len(all) != 2 {
		t.Fatalf("all = %d, want 2", len(all))
	}

	// ?platform=telegram → only the telegram lane, and the DTO carries platform.
	resp, body = doReq(t, http.MethodGet, ts.URL+"/api/v1/sessions/"+history.MainSessionID+"/messages?limit=10&platform=telegram", nil, tok)
	if resp.StatusCode != http.StatusOK {
		t.Fatalf("platform status = %d, want 200 (body=%s)", resp.StatusCode, body)
	}
	var tg []historyMessage
	decodeDataSlice(t, body, &tg)
	if len(tg) != 1 || tg[0].Content != "tg" || tg[0].Platform != "telegram" {
		t.Fatalf("telegram page = %+v, want one platform=telegram message", tg)
	}
}

// handleChannelMessagesGranularity exercises the admin adapter log endpoint at each
// granularity: a single adapter config (?adapter=), a whole platform (?platform=),
// and the full IM adapter overview (neither). It asserts adapterId is carried on the
// DTO so the panel can label the source adapter config.
func TestHistoryChannelMessagesGranularity(t *testing.T) {
	t.Parallel()
	_, ts, jwt, st := newHistoryEnv(t)
	ctx := context.Background()
	for _, m := range []history.Message{
		{SessionID: history.MainSessionID, Role: history.RoleUser, Content: "kook-owner", Platform: "kook", AdapterID: "kook:3bef", CreatedAt: 1000},
		{SessionID: "sess-g", Role: history.RoleUser, Content: "kook-group", Platform: "kook", AdapterID: "kook:3bef", SenderName: "张三", CreatedAt: 2000},
		{SessionID: "sess-t", Role: history.RoleUser, Content: "tg-group", Platform: "telegram", AdapterID: "telegram:conf0", CreatedAt: 3000},
		{SessionID: history.MainSessionID, Role: history.RoleUser, Content: "web-msg", Platform: history.PlatformWeb, CreatedAt: 4000},
	} {
		if err := st.Append(ctx, m); err != nil {
			t.Fatalf("seed %q: %v", m.Content, err)
		}
	}
	tok := signAny(t, jwt, "acct", auth.RoleOwner)

	// ?adapter=kook:3bef → only that adapter config, both the owner mirror and the
	// group message, newest first, and the DTO carries adapterId.
	resp, body := doReq(t, http.MethodGet, ts.URL+"/api/v1/admin/channels/messages?adapter=kook:3bef", nil, tok)
	if resp.StatusCode != http.StatusOK {
		t.Fatalf("adapter status = %d, want 200 (body=%s)", resp.StatusCode, body)
	}
	var byAdapter []historyMessage
	decodeDataSlice(t, body, &byAdapter)
	if len(byAdapter) != 2 {
		t.Fatalf("adapter page = %d, want 2 (%+v)", len(byAdapter), byAdapter)
	}
	if byAdapter[0].Content != "kook-group" || byAdapter[0].AdapterID != "kook:3bef" {
		t.Fatalf("adapter[0] = %+v, want kook-group with adapterId", byAdapter[0])
	}
	if byAdapter[1].Content != "kook-owner" || byAdapter[1].SessionID != history.MainSessionID {
		t.Fatalf("adapter[1] = %+v, want kook-owner on main session", byAdapter[1])
	}

	// ?platform=kook → the platform lane across isolated sessions (owner-private
	// mirror excluded, matching handleChannelPlatformLog semantics).
	resp, body = doReq(t, http.MethodGet, ts.URL+"/api/v1/admin/channels/messages?platform=kook", nil, tok)
	if resp.StatusCode != http.StatusOK {
		t.Fatalf("platform status = %d, want 200 (body=%s)", resp.StatusCode, body)
	}
	var byPlatform []historyMessage
	decodeDataSlice(t, body, &byPlatform)
	if len(byPlatform) != 1 || byPlatform[0].Content != "kook-group" {
		t.Fatalf("platform page = %+v, want [kook-group]", byPlatform)
	}

	// No filter → the full IM adapter overview (adapter_id != ''), web excluded.
	resp, body = doReq(t, http.MethodGet, ts.URL+"/api/v1/admin/channels/messages", nil, tok)
	if resp.StatusCode != http.StatusOK {
		t.Fatalf("all status = %d, want 200 (body=%s)", resp.StatusCode, body)
	}
	var all []historyMessage
	decodeDataSlice(t, body, &all)
	if len(all) != 3 {
		t.Fatalf("all page = %d, want 3 (%+v)", len(all), all)
	}
	if all[0].Content != "tg-group" || all[1].Content != "kook-group" || all[2].Content != "kook-owner" {
		t.Fatalf("all order = %+v, want [tg-group kook-group kook-owner]", all)
	}

	// Invalid before → 400.
	resp, body = doReq(t, http.MethodGet, ts.URL+"/api/v1/admin/channels/messages?before=abc", nil, tok)
	if resp.StatusCode != http.StatusBadRequest {
		t.Fatalf("invalid before status = %d, want 400 (body=%s)", resp.StatusCode, body)
	}
}

func TestHistoryDeleteSubSession(t *testing.T) {
	t.Parallel()
	_, ts, jwt, st := newHistoryEnv(t)
	ctx := context.Background()
	tok := signAny(t, jwt, "acct", auth.RoleOwner)

	// Create a sub and seed a message.
	resp, body := doReq(t, http.MethodPost, ts.URL+"/api/v1/sessions", nil, tok)
	if resp.StatusCode != http.StatusCreated {
		t.Fatalf("create status = %d, want 201 (body=%s)", resp.StatusCode, body)
	}
	var created struct {
		SessionID string `json:"sessionId"`
	}
	if err := json.Unmarshal(decodeBody(t, body)["data"], &created); err != nil {
		t.Fatalf("decode create data: %v", err)
	}
	if err := st.Append(ctx, history.Message{SessionID: created.SessionID, Role: history.RoleUser, Content: "x", CreatedAt: 1000}); err != nil {
		t.Fatalf("seed sub: %v", err)
	}

	// Delete it.
	resp, _ = doReq(t, http.MethodDelete, ts.URL+"/api/v1/sessions/"+created.SessionID, nil, tok)
	if resp.StatusCode != http.StatusOK {
		t.Fatalf("delete status = %d, want 200", resp.StatusCode)
	}
	// It is gone from the list.
	resp, body = doReq(t, http.MethodGet, ts.URL+"/api/v1/sessions", nil, tok)
	if resp.StatusCode != http.StatusOK {
		t.Fatalf("list status = %d, want 200", resp.StatusCode)
	}
	var sessions []historySessionSummary
	decodeDataSlice(t, body, &sessions)
	if len(sessions) != 1 || sessions[0].ID != history.MainSessionID {
		t.Fatalf("sessions after delete = %+v, want [main]", sessions)
	}

	// Main session is immutable → 403.
	resp, body = doReq(t, http.MethodDelete, ts.URL+"/api/v1/sessions/"+history.MainSessionID, nil, tok)
	if resp.StatusCode != http.StatusForbidden {
		t.Fatalf("delete main status = %d, want 403 (body=%s)", resp.StatusCode, body)
	}
	wantErrorShape(t, body)
}

// TestHistoryRenameSession covers PATCH /api/v1/sessions/{id}: renaming a sub and
// the fixed main session, the input bounds, RBAC and an unknown id.
func TestHistoryRenameSession(t *testing.T) {
	t.Parallel()
	_, ts, jwt, _ := newHistoryEnv(t)
	tok := signAny(t, jwt, "acct", auth.RoleOwner)

	// Create a sub session to rename.
	resp, body := doReq(t, http.MethodPost, ts.URL+"/api/v1/sessions", nil, tok)
	if resp.StatusCode != http.StatusCreated {
		t.Fatalf("create status = %d, want 201 (body=%s)", resp.StatusCode, body)
	}
	var created struct {
		SessionID string `json:"sessionId"`
	}
	if err := json.Unmarshal(decodeBody(t, body)["data"], &created); err != nil {
		t.Fatalf("decode create data: %v", err)
	}

	// Rename it and assert the response envelope plus the persisted list.
	resp, body = doReq(t, http.MethodPatch, ts.URL+"/api/v1/sessions/"+created.SessionID, map[string]any{"title": "  我的会话  "}, tok)
	if resp.StatusCode != http.StatusOK {
		t.Fatalf("rename status = %d, want 200 (body=%s)", resp.StatusCode, body)
	}
	var renamed struct {
		ID    string `json:"id"`
		Title string `json:"title"`
	}
	if err := json.Unmarshal(decodeBody(t, body)["data"], &renamed); err != nil {
		t.Fatalf("decode rename data: %v", err)
	}
	if renamed.ID != created.SessionID || renamed.Title != "我的会话" {
		t.Fatalf("rename data = %+v, want id %s title 我的会话", renamed, created.SessionID)
	}
	resp, body = doReq(t, http.MethodGet, ts.URL+"/api/v1/sessions", nil, tok)
	if resp.StatusCode != http.StatusOK {
		t.Fatalf("list status = %d, want 200 (body=%s)", resp.StatusCode, body)
	}
	var sessions []historySessionSummary
	decodeDataSlice(t, body, &sessions)
	found := false
	for _, m := range sessions {
		if m.ID == created.SessionID {
			found = true
			if m.Title != "我的会话" {
				t.Fatalf("listed sub title = %q, want 我的会话", m.Title)
			}
		}
	}
	if !found {
		t.Fatalf("renamed sub %s missing from %+v", created.SessionID, sessions)
	}

	// The fixed main session may be renamed even though it cannot be deleted.
	resp, body = doReq(t, http.MethodPatch, ts.URL+"/api/v1/sessions/"+history.MainSessionID, map[string]any{"title": "主控台"}, tok)
	if resp.StatusCode != http.StatusOK {
		t.Fatalf("rename main status = %d, want 200 (body=%s)", resp.StatusCode, body)
	}
	var mainRenamed struct {
		ID    string `json:"id"`
		Title string `json:"title"`
	}
	if err := json.Unmarshal(decodeBody(t, body)["data"], &mainRenamed); err != nil {
		t.Fatalf("decode main rename data: %v", err)
	}
	if mainRenamed.ID != history.MainSessionID || mainRenamed.Title != "主控台" {
		t.Fatalf("main rename data = %+v, want id web title 主控台", mainRenamed)
	}

	// Empty / whitespace-only / over-long titles are 400.
	for _, bad := range []string{"", "   ", strings.Repeat("字", maxSessionTitleRunes+1)} {
		resp, body = doReq(t, http.MethodPatch, ts.URL+"/api/v1/sessions/"+created.SessionID, map[string]any{"title": bad}, tok)
		if resp.StatusCode != http.StatusBadRequest {
			t.Fatalf("title %q status = %d, want 400 (body=%s)", bad, resp.StatusCode, body)
		}
		wantErrorShape(t, body)
	}

	// An unknown session id is 404.
	resp, body = doReq(t, http.MethodPatch, ts.URL+"/api/v1/sessions/web:missing", map[string]any{"title": "x"}, tok)
	if resp.StatusCode != http.StatusNotFound {
		t.Fatalf("unknown rename status = %d, want 404 (body=%s)", resp.StatusCode, body)
	}

	// A title of exactly the 80-rune bound is accepted.
	exact := strings.Repeat("字", maxSessionTitleRunes)
	resp, body = doReq(t, http.MethodPatch, ts.URL+"/api/v1/sessions/"+created.SessionID, map[string]any{"title": exact}, tok)
	if resp.StatusCode != http.StatusOK {
		t.Fatalf("80-rune rename status = %d, want 200 (body=%s)", resp.StatusCode, body)
	}

	// A viewer cannot rename (owner/admin write).
	viewer := signAny(t, jwt, "acct", auth.RoleViewer)
	resp, body = doReq(t, http.MethodPatch, ts.URL+"/api/v1/sessions/"+created.SessionID, map[string]any{"title": "nope"}, viewer)
	if resp.StatusCode != http.StatusForbidden {
		t.Fatalf("viewer rename status = %d, want 403 (body=%s)", resp.StatusCode, body)
	}
}

// TestPersistUserMessageNamesSession exercises the Web persistence path end to end:
// persistUserMessages (the orchestrator hook the HTTP/WS boundary calls) writes the
// first user message through the real store, which names the session. A later user
// message leaves the title alone.
func TestPersistUserMessageNamesSession(t *testing.T) {
	t.Parallel()
	_, _, _, st := newHistoryEnv(t)
	o := &Orchestrator{history: st, log: testLogger()}
	ctx := context.Background()

	// A sub session starts nameless; the first user message names it.
	sub, err := st.NewSubSession(ctx, "owner")
	if err != nil {
		t.Fatalf("new sub: %v", err)
	}
	o.persistUserMessages(ctx, sub, []model.Message{model.TextMessage(model.RoleUser, "帮我规划一次旅行")}, "web:test", "chat")
	o.persistUserMessages(ctx, sub, []model.Message{model.TextMessage(model.RoleUser, "第二句话")}, "web:test", "chat")

	metas, err := st.ListSessions(ctx)
	if err != nil {
		t.Fatalf("list sessions: %v", err)
	}
	var gotSub string
	for _, m := range metas {
		if m.ID == sub {
			gotSub = m.Title
		}
	}
	if gotSub != "帮我规划一次旅行" {
		t.Fatalf("sub title = %q, want 帮我规划一次旅行", gotSub)
	}

	// The main session is named from its first Web user message too.
	o.persistUserMessages(ctx, history.MainSessionID, []model.Message{model.TextMessage(model.RoleUser, "  今天\n天气如何  ")}, "web:test", "chat")
	metas, err = st.ListSessions(ctx)
	if err != nil {
		t.Fatalf("list sessions again: %v", err)
	}
	var gotMain string
	for _, m := range metas {
		if m.ID == history.MainSessionID {
			gotMain = m.Title
		}
	}
	if gotMain != "今天 天气如何" {
		t.Fatalf("main title = %q, want 今天 天气如何", gotMain)
	}
}

func TestHistoryNotWired(t *testing.T) {
	t.Parallel()
	_, ts, jwt := buildEnv(t, cfgDefault(), Deps{})
	tok := signAny(t, jwt, "acct", auth.RoleOwner)

	// Messages/create/delete answer a clear 501 when no history store is wired.
	for _, tc := range []struct {
		method, url string
		want        int
	}{
		{http.MethodGet, "/api/v1/sessions/web/messages?limit=2", http.StatusNotImplemented},
		{http.MethodPost, "/api/v1/sessions", http.StatusNotImplemented},
		{http.MethodPatch, "/api/v1/sessions/web", http.StatusNotImplemented},
	} {
		resp, body := doReq(t, tc.method, ts.URL+tc.url, nil, tok)
		if resp.StatusCode != tc.want {
			t.Fatalf("%s %s status = %d, want %d (body=%s)", tc.method, tc.url, resp.StatusCode, tc.want, body)
		}
		if !strings.Contains(string(body), "not_implemented") {
			t.Fatalf("%s %s body = %s, want not_implemented code", tc.method, tc.url, body)
		}
	}
}

func TestHistoryRBAC(t *testing.T) {
	t.Parallel()
	_, ts, jwt, _ := newHistoryEnv(t)
	viewer := signAny(t, jwt, "acct", auth.RoleViewer)
	owner := signAny(t, jwt, "acct", auth.RoleOwner)

	// Viewer can list session metadata (readAuth) but not read/write history content.
	resp, _ := doReq(t, http.MethodGet, ts.URL+"/api/v1/sessions", nil, viewer)
	if resp.StatusCode != http.StatusOK {
		t.Fatalf("viewer list sessions status = %d, want 200", resp.StatusCode)
	}
	resp, body := doReq(t, http.MethodGet, ts.URL+"/api/v1/sessions/web/messages", nil, viewer)
	if resp.StatusCode != http.StatusForbidden {
		t.Fatalf("viewer messages status = %d, want 403 (body=%s)", resp.StatusCode, body)
	}
	resp, body = doReq(t, http.MethodPost, ts.URL+"/api/v1/sessions", nil, viewer)
	if resp.StatusCode != http.StatusForbidden {
		t.Fatalf("viewer create status = %d, want 403 (body=%s)", resp.StatusCode, body)
	}
	// Owner can read messages.
	resp, _ = doReq(t, http.MethodGet, ts.URL+"/api/v1/sessions/web/messages?limit=2", nil, owner)
	if resp.StatusCode != http.StatusOK {
		t.Fatalf("owner messages status = %d, want 200", resp.StatusCode)
	}
}