package main

import (
	"context"
	"encoding/json"
	"errors"
	"net/http"
	"path/filepath"
	"strings"
	"sync"
	"testing"
	"time"

	"github.com/stretchr/testify/require"
)

func TestTurnRunsToolsUntilTheFinalAnswer(t *testing.T) {
	server := newFakeResponses(t)
	server.reply = func(w http.ResponseWriter, call fakeCall) {
		if call.number == 0 {
			writeEvents(w, completedEvent([]any{
				reasoningItem("rs_1", "opaque thought"),
				functionCallItem("fc_1", "call_1", "shell", `{"command":"echo hi"}`),
			}, 100, 0, 5))

			return
		}

		writeEvents(w, completedEvent([]any{messageItem("It said hi.")}, 120, 100, 5))
	}

	test := newTestLoop(t, server)
	_, err := test.loop.Submit("Run echo hi.")
	require.NoError(t, err)
	test.events.WaitFor(t, "idle", 1)
	require.Equal(t, 2, server.Calls())

	first := server.Call(0).body
	second := server.Call(1).body
	instructions, err := test.agent.Prompt()
	require.NoError(t, err)
	require.Equal(t, instructions, first["instructions"])
	require.Equal(t, test.agent.config.Model, first["model"])

	// The second request begins with the whole first one.
	firstInput := first["input"].([]any)
	secondInput := second["input"].([]any)
	require.Equal(t, firstInput, secondInput[:len(firstInput)])
	require.Equal(t, []any{
		map[string]any{"type": "reasoning", "encrypted_content": "opaque thought", "summary": []any{}},
		map[string]any{"type": "function_call", "call_id": "call_1", "name": "shell", "arguments": `{"command":"echo hi"}`},
		map[string]any{"type": "function_call_output", "call_id": "call_1", "output": "hi\n"},
	}, secondInput[len(firstInput):])

	require.Equal(t, []string{
		"user: Run echo hi.",
		`tool: shell {"command":"echo hi"}`,
		"echo: hi\n",
		"reply: It said hi.",
	}, test.Log(t))
	require.Equal(t, []string{"user", "busy", "tool", "echo", "reply", "idle"}, test.events.Kinds())
}

func TestFirstRequestHoldsTheViewTheStateAndTheMessage(t *testing.T) {
	server := newFakeResponses(t)
	test := newTestLoop(t, server)
	_, err := test.memory.Append("user", "an earlier message")
	require.NoError(t, err)

	_, err = test.loop.Submit("The new message.")
	require.NoError(t, err)
	test.events.WaitFor(t, "idle", 1)

	require.Equal(t, []string{
		"<chat>\n0+1|user: an earlier message\n",
		"</chat>\n\nNow: Thursday 2026-01-01 12:00 +00:00",
		"The new message.",
	}, inputTexts(t, server.Call(0)))
}

func TestMessageDuringATurnJoinsTheNextRequest(t *testing.T) {
	server := newFakeResponses(t)
	arrived := make(chan struct{})
	release := make(chan struct{})
	server.reply = func(w http.ResponseWriter, call fakeCall) {
		if call.number == 0 {
			close(arrived)
			<-release
			writeEvents(w, completedEvent([]any{functionCallItem("fc_1", "call_1", "date", `{"id":0}`)}, 100, 0, 5))

			return
		}

		writeEvents(w, completedEvent([]any{messageItem("done")}, 100, 0, 5))
	}

	test := newTestLoop(t, server)
	_, err := test.loop.Submit("first")
	require.NoError(t, err)

	<-arrived
	_, err = test.loop.Submit("second, during the turn")
	require.NoError(t, err)
	close(release)

	test.events.WaitFor(t, "idle", 1)
	input := server.Call(1).body["input"].([]any)
	require.Equal(t, map[string]any{
		"role":    "user",
		"content": []any{map[string]any{"type": "input_text", "text": "second, during the turn"}},
	}, input[len(input)-1])

	time.Sleep(50 * time.Millisecond)
	require.Equal(t, 2, server.Calls())
	require.Equal(t, 1, test.events.Count("busy"))
}

func TestMessageDuringTheFinalRequestStartsANewTurn(t *testing.T) {
	server := newFakeResponses(t)
	arrived := make(chan struct{})
	release := make(chan struct{})
	server.reply = func(w http.ResponseWriter, call fakeCall) {
		if call.number == 0 {
			close(arrived)
			<-release
		}

		writeEvents(w, completedEvent([]any{messageItem("answer")}, 100, 0, 5))
	}

	test := newTestLoop(t, server)
	_, err := test.loop.Submit("first")
	require.NoError(t, err)

	<-arrived
	_, err = test.loop.Submit("second")
	require.NoError(t, err)
	close(release)

	test.events.WaitFor(t, "idle", 2)
	require.Equal(t, 2, server.Calls())

	texts := inputTexts(t, server.Call(1))
	require.Equal(t, "second", texts[len(texts)-1])
	require.Contains(t, strings.Join(texts, ""), "|reply: answer\n")
}

func TestTurnWaitsForTheSummaries(t *testing.T) {
	server := newFakeResponses(t)
	summarizer := newFakeSummarizer()
	summarizer.gate = make(chan struct{})
	test := newTestLoopWith(t, server, summarizer, false)

	_, err := test.memory.Append("echo", strings.Repeat("long output ", 100))
	require.NoError(t, err)

	_, err = test.loop.Submit("go on")
	require.NoError(t, err)

	time.Sleep(50 * time.Millisecond)
	require.Equal(t, 0, server.Calls())

	close(summarizer.gate)
	test.events.WaitFor(t, "idle", 1)
	require.Equal(t, 1, server.Calls())
	require.NotContains(t, inputTexts(t, server.Call(0))[0], pending)
}

func TestInterruptEndsTheTurn(t *testing.T) {
	server := newFakeResponses(t)
	arrived := make(chan struct{})
	release := make(chan struct{})
	server.reply = func(w http.ResponseWriter, call fakeCall) {
		if call.number == 0 {
			close(arrived)
			<-release
		}

		writeEvents(w, completedEvent([]any{messageItem("answer")}, 100, 0, 5))
	}

	test := newTestLoop(t, server)
	_, err := test.loop.Submit("a long task")
	require.NoError(t, err)

	<-arrived
	require.True(t, test.loop.Interrupt())
	test.events.WaitFor(t, "idle", 1)
	close(release)

	require.Equal(t, "interrupted", test.events.Last("error"))
	require.Equal(t, []string{"user: a long task"}, test.Log(t))
	require.False(t, test.loop.Interrupt())

	_, err = test.loop.Submit("again")
	require.NoError(t, err)
	test.events.WaitFor(t, "idle", 2)
	require.Equal(t, "reply: answer", test.Log(t)[2])
}

func TestFailedCallEndsTheTurnWithoutARetry(t *testing.T) {
	server := newFakeResponses(t)
	server.reply = func(w http.ResponseWriter, call fakeCall) {
		http.Error(w, "busy", http.StatusServiceUnavailable)
	}

	test := newTestLoop(t, server)
	_, err := test.loop.Submit("hello")
	require.NoError(t, err)
	test.events.WaitFor(t, "idle", 1)

	time.Sleep(50 * time.Millisecond)
	require.Equal(t, 1, server.Calls())
	require.Contains(t, test.events.Last("error"), "HTTP 503")
}

func TestViewMessagesOnlyGrowBetweenTurns(t *testing.T) {
	server := newFakeResponses(t)
	test := newTestLoop(t, server)
	for n, text := range []string{"one", "two", "three"} {
		_, err := test.loop.Submit(text)
		require.NoError(t, err)
		test.events.WaitFor(t, "idle", n+1)
	}

	first := server.Call(1).body["input"].([]any)
	second := server.Call(2).body["input"].([]any)
	require.Len(t, first, 4)
	require.Len(t, second, 5)
	require.Equal(t, first[:2], second[:2])
	require.Equal(t, []string{
		"<chat>\n",
		"0+1|user: one\n1+1|reply: a line\n",
		"2+1|user: two\n3+1|reply: a line\n",
		"</chat>\n\nNow: Thursday 2026-01-01 12:00 +00:00",
		"three",
	}, inputTexts(t, server.Call(2)))
}

func TestWarmUpEndsWhereTheNextTurnReadsTheCache(t *testing.T) {
	server := newFakeResponses(t)
	server.reply = func(w http.ResponseWriter, call fakeCall) {
		if call.number == 1 {
			writeEvents(w, map[string]any{"type": "response.output_item.added", "item": reasoningItem("rs_1", "")})
			return
		}

		writeEvents(w, completedEvent([]any{messageItem("answer")}, 100, 0, 5))
	}

	test := newTestLoopWith(t, server, newFakeSummarizer(), true)
	_, err := test.loop.Submit("one")
	require.NoError(t, err)
	require.Eventually(t, func() bool {
		return server.Calls() == 2
	}, 10*time.Second, time.Millisecond)

	_, err = test.loop.Submit("two")
	require.NoError(t, err)
	test.events.WaitFor(t, "idle", 2)
	require.Eventually(t, func() bool {
		return server.Calls() == 4
	}, 10*time.Second, time.Millisecond)

	warmUp := server.Call(1).body
	require.Equal(t, server.Call(0).body["instructions"], warmUp["instructions"])
	require.Equal(t, server.Call(0).body["tools"], warmUp["tools"])
	require.Equal(t, []string{"<chat>\n", "0+1|user: one\n1+1|reply: answer\n"}, inputTexts(t, server.Call(1)))

	// The next turn begins with the whole warm-up, so its message end after
	// the view is the end of the warm-up entry.
	warmInput := warmUp["input"].([]any)
	turnInput := server.Call(2).body["input"].([]any)
	require.Equal(t, warmInput, turnInput[:len(warmInput)])
	require.Equal(t, "</chat>\n\nNow: Thursday 2026-01-01 12:00 +00:00", inputTexts(t, server.Call(2))[len(warmInput)])

	turns := []string{}
	for _, record := range readUsage(t, test.usagePath) {
		turns = append(turns, record.Turn)
	}

	require.Equal(t, []string{"first", "warmup", "first", "warmup"}, turns)
	require.Equal(t, []string{"user: one", "reply: answer", "user: two", "reply: answer"}, test.Log(t))
}

// testLoop is a loop that runs in the background of a test, with its parts.
type testLoop struct {
	agent     *Agent
	memory    *Memory
	loop      *loop
	events    *eventRecorder
	usagePath string
}

// Log returns the logged messages as "kind: text".
func (l *testLoop) Log(t *testing.T) []string {
	t.Helper()

	var lines []string
	for id := range l.memory.Len() {
		message, err := l.memory.Message(id)
		require.NoError(t, err)

		lines = append(lines, message.Kind+": "+message.Text)
	}

	return lines
}

// eventRecorder keeps the events of a loop.
type eventRecorder struct {
	mutex  sync.Mutex
	events []Event
}

func (r *eventRecorder) Add(event Event) {
	r.mutex.Lock()
	defer r.mutex.Unlock()

	r.events = append(r.events, event)
}

func (r *eventRecorder) Kinds() []string {
	r.mutex.Lock()
	defer r.mutex.Unlock()

	kinds := make([]string, len(r.events))
	for n, event := range r.events {
		kinds[n] = event.Kind
	}

	return kinds
}

func (r *eventRecorder) Count(kind string) int {
	count := 0
	for _, each := range r.Kinds() {
		if each == kind {
			count++
		}
	}

	return count
}

// Last returns the text of the last event of kind.
func (r *eventRecorder) Last(kind string) string {
	r.mutex.Lock()
	defer r.mutex.Unlock()

	for n := len(r.events) - 1; n >= 0; n-- {
		if r.events[n].Kind == kind {
			return r.events[n].Text
		}
	}

	return ""
}

// WaitFor waits until count events of kind came.
func (r *eventRecorder) WaitFor(t *testing.T, kind string, count int) {
	t.Helper()

	require.Eventually(t, func() bool {
		return r.Count(kind) >= count
	}, 10*time.Second, time.Millisecond)
}

func newTestLoop(t *testing.T, server *fakeResponses) *testLoop {
	t.Helper()

	return newTestLoopWith(t, server, newFakeSummarizer(), false)
}

// newTestLoopWith returns a running loop on a new agent whose builds use
// summarizer and whose commands run in a temporary directory. warmUp turns the
// warm-up on.
func newTestLoopWith(t *testing.T, server *fakeResponses, summarizer Summarizer, warmUp bool) *testLoop {
	t.Helper()

	agent, err := openAgent(t.TempDir())
	require.NoError(t, err)

	agent.config.Workdir = t.TempDir()
	clock := newTestClock()
	memory, err := openMemory(t.Context(), t.TempDir(), clock.Now, summarizer)
	require.NoError(t, err)

	test := &testLoop{
		agent:     agent,
		memory:    memory,
		events:    &eventRecorder{},
		usagePath: filepath.Join(t.TempDir(), "usage.jsonl"),
	}

	client := newClient(server.URL, apiKey(testKey), agent.CacheKey(), test.usagePath)
	test.loop, err = newLoop(agent, memory, client, clock.Now, test.events.Add)
	require.NoError(t, err)

	test.loop.warmUp = warmUp
	ctx, cancel := context.WithCancel(t.Context())
	done := make(chan error)
	go func() {
		done <- test.loop.Run(ctx)
	}()

	t.Cleanup(func() {
		cancel()
		require.True(t, errors.Is(<-done, context.Canceled))
		require.NoError(t, memory.Close())
	})

	return test
}

// inputTexts returns the text of each user message of the input of call.
func inputTexts(t *testing.T, call fakeCall) []string {
	t.Helper()

	var body struct {
		Input []struct {
			Role    string `json:"role"`
			Content []struct {
				Text string `json:"text"`
			} `json:"content"`
		} `json:"input"`
	}

	require.NoError(t, json.Unmarshal(call.raw, &body))

	var texts []string
	for _, item := range body.Input {
		if item.Role != "user" {
			continue
		}

		var text strings.Builder
		for _, part := range item.Content {
			text.WriteString(part.Text)
		}

		texts = append(texts, text.String())
	}

	return texts
}

func reasoningItem(id, encrypted string) map[string]any {
	return map[string]any{
		"type":              "reasoning",
		"id":                id,
		"encrypted_content": encrypted,
		"summary":           []any{},
	}
}

func functionCallItem(id, callID, name, arguments string) map[string]any {
	return map[string]any{
		"type":      "function_call",
		"id":        id,
		"call_id":   callID,
		"name":      name,
		"arguments": arguments,
	}
}