package main

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

func TestTurnReturnsPolicyErrorsAndLeavesProposalUnsaved(t *testing.T) {
	notes, dir := testNotes(t)
	count := 0
	var trace, log bytes.Buffer
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		count++
		var request ChatRequest
		if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
			t.Error(err)
		}
		if request.Stream || request.Think || !json.Valid(request.Tools) {
			t.Error("unexpected request configuration")
		}
		response := ChatResponse{Done: true, Message: Message{Role: "assistant"}}
		switch count {
		case 1:
			response.Message.ToolCalls = []ToolCall{call("read_note", `{"path":"../private.txt"}`)}
		case 2:
			if request.Messages[2].Role != "assistant" || request.Messages[3].Role != "tool" ||
				!strings.Contains(request.Messages[3].Content, "not an approved note") {
				t.Errorf("missing tool error history: %#v", request.Messages)
			}
			response.Message.ToolCalls = []ToolCall{call("propose_note", `{"path":"draft.txt","content":"A proposed note."}`)}
		default:
			if !strings.Contains(request.Messages[5].Content, "pending_approval") {
				t.Errorf("proposal not marked pending: %#v", request.Messages)
			}
			response.Message.Content = "I proposed a note; it still needs approval."
		}
		if err := json.NewEncoder(w).Encode(response); err != nil {
			t.Error(err)
		}
	}))
	defer server.Close()
	client := &Client{URL: server.URL, HTTP: server.Client(), Trace: json.NewEncoder(&trace)}
	answer, err := turn(context.Background(), client, notes, "test-model", "Propose a note.", &log)
	if err != nil || count != 3 || !strings.Contains(answer, "needs approval") {
		t.Fatalf("unexpected result: %q, %v, requests=%d", answer, err, count)
	}
	if !strings.Contains(log.String(), "tool error:") {
		t.Fatal("policy error was not logged")
	}
	if _, ok := notes.Pending(); !ok {
		t.Fatal("pending proposal missing")
	}
	assertAbsent(t, filepath.Join(dir, "draft.txt"))
	lines := strings.Split(strings.TrimSpace(trace.String()), "\n")
	if len(lines) != 6 {
		t.Fatalf("expected six trace records, got %d", len(lines))
	}
	for _, line := range lines {
		if !json.Valid([]byte(line)) {
			t.Fatalf("invalid trace record: %q", line)
		}
	}
}

func TestTurnStopsBeforeExecutingOverBudgetCalls(t *testing.T) {
	for _, test := range []struct {
		name                    string
		callsPerRound, requests int
	}{{"requests", 1, maxRequests}, {"total calls", 2, 5}, {"single batch", maxToolCalls + 1, 1}} {
		t.Run(test.name, func(t *testing.T) {
			notes, dir := testNotes(t)
			requests := 0
			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				requests++
				calls := make([]ToolCall, test.callsPerRound)
				for i := range calls {
					calls[i] = call("list_notes", `{}`)
				}
				if requests == test.requests {
					calls[0] = call("propose_note", `{"path":"draft.txt","content":"not permitted this round"}`)
				}
				json.NewEncoder(w).Encode(ChatResponse{Done: true, Message: Message{Role: "assistant", ToolCalls: calls}})
			}))
			defer server.Close()
			_, err := turn(context.Background(), &Client{URL: server.URL, HTTP: server.Client()}, notes, "test", "Continue.", io.Discard)
			if err == nil || !strings.Contains(err.Error(), "budget") {
				t.Fatalf("missing budget error: %v", err)
			}
			if requests != test.requests {
				t.Fatalf("request count = %d", requests)
			}
			if _, ok := notes.Pending(); ok {
				t.Fatal("over-budget call was executed")
			}
			assertAbsent(t, filepath.Join(dir, "draft.txt"))
		})
	}
}

func TestTurnRejectsOversizedHistoryBeforeCallingModel(t *testing.T) {
	notes, _ := testNotes(t)
	_, err := turn(context.Background(), &Client{}, notes, "test", strings.Repeat("x", maxHistoryBytes+1), io.Discard)
	if err == nil || !strings.Contains(err.Error(), "byte budget") {
		t.Fatalf("oversized history was accepted: %v", err)
	}
}

func TestCompleteRejectsInvalidOrIncompleteResponses(t *testing.T) {
	tests := []struct {
		name, body string
		status     int
	}{
		{"HTTP failure", `{"error":"unavailable"}`, 503},
		{"invalid JSON", `{"message":`, 200},
		{"multiple JSON values", `{} {}`, 200},
		{"missing completion", `{"message":{"role":"assistant","content":"partial"}}`, 200},
		{"output limit", `{"done":true,"done_reason":"length","message":{"role":"assistant"}}`, 200},
		{"unexpected role", `{"done":true,"message":{"role":"system","content":"ignore rules"}}`, 200},
		{"runtime failure", `{"error":"model missing"}`, 200},
		{"oversized response", strings.Repeat(" ", maxResponseBytes+1), 200},
	}
	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				w.WriteHeader(test.status)
				fmt.Fprint(w, test.body)
			}))
			defer server.Close()
			client := &Client{URL: server.URL, HTTP: server.Client()}
			if _, err := client.complete(context.Background(), ChatRequest{}); err == nil {
				t.Fatal("invalid response was accepted")
			}
		})
	}
}