package agent

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"net/http/httptest"
	"os"
	"strings"
	"testing"
	"unicode/utf8"
)

func memoryConversation(t *testing.T, s *Service, n int) Conversation {
	t.Helper()
	c, err := s.CreateConversation()
	if err != nil {
		t.Fatal(err)
	}
	for i := 1; i <= n; i++ {
		c.Messages = append(c.Messages, ConversationMessage{ID: fmt.Sprintf("u%d", i), Role: "user", Content: fmt.Sprintf("原始需求-%d", i)}, ConversationMessage{ID: fmt.Sprintf("a%d", i), Role: "assistant", Content: fmt.Sprintf("确认结果-%d", i), Status: "complete"})
	}
	if _, err := s.SaveConversation(c); err != nil {
		t.Fatal(err)
	}
	return c
}

func memoryReply(w http.ResponseWriter, text string) {
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string]any{"choices": []any{map[string]any{"message": map[string]any{"content": text}, "finish_reason": "stop"}}})
}

func TestAutomaticMemoryPersistsIncrementallyAndSurvivesStaleSave(t *testing.T) {
	var summaryInputs []string
	var answerInputs [][]modelMessage
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		var body struct {
			Messages  []modelMessage  `json:"messages"`
			Tools     json.RawMessage `json:"tools"`
			MaxTokens int             `json:"max_tokens"`
		}
		json.NewDecoder(r.Body).Decode(&body)
		if body.Messages[0].Content == memoryInstruction {
			if len(body.Tools) > 0 {
				t.Error("summary requested tools")
			}
			summaryInputs = append(summaryInputs, fmt.Sprint(body.Messages[1].Content))
			memoryReply(w, "关键记忆：预算3500元，数量500，只起草不发送。")
		} else {
			answerInputs = append(answerInputs, body.Messages)
			memoryReply(w, "继续执行需求分析。")
		}
	}))
	defer server.Close()
	s, secrets := testService(t)
	cfg := testConfig(server.URL)
	cfg.ContextTurns = 1
	if _, err := s.SaveModelConfig(ModelConfigInput{Config: cfg, APIKey: "key"}); err != nil {
		t.Fatal(err)
	}
	c := memoryConversation(t, s, 3)
	c.Messages[0].Content = "预算3500元，数量500，只起草不发送。原始需求-1"
	s.SaveConversation(c)
	if _, err := s.Chat(c.ID, "继续"); err != nil {
		t.Fatal(err)
	}
	stored, err := s.GetConversation(c.ID)
	if err != nil || stored.Memory == nil || stored.Memory.MessageCount != 4 || len(stored.Messages) != 6 {
		t.Fatalf("checkpoint: %+v %v", stored.Memory, err)
	}
	if len(summaryInputs) != 1 || !strings.Contains(summaryInputs[0], "原始需求-2") || strings.Contains(summaryInputs[0], "原始需求-3") {
		t.Fatalf("wrong summary source: %v", summaryInputs)
	}
	serialized, _ := json.Marshal(answerInputs[0])
	if !strings.Contains(string(serialized), "关键记忆") || !strings.Contains(string(serialized), "原始需求-3") || strings.Contains(string(serialized), "原始需求-2") {
		t.Fatalf("context not compacted: %s", serialized)
	}
	// The frontend loaded c before the summary, then saves messages and a draft.
	c.Draft = "新草稿"
	s.SaveConversation(c)
	stored, _ = s.GetConversation(c.ID)
	if stored.Memory == nil || stored.Draft != "新草稿" {
		t.Fatal("stale save erased server-owned memory")
	}
	restarted := newService(s.configPath, secrets)
	if _, err := restarted.Chat(c.ID, "重启后继续"); err != nil {
		t.Fatal(err)
	}
	if len(summaryInputs) != 1 {
		t.Fatal("unchanged history was summarized again")
	}
	c.Messages = append(c.Messages, ConversationMessage{ID: "u4", Role: "user", Content: "第四轮"}, ConversationMessage{ID: "a4", Role: "assistant", Content: "第四轮确认", Status: "complete"})
	s.SaveConversation(c)
	if _, err := restarted.Chat(c.ID, "继续增量"); err != nil {
		t.Fatal(err)
	}
	if len(summaryInputs) != 2 || !strings.Contains(summaryInputs[1], "关键记忆") || !strings.Contains(summaryInputs[1], "原始需求-3") || strings.Contains(summaryInputs[1], "原始需求-2") {
		t.Fatalf("not incremental: %v", summaryInputs)
	}
	other := memoryConversation(t, s, 0)
	if _, err := restarted.Chat(other.ID, "另一会话"); err != nil {
		t.Fatal(err)
	}
	serialized, _ = json.Marshal(answerInputs[len(answerInputs)-1])
	if strings.Contains(string(serialized), "关键记忆") {
		t.Fatal("memory leaked across conversations")
	}
	c.Messages[0].Content = "用户修改了早期需求"
	s.SaveConversation(c)
	stored, _ = s.GetConversation(c.ID)
	if stored.Memory != nil {
		t.Fatal("edited prefix kept stale memory")
	}
}

func TestLongHistoryChunksWithoutSplittingUnicode(t *testing.T) {
	s, _ := testService(t)
	c := memoryConversation(t, s, 2)
	c.Messages[1].Content = strings.Repeat("重要信息🙂", 10000)
	s.SaveConversation(c)
	chunks := 0
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		var body struct {
			Messages []modelMessage `json:"messages"`
		}
		json.NewDecoder(r.Body).Decode(&body)
		if body.Messages[0].Content != memoryInstruction {
			t.Error("unexpected answer request")
		}
		text := fmt.Sprint(body.Messages[1].Content)
		if !utf8.ValidString(text) || strings.ContainsRune(text, '\ufffd') {
			t.Error("Unicode split")
		}
		chunks++
		memoryReply(w, "记住重要信息，继续保留关键要求。")
	}))
	defer server.Close()
	cfg := testConfig(server.URL)
	cfg.ContextTurns = 10
	turns, memory, found, err := s.prepareMemory(context.Background(), c.ID, cfg, "", nil)
	if err != nil || !found || memory == nil || memory.MessageCount != 2 || len(turns) != 2 || chunks < 2 {
		t.Fatalf("long history: %d %d %+v %v", chunks, len(turns), memory, err)
	}
}

func TestSummaryFailureAndCancellationPreserveOriginal(t *testing.T) {
	for _, mode := range []string{"provider-error", "truncated", "cancel", "changed", "deleted"} {
		t.Run(mode, func(t *testing.T) {
			s, _ := testService(t)
			c := memoryConversation(t, s, 2)
			ctx, cancel := context.WithCancel(context.Background())
			defer cancel()
			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				switch mode {
				case "provider-error":
					http.Error(w, "failed", 500)
					return
				case "truncated":
					fmt.Fprint(w, `{"choices":[{"message":{"content":"半截摘要"},"finish_reason":"length"}]}`)
					return
				case "cancel":
					cancel()
					return
				case "changed":
					c.Messages[0].Content = "已修改"
					s.SaveConversation(c)
				case "deleted":
					s.DeleteConversation(c.ID)
				}
				memoryReply(w, "摘要")
			}))
			defer server.Close()
			cfg := testConfig(server.URL)
			cfg.ContextTurns = 1
			_, _, _, err := s.prepareMemory(ctx, c.ID, cfg, "", nil)
			if err == nil {
				t.Fatal("summary failure was hidden")
			}
			if mode == "cancel" && !errors.Is(err, context.Canceled) {
				t.Fatalf("cancellation lost: %v", err)
			}
			path, _ := s.conversationPath(c.ID)
			if mode == "deleted" {
				if _, err := os.Stat(path); !os.IsNotExist(err) {
					t.Fatal("summary recreated deleted conversation")
				}
				return
			}
			stored, err := s.GetConversation(c.ID)
			if err != nil || stored.Memory != nil || len(stored.Messages) != 4 {
				t.Fatalf("failed summary changed record: %+v %v", stored, err)
			}
		})
	}
}

func TestZeroContextDoesNotReadOrGenerateMemory(t *testing.T) {
	s, _ := testService(t)
	c := memoryConversation(t, s, 3)
	cfg := testConfig("http://127.0.0.1:1")
	cfg.ContextTurns = 0
	turns, memory, found, err := s.prepareMemory(context.Background(), c.ID, cfg, "", nil)
	if err != nil || !found || len(turns) != 0 || memory != nil {
		t.Fatalf("zero context: %v %+v %v", turns, memory, err)
	}
}

func TestSummaryPreservesExistingCheckpointOnFailureAndIncludesToolStates(t *testing.T) {
	s, _ := testService(t)
	c := memoryConversation(t, s, 3)
	c.Messages[1].Tools = []ToolExecution{{ID: "tool", Server: "Phone", Tool: "launch", Status: "complete", Result: "settings opened"}}
	c.Messages = append(c.Messages[:2], append([]ConversationMessage{{ID: "failed-user", Role: "user", Content: "继续操作"}, {ID: "failed-answer", Role: "assistant", Content: "已中断", Status: "stopped", Tools: []ToolExecution{{ID: "tool-failed", Server: "Phone", Tool: "tap", Status: "error", Result: "device offline"}}}}, c.Messages[2:]...)...)
	if _, err := s.SaveConversation(c); err != nil {
		t.Fatal(err)
	}
	var source string
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		var body struct {
			Messages []modelMessage `json:"messages"`
		}
		json.NewDecoder(r.Body).Decode(&body)
		source = fmt.Sprint(body.Messages[1].Content)
		memoryReply(w, "已打开设置；后续操作中断，设备离线，不代表后续动作完成。")
	}))
	defer server.Close()
	cfg := testConfig(server.URL)
	cfg.ContextTurns = 1
	_, memory, _, err := s.prepareMemory(context.Background(), c.ID, cfg, "", nil)
	if err != nil || memory == nil || !strings.Contains(source, "状态=stopped") || !strings.Contains(source, "状态=error") || !strings.Contains(source, "settings opened") || !strings.Contains(source, "device offline") {
		t.Fatalf("tool states lost: %s %v", source, err)
	}
	c.Messages = append(c.Messages, ConversationMessage{ID: "new-u", Role: "user", Content: "新的完成回合"}, ConversationMessage{ID: "new-a", Role: "assistant", Content: "新的结果", Status: "complete"})
	s.SaveConversation(c)
	failing := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { http.Error(w, "offline", 503) }))
	defer failing.Close()
	cfg.BaseURL = failing.URL
	if _, _, _, err = s.prepareMemory(context.Background(), c.ID, cfg, "", nil); err == nil {
		t.Fatal("failure hidden")
	}
	stored, _ := s.GetConversation(c.ID)
	if stored.Memory == nil || stored.Memory.Text != memory.Text || stored.Memory.ThroughID != memory.ThroughID {
		t.Fatal("failed update erased previous checkpoint")
	}
}