package cli

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"net/http/httptest"
	"path/filepath"
	"strings"
	"testing"
	"time"

	gitcrawlopenai "github.com/openclaw/gitcrawl/internal/openai"
	"github.com/openclaw/gitcrawl/internal/store"
)

func TestSummarizeCommandPersistsCurrentRevisionSummary(t *testing.T) {
	ctx := context.Background()
	dir := t.TempDir()
	configPath := filepath.Join(dir, "config.toml")
	dbPath := filepath.Join(dir, "gitcrawl.db")
	if err := New().Run(ctx, []string{"--config", configPath, "init", "--db", dbPath}); err != nil {
		t.Fatalf("init: %v", err)
	}
	st, err := store.Open(ctx, dbPath)
	if err != nil {
		t.Fatalf("open store: %v", err)
	}
	repoID, err := st.UpsertRepository(ctx, store.Repository{
		Owner:     "openclaw",
		Name:      "openclaw",
		FullName:  "openclaw/openclaw",
		RawJSON:   "{}",
		UpdatedAt: "2026-07-12T00:00:00Z",
	})
	if err != nil {
		t.Fatalf("repository: %v", err)
	}
	thread := store.Thread{
		RepoID:          repoID,
		GitHubID:        "42",
		Number:          42,
		Kind:            "issue",
		State:           "open",
		Title:           "Gateway reconnect loop",
		Body:            "Reconnect loops after websocket timeout.",
		HTMLURL:         "https://github.com/openclaw/openclaw/issues/42",
		LabelsJSON:      "[]",
		AssigneesJSON:   "[]",
		RawJSON:         "{}",
		ContentHash:     "thread",
		UpdatedAtGitHub: "2026-07-12T00:00:00Z",
		UpdatedAt:       "2026-07-12T00:00:00Z",
	}
	threadID, err := st.UpsertThread(ctx, thread)
	if err != nil {
		t.Fatalf("thread: %v", err)
	}
	thread.ID = threadID
	if _, err := st.UpsertDocument(ctx, store.Document{
		ThreadID:   threadID,
		Title:      thread.Title,
		Body:       thread.Body,
		RawText:    thread.Title + "\n\n" + thread.Body,
		DedupeText: thread.Title + " " + thread.Body,
		UpdatedAt:  thread.UpdatedAt,
	}); err != nil {
		t.Fatalf("document: %v", err)
	}
	if _, err := st.UpsertThreadRevisionAndFingerprint(ctx, store.ThreadEvidence{Thread: thread}, "2026-07-12T00:00:00Z"); err != nil {
		t.Fatalf("enrichment: %v", err)
	}
	if err := st.Close(); err != nil {
		t.Fatalf("close store: %v", err)
	}

	var calls int
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		calls++
		if r.URL.Path != "/responses" {
			t.Fatalf("path = %q", r.URL.Path)
		}
		var payload struct {
			Input string `json:"input"`
		}
		if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
			t.Fatalf("decode request: %v", err)
		}
		if !strings.Contains(payload.Input, "Gateway reconnect loop") {
			t.Fatalf("input = %q", payload.Input)
		}
		_ = json.NewEncoder(w).Encode(map[string]any{
			"output": []map[string]any{{
				"type": "message",
				"content": []map[string]any{{
					"type": "output_text",
					"text": "Gateway reconnect loops after websocket timeout.",
				}},
			}},
		})
	}))
	defer server.Close()
	t.Setenv("OPENAI_API_KEY", "test-key")
	t.Setenv("GITCRAWL_OPENAI_BASE_URL", server.URL)
	t.Setenv("GITCRAWL_OPENAI_RETRY_DISABLED", "1")

	app := New()
	var stdout bytes.Buffer
	app.Stdout = &stdout
	if err := app.Run(ctx, []string{"--config", configPath, "summarize", "openclaw/openclaw", "--json"}); err != nil {
		t.Fatalf("summarize: %v", err)
	}
	var result summaryResult
	if err := json.Unmarshal(stdout.Bytes(), &result); err != nil {
		t.Fatalf("decode result: %v\n%s", err, stdout.String())
	}
	if result.Selected != 1 || result.Summarized != 1 || result.Status != "success" {
		t.Fatalf("result = %+v", result)
	}

	st, err = store.Open(ctx, dbPath)
	if err != nil {
		t.Fatalf("reopen store: %v", err)
	}
	defer st.Close()
	coverage, err := st.ArchiveCoverage(ctx, store.ArchiveCoverageOptions{})
	if err != nil {
		t.Fatalf("coverage: %v", err)
	}
	if len(coverage.Rows) != 1 || coverage.Rows[0].Enrichment.Summaries.Fresh != 1 {
		t.Fatalf("summary coverage = %+v", coverage.Rows)
	}
	runs, err := st.ListRuns(ctx, repoID, "summary", 1)
	if err != nil {
		t.Fatalf("summary runs: %v", err)
	}
	if len(runs) != 1 || runs[0].Status != "success" {
		t.Fatalf("summary runs = %+v", runs)
	}
	if err := st.Close(); err != nil {
		t.Fatalf("close before rerun: %v", err)
	}
	stdout.Reset()
	if err := app.Run(ctx, []string{"--config", configPath, "summarize", "openclaw/openclaw", "--json"}); err != nil {
		t.Fatalf("summarize current: %v", err)
	}
	if calls != 1 {
		t.Fatalf("current summary triggered another API call: %d", calls)
	}
}

func TestSummaryInputIncludesThreadIdentity(t *testing.T) {
	input := summaryInput(store.SummaryTask{
		Number: 7,
		Kind:   "pull_request",
		Title:  "Fix reconnect",
		Text:   "Evidence body",
	})
	for _, want := range []string{"kind: pull_request", "number: #7", "title: Fix reconnect", "Evidence body"} {
		if !strings.Contains(input, want) {
			t.Fatalf("input missing %q: %s", want, input)
		}
	}
}

func TestSummarizeCommandRecordsPartialAPIResults(t *testing.T) {
	ctx := context.Background()
	dir := t.TempDir()
	configPath := filepath.Join(dir, "config.toml")
	dbPath := filepath.Join(dir, "gitcrawl.db")
	if err := New().Run(ctx, []string{"--config", configPath, "init", "--db", dbPath}); err != nil {
		t.Fatalf("init: %v", err)
	}
	st, err := store.Open(ctx, dbPath)
	if err != nil {
		t.Fatalf("open store: %v", err)
	}
	repoID, err := st.UpsertRepository(ctx, store.Repository{
		Owner:     "openclaw",
		Name:      "openclaw",
		FullName:  "openclaw/openclaw",
		RawJSON:   "{}",
		UpdatedAt: "2026-07-12T00:00:00Z",
	})
	if err != nil {
		t.Fatalf("repository: %v", err)
	}
	for _, number := range []int{42, 43} {
		thread := store.Thread{
			RepoID:          repoID,
			GitHubID:        fmt.Sprintf("%d", number),
			Number:          number,
			Kind:            "issue",
			State:           "open",
			Title:           fmt.Sprintf("Summary case %d", number),
			Body:            "Distinct evidence.",
			HTMLURL:         fmt.Sprintf("https://github.com/openclaw/openclaw/issues/%d", number),
			LabelsJSON:      "[]",
			AssigneesJSON:   "[]",
			RawJSON:         "{}",
			ContentHash:     fmt.Sprintf("thread-%d", number),
			UpdatedAtGitHub: "2026-07-12T00:00:00Z",
			UpdatedAt:       "2026-07-12T00:00:00Z",
		}
		threadID, err := st.UpsertThread(ctx, thread)
		if err != nil {
			t.Fatalf("thread %d: %v", number, err)
		}
		thread.ID = threadID
		if _, err := st.UpsertDocument(ctx, store.Document{
			ThreadID:   threadID,
			Title:      thread.Title,
			Body:       thread.Body,
			RawText:    thread.Title + "\n\n" + thread.Body,
			DedupeText: thread.Title + " " + thread.Body,
			UpdatedAt:  thread.UpdatedAt,
		}); err != nil {
			t.Fatalf("document %d: %v", number, err)
		}
		if _, err := st.UpsertThreadRevisionAndFingerprint(ctx, store.ThreadEvidence{Thread: thread}, "2026-07-12T00:00:00Z"); err != nil {
			t.Fatalf("enrichment %d: %v", number, err)
		}
	}
	if err := st.Close(); err != nil {
		t.Fatalf("close store: %v", err)
	}

	failAll := false
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		var payload struct {
			Input string `json:"input"`
		}
		if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
			t.Fatalf("decode request: %v", err)
		}
		if failAll || strings.Contains(payload.Input, "number: #43") {
			w.WriteHeader(http.StatusBadRequest)
			_ = json.NewEncoder(w).Encode(map[string]any{"error": map[string]any{
				"message": "summary rejected",
				"type":    "invalid_request_error",
				"code":    "bad_summary",
			}})
			return
		}
		_ = json.NewEncoder(w).Encode(map[string]any{"output_text": "Stable summary."})
	}))
	defer server.Close()
	t.Setenv("OPENAI_API_KEY", "test-key")
	t.Setenv("GITCRAWL_OPENAI_BASE_URL", server.URL)
	t.Setenv("GITCRAWL_OPENAI_RETRY_DISABLED", "1")

	app := New()
	var stdout bytes.Buffer
	app.Stdout = &stdout
	if err := app.Run(ctx, []string{"--config", configPath, "summarize", "openclaw/openclaw", "--json"}); err != nil {
		t.Fatalf("summarize: %v", err)
	}
	var result summaryResult
	if err := json.Unmarshal(stdout.Bytes(), &result); err != nil {
		t.Fatalf("decode result: %v", err)
	}
	if result.Selected != 2 || result.Summarized != 1 || result.Failed != 1 || result.Status != "partial" {
		t.Fatalf("partial result = %+v", result)
	}
	if len(result.Failures) != 1 || result.Failures[0].Status != http.StatusBadRequest ||
		result.Failures[0].Type != "invalid_request_error" || result.Failures[0].Code != "bad_summary" {
		t.Fatalf("failure metadata = %+v", result.Failures)
	}

	st, err = store.Open(ctx, dbPath)
	if err != nil {
		t.Fatalf("reopen store: %v", err)
	}
	defer st.Close()
	runs, err := st.ListRuns(ctx, repoID, "summary", 1)
	if err != nil {
		t.Fatalf("summary runs: %v", err)
	}
	if len(runs) != 1 || runs[0].Status != "partial" || !strings.Contains(runs[0].ErrorText, "summary rejected") {
		t.Fatalf("summary runs = %+v", runs)
	}
	if err := st.Close(); err != nil {
		t.Fatalf("close before failed rerun: %v", err)
	}
	failAll = true
	stdout.Reset()
	err = app.Run(ctx, []string{"--config", configPath, "summarize", "openclaw/openclaw", "--force", "--json"})
	if err == nil || !strings.Contains(err.Error(), "summary rejected") {
		t.Fatalf("failed summarize error = %v", err)
	}
	st, err = store.Open(ctx, dbPath)
	if err != nil {
		t.Fatalf("reopen after failed run: %v", err)
	}
	defer st.Close()
	runs, err = st.ListRuns(ctx, repoID, "summary", 1)
	if err != nil {
		t.Fatalf("failed summary runs: %v", err)
	}
	if len(runs) != 1 || runs[0].Status != "error" {
		t.Fatalf("failed summary run = %+v", runs)
	}
}

func TestSummaryFailurePreservesGenericErrors(t *testing.T) {
	failure := summaryFailure(7, fmt.Errorf("network unavailable"))
	if failure.Number != 7 || failure.Message != "network unavailable" || failure.Status != 0 {
		t.Fatalf("generic failure = %+v", failure)
	}
	apiFailure := summaryFailure(8, &gitcrawlopenai.APIError{
		Status:  http.StatusTooManyRequests,
		Type:    "rate_limit_error",
		Code:    "rate_limit",
		Message: "slow down",
	})
	if apiFailure.Status != http.StatusTooManyRequests || apiFailure.Type != "rate_limit_error" ||
		apiFailure.Code != "rate_limit" || !strings.Contains(apiFailure.Message, "slow down") {
		t.Fatalf("API failure = %+v", apiFailure)
	}
}

func TestSummarizeCancelsWorkersAfterPersistenceFailure(t *testing.T) {
	ctx := context.Background()
	dir := t.TempDir()
	configPath := filepath.Join(dir, "config.toml")
	dbPath := filepath.Join(dir, "gitcrawl.db")
	if err := New().Run(ctx, []string{"--config", configPath, "init", "--db", dbPath}); err != nil {
		t.Fatalf("init: %v", err)
	}
	st, err := store.Open(ctx, dbPath)
	if err != nil {
		t.Fatalf("open store: %v", err)
	}
	repoID, err := st.UpsertRepository(ctx, store.Repository{
		Owner: "openclaw", Name: "openclaw", FullName: "openclaw/openclaw", RawJSON: "{}", UpdatedAt: "2026-07-12T00:00:00Z",
	})
	if err != nil {
		t.Fatalf("repository: %v", err)
	}
	for _, number := range []int{42, 43} {
		thread := store.Thread{
			RepoID: repoID, GitHubID: fmt.Sprintf("%d", number), Number: number, Kind: "issue", State: "open",
			Title: fmt.Sprintf("Persistence failure %d", number), Body: "evidence",
			HTMLURL:    fmt.Sprintf("https://github.com/openclaw/openclaw/issues/%d", number),
			LabelsJSON: "[]", AssigneesJSON: "[]", RawJSON: "{}", ContentHash: fmt.Sprintf("thread-%d", number),
			UpdatedAtGitHub: "2026-07-12T00:00:00Z", UpdatedAt: "2026-07-12T00:00:00Z",
		}
		thread.ID, err = st.UpsertThread(ctx, thread)
		if err != nil {
			t.Fatalf("thread %d: %v", number, err)
		}
		if _, err := st.UpsertDocument(ctx, store.Document{
			ThreadID: thread.ID, Title: thread.Title, Body: thread.Body,
			RawText: thread.Title + "\n\n" + thread.Body, DedupeText: thread.Title + " " + thread.Body,
			UpdatedAt: thread.UpdatedAt,
		}); err != nil {
			t.Fatalf("document %d: %v", number, err)
		}
		if _, err := st.UpsertThreadRevisionAndFingerprint(ctx, store.ThreadEvidence{Thread: thread}, thread.UpdatedAt); err != nil {
			t.Fatalf("enrichment %d: %v", number, err)
		}
	}
	if _, err := st.DB().ExecContext(ctx, `
		create trigger reject_summary_insert
		before insert on thread_key_summaries
		begin
			select raise(abort, 'summary persistence rejected');
		end
	`); err != nil {
		t.Fatalf("trigger: %v", err)
	}
	if err := st.Close(); err != nil {
		t.Fatalf("close store: %v", err)
	}

	blockedStarted := make(chan struct{})
	blockedCancelled := make(chan struct{})
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		var payload struct {
			Input string `json:"input"`
		}
		if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
			t.Errorf("decode request: %v", err)
			return
		}
		if strings.Contains(payload.Input, "number: #42") {
			close(blockedStarted)
			<-r.Context().Done()
			close(blockedCancelled)
			return
		}
		select {
		case <-blockedStarted:
		case <-time.After(2 * time.Second):
			t.Error("second summary worker did not start")
		}
		_ = json.NewEncoder(w).Encode(map[string]any{"status": "completed", "output_text": "Fast summary."})
	}))
	defer server.Close()
	t.Setenv("OPENAI_API_KEY", "test-key")
	t.Setenv("GITCRAWL_OPENAI_BASE_URL", server.URL)
	t.Setenv("GITCRAWL_OPENAI_RETRY_DISABLED", "1")

	err = New().Run(ctx, []string{"--config", configPath, "summarize", "openclaw/openclaw", "--json"})
	if err == nil || !strings.Contains(err.Error(), "summary persistence rejected") {
		t.Fatalf("summarize error = %v", err)
	}
	select {
	case <-blockedCancelled:
	case <-time.After(2 * time.Second):
		t.Fatal("blocked summary worker was not cancelled and joined")
	}
}