package api

import (
	"context"
	"crypto/sha256"
	"crypto/subtle"
	"encoding/base64"
	"encoding/json"
	"errors"
	"io"
	"net/http"
	"net/http/httptest"
	"os"
	"strings"
	"testing"
	"time"

	account "git.ipao.vip/rogee/creator-hub/internal/account"
	"git.ipao.vip/rogee/creator-hub/internal/creator"
	hub "git.ipao.vip/rogee/creator-hub/internal/environment"
	"github.com/gofiber/fiber/v3"
)

func TestCreatorReadRoutesAgainstPostgres(t *testing.T) {
	databaseURL := os.Getenv("CREATORHUB_POSTGRES_TEST_URL")
	if databaseURL == "" {
		t.Skip("set CREATORHUB_POSTGRES_TEST_URL to run creator route coverage")
	}
	ctx := context.Background()
	databaseURL = isolatedControlPlaneDatabaseURL(t, databaseURL)
	phaseAStore, err := account.Open(ctx, databaseURL)
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = phaseAStore.Close() })
	hubStore, err := hub.Open(ctx, databaseURL)
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = hubStore.Close() })
	creatorStore, err := creator.Open(ctx, databaseURL)
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = creatorStore.Close() })
	app := newHandlerWithCreator(t.TempDir(), "operator", "unit-test-password", phaseAStore, hubStore, nil, creatorStore)
	for _, path := range []string{
		"/api/creator/settings", "/api/creator/accounts", "/api/creator/competitors", "/api/creator/relations",
		"/api/creator/accounts/route-account/strategies", "/api/creator/rules", "/api/creator/rule-results", "/api/creator/leads",
		"/api/creator/works", "/api/creator/works?page=1&page_size=10", "/api/creator/comments", "/api/creator/comments?page=1&page_size=10",
		"/api/creator/listener-boundaries", "/api/creator/events", "/api/creator/events?page=1&page_size=10",
		"/api/creator/listeners", "/api/creator/operations", "/api/creator/conversations",
	} {
		response := do(app, http.MethodGet, path, "", "operator", "unit-test-password")
		if response.Code != http.StatusOK {
			t.Fatalf("GET %s returned %d: %s", path, response.Code, response.Body.String())
		}
	}
}

func TestCreatorRouteValidationCoverage(t *testing.T) {
	databaseURL := os.Getenv("CREATORHUB_POSTGRES_TEST_URL")
	if databaseURL == "" {
		t.Skip("set CREATORHUB_POSTGRES_TEST_URL to run creator route coverage")
	}
	ctx := context.Background()
	databaseURL = isolatedControlPlaneDatabaseURL(t, databaseURL)
	phaseAStore, err := account.Open(ctx, databaseURL)
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = phaseAStore.Close() })
	hubStore, err := hub.Open(ctx, databaseURL)
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = hubStore.Close() })
	creatorStore, err := creator.Open(ctx, databaseURL)
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = creatorStore.Close() })
	credentials := &testCredentialBridge{values: make(map[string]string)}
	if err := phaseAStore.CreateAccount(ctx, account.Account{
		ID: "route-account", Name: "Route Account", Platform: creator.PlatformDouyin,
		PlatformAccountKey: "route-platform", Tags: []string{}, Cookies: "",
		CredentialReference: account.CredentialReference{ID: "route-account-credential", Provider: "os_keyring"},
		CredentialKey:       "creatorhub/route-account/cookies",
	}, credentials); err != nil {
		t.Fatal(err)
	}
	app := newHandlerWithCreator(t.TempDir(), "operator", "unit-test-password", phaseAStore, hubStore, nil, creatorStore)
	for _, path := range []string{
		"/api/creator/accounts/route-account/profile", "/api/creator/accounts/route-account/strategies",
		"/api/creator/accounts/route-account/collection-status", "/api/creator/accounts/route-account/metrics",
	} {
		response := do(app, http.MethodGet, path, "", "operator", "unit-test-password")
		if response.Code != http.StatusOK {
			t.Fatalf("GET %s returned %d: %s", path, response.Code, response.Body.String())
		}
	}
	for _, path := range []string{
		"/api/creator/works/missing/metrics", "/api/creator/rule-results?comment_id=missing",
		"/api/creator/events/missing/strategy-trace", "/api/creator/conversations/missing/messages",
	} {
		response := do(app, http.MethodGet, path, "", "operator", "unit-test-password")
		if response.Code != http.StatusOK {
			t.Fatalf("GET %s returned %d: %s", path, response.Code, response.Body.String())
		}
	}
	for _, path := range []string{
		"/api/creator/competitors/missing", "/api/creator/works/missing",
		"/api/creator/comments/missing", "/api/creator/rules/missing",
		"/api/creator/operations/missing", "/api/creator/operations/missing/verification",
	} {
		response := do(app, http.MethodGet, path, "", "operator", "unit-test-password")
		if response.Code != http.StatusNotFound {
			t.Fatalf("GET %s returned %d: %s", path, response.Code, response.Body.String())
		}
	}
	response := do(app, http.MethodGet, "/api/creator/works/missing/material", "", "operator", "unit-test-password")
	if response.Code != http.StatusBadRequest {
		t.Fatalf("GET material for missing work returned %d: %s", response.Code, response.Body.String())
	}
	for _, route := range []struct {
		method string
		path   string
	}{
		{http.MethodPut, "/api/creator/settings"},
		{http.MethodPut, "/api/creator/accounts/missing/profile"},
		{http.MethodPost, "/api/creator/accounts/missing/login-result"},
		{http.MethodPost, "/api/creator/accounts/missing/big-account"},
		{http.MethodPost, "/api/creator/relations"},
		{http.MethodPost, "/api/creator/accounts/missing/strategies"},
		{http.MethodPost, "/api/creator/strategies/missing/enable"},
		{http.MethodPost, "/api/creator/strategies/missing/disable"},
		{http.MethodDelete, "/api/creator/strategies/missing"},
		{http.MethodPut, "/api/creator/strategies/missing"},
		{http.MethodPost, "/api/creator/competitor-share-jobs"},
		{http.MethodPost, "/api/creator/competitors/missing/pause"},
		{http.MethodPost, "/api/creator/competitors/missing/resume"},
		{http.MethodPost, "/api/creator/competitors/missing/sync"},
		{http.MethodPost, "/api/creator/accounts/missing/sync"},
		{http.MethodPost, "/api/creator/works/missing/metrics"},
		{http.MethodPost, "/api/creator/works/missing/material/select"},
		{http.MethodPost, "/api/creator/works/missing/material/process"},
		{http.MethodPost, "/api/creator/works/missing/material/rewrite/confirm"},
		{http.MethodPost, "/api/creator/works/missing/material/rewrite/generate"},
		{http.MethodPut, "/api/creator/works/missing/material/rewrite"},
		{http.MethodPost, "/api/creator/rules"},
		{http.MethodPut, "/api/creator/rules/missing"},
		{http.MethodPost, "/api/creator/rules/missing/enable"},
		{http.MethodPost, "/api/creator/rules/missing/disable"},
		{http.MethodPost, "/api/creator/comments/analyze"},
		{http.MethodPost, "/api/creator/comments/missing/analyze"},
		{http.MethodPost, "/api/creator/events/missing/display"},
		{http.MethodPost, "/api/creator/operations"},
		{http.MethodPost, "/api/creator/operations/missing/execute"},
		{http.MethodPost, "/api/creator/conversations/missing/sync"},
		{http.MethodPost, "/api/creator/messages/send"},
	} {
		response := do(app, route.method, route.path, "{", "operator", "unit-test-password")
		if response.Code != http.StatusBadRequest && response.Code != http.StatusNotFound && response.Code != http.StatusNoContent && response.Code != http.StatusServiceUnavailable {
			t.Fatalf("%s %s returned %d for invalid JSON: %s", route.method, route.path, response.Code, response.Body.String())
		}
	}
	for _, path := range []string{
		"/api/creator/works", "/api/creator/comments", "/api/creator/events", "/api/creator/events/process", "/api/creator/messages",
	} {
		response := do(app, http.MethodPost, path, `{}`, "operator", "unit-test-password")
		if response.Code != http.StatusConflict {
			t.Fatalf("POST %s accepted public platform input: %d", path, response.Code)
		}
	}
}

func TestCreatorFixtureRoutesPostgres(t *testing.T) {
	databaseURL := os.Getenv("CREATORHUB_POSTGRES_TEST_URL")
	if databaseURL == "" {
		t.Skip("set CREATORHUB_POSTGRES_TEST_URL to run creator fixture coverage")
	}
	ctx := context.Background()
	databaseURL = isolatedControlPlaneDatabaseURL(t, databaseURL)
	phaseAStore, err := account.Open(ctx, databaseURL)
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = phaseAStore.Close() })
	hubStore, err := hub.Open(ctx, databaseURL)
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = hubStore.Close() })
	creatorStore, err := creator.Open(ctx, databaseURL)
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = creatorStore.Close() })
	credentials := &testCredentialBridge{values: make(map[string]string)}
	if err := phaseAStore.CreateAccount(ctx, account.Account{
		ID: "fixture-account", Name: "Fixture Account", Platform: creator.PlatformDouyin,
		PlatformAccountKey: "fixture-platform", Tags: []string{}, Cookies: "",
		CredentialReference: account.CredentialReference{ID: "fixture-credential", Provider: "os_keyring"},
		CredentialKey:       "creatorhub/fixture-account/cookies",
	}, credentials); err != nil {
		t.Fatal(err)
	}
	if err := phaseAStore.CreateAccount(ctx, account.Account{
		ID: "fixture-small", Name: "Fixture Small", Platform: creator.PlatformDouyin,
		PlatformAccountKey: "fixture-small-platform", Tags: []string{}, Cookies: "",
		CredentialReference: account.CredentialReference{ID: "fixture-small-credential", Provider: "os_keyring"},
		CredentialKey:       "creatorhub/fixture-small/cookies",
	}, credentials); err != nil {
		t.Fatal(err)
	}
	if err := creatorStore.EnsureAccountProfile(ctx, "fixture-small"); err != nil {
		t.Fatal(err)
	}
	app := newHandlerWithCreator(t.TempDir(), "operator", "unit-test-password", phaseAStore, hubStore, nil, creatorStore)
	idFrom := func(response *httptest.ResponseRecorder) string {
		var value struct {
			ID string `json:"id"`
		}
		if err := json.Unmarshal(response.Body.Bytes(), &value); err != nil || value.ID == "" {
			t.Fatalf("response has no ID: %s (%v)", response.Body.String(), err)
		}
		return value.ID
	}
	workBody := `{"platform":"douyin","work_key":"fixture-work","source_type":"owned","source_id":"fixture-account","author_name":"author","title":"title","body":"body","published_at":"2024-01-01T00:00:00Z","published_at_status":"verified"}`
	workResponse := do(app, http.MethodPost, "/api/creator/test/works", workBody, "operator", "unit-test-password")
	if workResponse.Code != http.StatusCreated {
		t.Fatalf("create fixture work: %d %s", workResponse.Code, workResponse.Body.String())
	}
	workID := idFrom(workResponse)
	if response := do(app, http.MethodPost, "/api/creator/test/works", workBody, "operator", "unit-test-password"); response.Code != http.StatusOK {
		t.Fatalf("deduplicate fixture work: %d %s", response.Code, response.Body.String())
	}
	for _, path := range []string{"/api/creator/works/" + workID, "/api/creator/works/" + workID + "/metrics", "/api/creator/works/" + workID + "/material"} {
		if response := do(app, http.MethodGet, path, "", "operator", "unit-test-password"); response.Code != http.StatusOK {
			t.Fatalf("GET %s: %d %s", path, response.Code, response.Body.String())
		}
	}
	metricBody := `{"likes":2,"comments_count":1,"shares":1}`
	if response := do(app, http.MethodPost, "/api/creator/works/"+workID+"/metrics", metricBody, "operator", "unit-test-password"); response.Code != http.StatusOK {
		t.Fatalf("record fixture metric: %d %s", response.Code, response.Body.String())
	}
	materialResponse := do(app, http.MethodPost, "/api/creator/works/"+workID+"/material/select", `{}`, "operator", "unit-test-password")
	if materialResponse.Code != http.StatusCreated && materialResponse.Code != http.StatusOK {
		t.Fatalf("select fixture material: %d %s", materialResponse.Code, materialResponse.Body.String())
	}
	if _, claimed, err := creatorStore.ClaimMaterialStep(ctx, workID, "download", "fixture-material-token"); err != nil || !claimed {
		t.Fatalf("claim fixture material download: claimed=%v err=%v", claimed, err)
	}
	if _, err := setMaterialFailure(ctx, creatorStore, workID, "download", "fixture-material-token", errors.New("fixture download failed")); err != nil {
		t.Fatalf("record fixture material failure: %v", err)
	}
	commentBody := `{"platform":"douyin","comment_key":"fixture-comment","work_id":"` + workID + `","author_uid":"peer","author_name":"Peer","content":"hello","comment_type":"top_level","published_at":"2024-01-01T00:00:00Z"}`
	commentResponse := do(app, http.MethodPost, "/api/creator/test/comments", commentBody, "operator", "unit-test-password")
	if commentResponse.Code != http.StatusCreated {
		t.Fatalf("create fixture comment: %d %s", commentResponse.Code, commentResponse.Body.String())
	}
	commentID := idFrom(commentResponse)
	if response := do(app, http.MethodPost, "/api/creator/test/comments", commentBody, "operator", "unit-test-password"); response.Code != http.StatusOK {
		t.Fatalf("deduplicate fixture comment: %d %s", response.Code, response.Body.String())
	}
	if response := do(app, http.MethodGet, "/api/creator/comments/"+commentID, "", "operator", "unit-test-password"); response.Code != http.StatusOK {
		t.Fatalf("GET fixture comment: %d %s", response.Code, response.Body.String())
	}
	profileBody := `{"real_name_status":"unknown","business_status":"normal","cooldown_seconds":60}`
	if response := do(app, http.MethodPut, "/api/creator/accounts/fixture-account/profile", profileBody, "operator", "unit-test-password"); response.Code != http.StatusOK {
		t.Fatalf("update fixture profile: %d %s", response.Code, response.Body.String())
	}
	if response := do(app, http.MethodPost, "/api/creator/accounts/fixture-account/big-account", `{"enabled":true}`, "operator", "unit-test-password"); response.Code != http.StatusOK {
		t.Fatalf("enable fixture big account: %d %s", response.Code, response.Body.String())
	}
	for _, accountID := range []string{"fixture-account", "fixture-small"} {
		if _, err := creatorStore.UpdateAccountProfile(ctx, accountID, creator.AccountProfileUpdate{RealNameStatus: "unknown", BusinessStatus: "normal", BigAccount: accountID == "fixture-account", CooldownSeconds: 60}); err != nil {
			t.Fatal(err)
		}
	}
	if _, err := creatorStore.RecordVerifiedLoginResult(ctx, "fixture-account", "fixture-platform"); err != nil {
		t.Fatal(err)
	}
	if _, err := creatorStore.RecordVerifiedLoginResult(ctx, "fixture-small", "fixture-small-platform"); err != nil {
		t.Fatal(err)
	}
	if err := creatorStore.SetRelation(ctx, "fixture-account", "fixture-small", true); err != nil {
		t.Fatal(err)
	}
	strategyBody := `{"execution_account_id":"fixture-small","position":1,"enabled":true,"event_types":["comment"],"action":"reply_comment","target_type":"comment","candidate_texts":["已收到"]}`
	strategyResponse := do(app, http.MethodPost, "/api/creator/accounts/fixture-account/strategies", strategyBody, "operator", "unit-test-password")
	if strategyResponse.Code != http.StatusCreated {
		t.Fatalf("create fixture strategy: %d %s", strategyResponse.Code, strategyResponse.Body.String())
	}
	strategyID := idFrom(strategyResponse)
	for _, route := range []struct {
		method string
		path   string
		body   string
	}{
		{http.MethodPut, "/api/creator/strategies/" + strategyID, strategyBody},
		{http.MethodPost, "/api/creator/strategies/" + strategyID + "/enable", `{}`},
		{http.MethodPost, "/api/creator/strategies/" + strategyID + "/disable", `{}`},
	} {
		if response := do(app, route.method, route.path, route.body, "operator", "unit-test-password"); response.Code != http.StatusOK {
			t.Fatalf("%s %s: %d %s", route.method, route.path, response.Code, response.Body.String())
		}
	}
	if response := do(app, http.MethodDelete, "/api/creator/strategies/"+strategyID, "", "operator", "unit-test-password"); response.Code != http.StatusNoContent {
		t.Fatalf("delete fixture strategy: %d %s", response.Code, response.Body.String())
	}
	ruleBody := `{"name":"fixture-rule","enabled":true,"source_type":"owned","topic":"title","include_keywords":["hello"],"ai_requirement":"lead"}`
	ruleResponse := do(app, http.MethodPost, "/api/creator/rules", ruleBody, "operator", "unit-test-password")
	if ruleResponse.Code != http.StatusCreated {
		t.Fatalf("create fixture rule: %d %s", ruleResponse.Code, ruleResponse.Body.String())
	}
	ruleID := idFrom(ruleResponse)
	if response := do(app, http.MethodGet, "/api/creator/rules/"+ruleID, "", "operator", "unit-test-password"); response.Code != http.StatusOK {
		t.Fatalf("GET fixture rule: %d %s", response.Code, response.Body.String())
	}
	if response := do(app, http.MethodPost, "/api/creator/comments/"+commentID+"/analyze", `{"rule_id":"`+ruleID+`"}`, "operator", "unit-test-password"); response.Code != http.StatusServiceUnavailable {
		t.Fatalf("analyze fixture comment without AI: %d %s", response.Code, response.Body.String())
	}
	competitor, err := creatorStore.CreateCompetitor(ctx, creator.CompetitorInput{Platform: creator.PlatformDouyin, PlatformAccountKey: "competitor-key", Nickname: "Competitor", HomepageURL: "https://www.douyin.com/user/competitor-key"})
	if err != nil {
		t.Fatal(err)
	}
	competitorID := competitor.ID
	if response := do(app, http.MethodGet, "/api/creator/competitors/"+competitorID, "", "operator", "unit-test-password"); response.Code != http.StatusOK {
		t.Fatalf("GET fixture competitor: %d %s", response.Code, response.Body.String())
	}
	for _, action := range []string{"pause", "resume", "sync"} {
		if response := do(app, http.MethodPost, "/api/creator/competitors/"+competitorID+"/"+action, `{}`, "operator", "unit-test-password"); response.Code != http.StatusOK && response.Code != http.StatusServiceUnavailable {
			t.Fatalf("competitor %s: %d %s", action, response.Code, response.Body.String())
		}
	}
	if _, err := syncCreatorCompetitorWithClaim(ctx, creatorStore, hubStore, competitorID, true); err == nil {
		t.Fatal("competitor sync without anonymous browser unexpectedly succeeded")
	}
	if _, err := previewDouyinCompetitor(ctx, creatorStore, phaseAStore, hubStore, "fixture-account", creator.CompetitorInput{Platform: creator.PlatformDouyin, PlatformAccountKey: "preview-key", Nickname: "Preview", HomepageURL: "https://www.douyin.com/user/preview-key"}); err == nil {
		t.Fatal("competitor preview without browser unexpectedly succeeded")
	}

	// 自有账号监控：列表带作品聚合统计（fixture 已有 1 个 owned 作品）。
	viewResponse := do(app, http.MethodGet, "/api/creator/accounts/monitor-views", "", "operator", "unit-test-password")
	if viewResponse.Code != http.StatusOK {
		t.Fatalf("GET monitor views: %d %s", viewResponse.Code, viewResponse.Body.String())
	}
	var monitorViews []struct {
		ID                string `json:"id"`
		WorkCount         int64  `json:"work_count"`
		LatestPublishedAt *string `json:"latest_published_at"`
	}
	if err := json.Unmarshal(viewResponse.Body.Bytes(), &monitorViews); err != nil {
		t.Fatal(err)
	}
	viewByAccount := map[string]bool{}
	for _, view := range monitorViews {
		viewByAccount[view.ID] = true
		if view.ID == "fixture-account" && (view.WorkCount < 1 || view.LatestPublishedAt == nil) {
			t.Fatalf("monitor view aggregates missing for fixture-account: %+v", view)
		}
	}
	if !viewByAccount["fixture-account"] {
		t.Fatal("monitor views missing fixture-account")
	}
	// 采集状态：无 checkpoint 时 pending；作品采集完成后 succeeded 且带窗口。
	statusResponse := do(app, http.MethodGet, "/api/creator/accounts/fixture-small/collection-status", "", "operator", "unit-test-password")
	if statusResponse.Code != http.StatusOK {
		t.Fatalf("GET collection status: %d %s", statusResponse.Code, statusResponse.Body.String())
	}
	var collectionStatus struct {
		Works struct {
			Status string `json:"status"`
		} `json:"works"`
	}
	if err := json.Unmarshal(statusResponse.Body.Bytes(), &collectionStatus); err != nil {
		t.Fatal(err)
	}
	if collectionStatus.Works.Status != "pending" {
		t.Fatalf("expected pending checkpoint for untouched account: %s", statusResponse.Body.String())
	}
	statusResponse = do(app, http.MethodGet, "/api/creator/accounts/fixture-account/collection-status", "", "operator", "unit-test-password")
	if statusResponse.Code != http.StatusOK {
		t.Fatalf("GET collection status: %d %s", statusResponse.Code, statusResponse.Body.String())
	}
	var fixtureStatus struct {
		Works struct {
			Status          string `json:"status"`
			NextWindowStart *string `json:"next_window_start"`
			NextWindowEnd   *string `json:"next_window_end"`
		} `json:"works"`
	}
	if err := json.Unmarshal(statusResponse.Body.Bytes(), &fixtureStatus); err != nil {
		t.Fatal(err)
	}
	// fixture 流程没有跑过调度器 checkpoint，状态可能仍为 pending；两种都合法。
	if fixtureStatus.Works.Status != "pending" && fixtureStatus.Works.Status != "succeeded" {
		t.Fatalf("unexpected works checkpoint status: %s", statusResponse.Body.String())
	}
	// 账号画像时序：初始为空数组。
	metricsResponse := do(app, http.MethodGet, "/api/creator/accounts/fixture-account/metrics", "", "operator", "unit-test-password")
	if metricsResponse.Code != http.StatusOK || strings.TrimSpace(metricsResponse.Body.String()) != "[]" {
		t.Fatalf("GET account metrics: %d %s", metricsResponse.Code, metricsResponse.Body.String())
	}
	// 未登录账号强制同步：账号存在但未通过登录/环境校验，必须 409/503 且不吞错。
	smallSync := do(app, http.MethodPost, "/api/creator/accounts/fixture-small/sync", ``, "operator", "unit-test-password")
	if smallSync.Code != http.StatusConflict && smallSync.Code != http.StatusServiceUnavailable {
		t.Fatalf("sync not-logged-in account must be blocked: %d %s", smallSync.Code, smallSync.Body.String())
	}
	if _, err := creatorStore.RecordVerifiedLoginResult(ctx, "fixture-small", "fixture-small-platform"); err != nil {
		t.Fatal(err)
	}
	loggedSync := do(app, http.MethodPost, "/api/creator/accounts/fixture-small/sync", ``, "operator", "unit-test-password")
	if loggedSync.Code != http.StatusConflict && loggedSync.Code != http.StatusServiceUnavailable {
		t.Fatalf("sync without runtime environment must be blocked: %d %s", loggedSync.Code, loggedSync.Body.String())
	}
	missingSync := do(app, http.MethodPost, "/api/creator/accounts/fixture-missing/sync", ``, "operator", "unit-test-password")
	if missingSync.Code != http.StatusNotFound && missingSync.Code != http.StatusConflict && missingSync.Code != http.StatusServiceUnavailable {
		t.Fatalf("sync missing account: %d %s", missingSync.Code, missingSync.Body.String())
	}
	eventBody := `{"platform":"douyin","receiving_account_id":"fixture-account","event_key":"fixture-event","event_type":"comment","interactor_uid":"peer","work_id":"` + workID + `","comment_id":"` + commentID + `"}`
	eventResponse := do(app, http.MethodPost, "/api/creator/test/events", eventBody, "operator", "unit-test-password")
	if eventResponse.Code != http.StatusCreated {
		t.Fatalf("create fixture event: %d %s", eventResponse.Code, eventResponse.Body.String())
	}
	var eventEnvelope struct {
		Event struct {
			ID string `json:"id"`
		} `json:"event"`
	}
	if err := json.Unmarshal(eventResponse.Body.Bytes(), &eventEnvelope); err != nil || eventEnvelope.Event.ID == "" {
		t.Fatalf("event has no ID: %s (%v)", eventResponse.Body.String(), err)
	}
	eventID := eventEnvelope.Event.ID
	if response := do(app, http.MethodPost, "/api/creator/events/"+eventID+"/display", `{}`, "operator", "unit-test-password"); response.Code != http.StatusOK {
		t.Fatalf("display fixture event: %d %s", response.Code, response.Body.String())
	}
	operationBody := `{"idempotency_key":"fixture-operation","source":"manual","action":"reply_comment","platform":"douyin","account_id":"fixture-account","target_uid":"peer","target_comment_id":"` + commentID + `","target_work_id":"` + workID + `","text":"reply"}`
	operationResponse := do(app, http.MethodPost, "/api/creator/operations", operationBody, "operator", "unit-test-password")
	if operationResponse.Code != http.StatusCreated {
		t.Fatalf("create fixture operation: %d %s", operationResponse.Code, operationResponse.Body.String())
	}
	operationID := idFrom(operationResponse)
	for _, path := range []string{"/api/creator/operations/" + operationID, "/api/creator/operations/" + operationID + "/verification"} {
		if response := do(app, http.MethodGet, path, "", "operator", "unit-test-password"); response.Code != http.StatusOK {
			t.Fatalf("GET %s: %d %s", path, response.Code, response.Body.String())
		}
	}
	if response := do(app, http.MethodPost, "/api/creator/operations/"+operationID+"/execute", `{}`, "operator", "unit-test-password"); response.Code != http.StatusOK {
		t.Fatalf("execute fixture operation without executor: %d %s", response.Code, response.Body.String())
	}
	if response := do(app, http.MethodPost, "/api/creator/test/events/process", eventBody, "operator", "unit-test-password"); response.Code != http.StatusOK && response.Code != http.StatusServiceUnavailable {
		t.Fatalf("process fixture event without executor: %d %s", response.Code, response.Body.String())
	}
	messageBody := `{"platform":"douyin","account_id":"fixture-account","peer_uid":"peer","peer_name":"Peer","platform_message_key":"fixture-message","direction":"inbound","message_type":"text","text":"hello"}`
	messageResponse := do(app, http.MethodPost, "/api/creator/test/messages", messageBody, "operator", "unit-test-password")
	if messageResponse.Code != http.StatusCreated {
		t.Fatalf("create fixture message: %d %s", messageResponse.Code, messageResponse.Body.String())
	}
	var message struct {
		ConversationID string `json:"conversation_id"`
	}
	if err := json.Unmarshal(messageResponse.Body.Bytes(), &message); err != nil || message.ConversationID == "" {
		t.Fatalf("message has no conversation: %s (%v)", messageResponse.Body.String(), err)
	}
	for _, path := range []string{"/api/creator/conversations/" + message.ConversationID + "/messages", "/api/creator/conversations/" + message.ConversationID + "/messages?page=1&page_size=10"} {
		if response := do(app, http.MethodGet, path, "", "operator", "unit-test-password"); response.Code != http.StatusOK {
			t.Fatalf("GET %s: %d %s", path, response.Code, response.Body.String())
		}
	}
	if err := runCreatorScheduleOnce(ctx, creatorStore, phaseAStore, hubStore); err != nil && !errors.Is(err, creator.ErrUnavailable) {
		t.Fatalf("creator schedule fixture: %v", err)
	}
	if err := runCreatorMetricScheduleOnce(ctx, creatorStore, phaseAStore, hubStore, time.Now().UTC()); err != nil && !errors.Is(err, creator.ErrUnavailable) {
		t.Fatalf("creator metric schedule fixture: %v", err)
	}
	storedWork, err := creatorStore.GetWork(ctx, workID)
	if err != nil {
		t.Fatal(err)
	}
	settings, err := creatorStore.GetSettings(ctx)
	if err != nil {
		t.Fatal(err)
	}
	if err := refreshCreatorMetricWork(ctx, creatorStore, phaseAStore, hubStore, storedWork, "fixture-account", settings, time.Now().UTC()); err == nil {
		t.Fatal("metric refresh without browser unexpectedly succeeded")
	}
	if _, err := verifyCreatorAccount(ctx, creatorStore, phaseAStore, hubStore, "fixture-account"); err == nil {
		t.Fatal("account verification without browser unexpectedly succeeded")
	}
}

func TestPhaseAAccountRequestRejectsUnknownFields(t *testing.T) {
	for name, body := range map[string]string{
		"client id":            `{"id":"account-a","name":"账号 A","platform":"douyin","platform_account_key":"a","tags":[],"cookies":"sid=value"}`,
		"authorization kind":   `{"name":"账号 A","platform":"douyin","platform_account_key":"a","tags":[],"cookies":"sid=value","authorization_kind":"owned"}`,
		"credential reference": `{"name":"账号 A","platform":"douyin","platform_account_key":"a","tags":[],"cookies":"sid=value","credential_reference":{}}`,
	} {
		t.Run(name, func(t *testing.T) {
			app := fiber.New()
			app.Post("/", func(c fiber.Ctx) error {
				var input accountRequest
				if err := decodePhaseA(c, &input); err != nil {
					return phaseAError(c, err)
				}
				return c.SendStatus(http.StatusNoContent)
			})
			response, err := app.Test(httptest.NewRequest(http.MethodPost, "/", strings.NewReader(body)))
			if err != nil {
				t.Fatal(err)
			}
			defer response.Body.Close()
			if response.StatusCode != http.StatusBadRequest {
				t.Fatalf("expected sensitive or unknown field to be rejected, got %d", response.StatusCode)
			}
		})
	}
}

func TestPhaseAErrorRedactsInternalDetails(t *testing.T) {
	app := fiber.New()
	app.Get("/", func(c fiber.Ctx) error {
		return phaseAError(c, errors.New("database exposed a secret value"))
	})
	response, err := app.Test(httptest.NewRequest(http.MethodGet, "/", nil))
	if err != nil {
		t.Fatal(err)
	}
	defer response.Body.Close()
	body, _ := io.ReadAll(response.Body)
	if response.StatusCode != http.StatusInternalServerError || strings.Contains(string(body), "secret") || !strings.Contains(string(body), "phase A operation failed") {
		t.Fatalf("internal error was not redacted: status=%d body=%s", response.StatusCode, body)
	}
}

func newHandlerWithStores(_ string, _ string, _ string, accountStore *account.Store, environmentStore *hub.Store) *fiber.App {
	appInstance := fiber.New()
	if environmentStore != nil {
		RegisterEnvironments(appInstance, environmentStore)
	}
	if accountStore != nil {
		RegisterAccounts(appInstance, accountStore, environmentStore, nil)
	}
	return appInstance
}

func newHandlerWithCreator(_ string, _ string, _ string, accountStore *account.Store, environmentStore *hub.Store, _ account.CredentialBridge, creatorStore *creator.Store) *fiber.App {
	appInstance := newHandlerWithStores("", "", "", accountStore, environmentStore)
	if creatorStore != nil {
		RegisterCreator(appInstance, creatorStore, accountStore, environmentStore)
	}
	return appInstance
}

func authenticate(username, password string) fiber.Handler {
	wantUser, wantPassword := sha256.Sum256([]byte(username)), sha256.Sum256([]byte(password))
	return func(c fiber.Ctx) error {
		encoded, ok := strings.CutPrefix(c.Get(fiber.HeaderAuthorization), "Basic ")
		decoded, err := base64.StdEncoding.DecodeString(encoded)
		user, suppliedPassword, found := strings.Cut(string(decoded), ":")
		gotUser, gotPassword := sha256.Sum256([]byte(user)), sha256.Sum256([]byte(suppliedPassword))
		if !ok || err != nil || !found || subtle.ConstantTimeCompare(gotUser[:], wantUser[:]) != 1 || subtle.ConstantTimeCompare(gotPassword[:], wantPassword[:]) != 1 {
			return c.Status(fiber.StatusUnauthorized).JSON(map[string]string{"error": "authentication required"})
		}
		return c.Next()
	}
}