package api

import (
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"

	"crypto-miner-server/internal/db"
)

func TestSeerHandlerGetStream(t *testing.T) {
	database, err := db.New(t.TempDir())
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { database.Close() })
	_ = database.InsertSeerNote("agent-1", "wsl tier blocked by Defender", "abc123")
	_, _ = database.InsertSeerEvent("llm_request", "agent-1", []byte(`{"direction":"request"}`))

	h := NewSeerHandler(database)
	req := httptest.NewRequest(http.MethodGet, "/api/v1/seer/stream?limit=10", nil)
	rec := httptest.NewRecorder()
	h.GetStream(rec, req)
	if rec.Code != http.StatusOK {
		t.Fatalf("status %d body %s", rec.Code, rec.Body.String())
	}
	var body map[string]interface{}
	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
		t.Fatal(err)
	}
	notes, _ := body["notes"].([]interface{})
	if len(notes) != 1 {
		t.Fatalf("notes: %v", body["notes"])
	}
	events, _ := body["events"].([]interface{})
	if len(events) != 1 {
		t.Fatalf("events: %v", body["events"])
	}
}

func TestSeerHandlerPostStream(t *testing.T) {
	database, err := db.New(t.TempDir())
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { database.Close() })

	h := NewSeerHandler(database)
	req := httptest.NewRequest(http.MethodPost, "/api/v1/seer/stream",
		strings.NewReader(`{"note":"manual insight","agent_id":"agent-x"}`))
	rec := httptest.NewRecorder()
	h.PostStream(rec, req)
	if rec.Code != http.StatusOK {
		t.Fatalf("status %d body %s", rec.Code, rec.Body.String())
	}
	notes, err := database.ListSeerNotes(10)
	if err != nil || len(notes) != 1 {
		t.Fatalf("notes=%v err=%v", notes, err)
	}
}

func TestSeerToolStubs(t *testing.T) {
	h := NewSeerHandler(nil)
	for _, tc := range []struct {
		name string
		fn   func(http.ResponseWriter, *http.Request)
	}{
		{"spread_route", h.ToolSpreadRoute},
		{"graft_strain", h.ToolGraftStrain},
		{"fork_onion", h.ToolForkOnion},
	} {
		t.Run(tc.name, func(t *testing.T) {
			req := httptest.NewRequest(http.MethodPost, "/api/v1/seer/tools/"+tc.name,
				strings.NewReader(`{"agent_id":"a1"}`))
			rec := httptest.NewRecorder()
			tc.fn(rec, req)
			if rec.Code != http.StatusOK {
				t.Fatalf("status %d", rec.Code)
			}
			var body map[string]interface{}
			if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
				t.Fatal(err)
			}
			if body["stub"] != true {
				t.Fatalf("expected stub response: %v", body)
			}
		})
	}
}

func TestSeerBridgeNotesForPrompt(t *testing.T) {
	database, err := db.New(t.TempDir())
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { database.Close() })
	_ = database.InsertSeerNote("", "fleet-wide note", "h1")
	_ = database.InsertSeerNote("agent-1", "agent note", "h2")

	bridge := &SeerBridge{DB: database}
	got := bridge.NotesForPrompt("agent-1")
	if !strings.Contains(got, "fleet-wide note") || !strings.Contains(got, "agent note") {
		t.Fatalf("notes block: %q", got)
	}
}

func TestSeerBridgeEmitEvent(t *testing.T) {
	database, err := db.New(t.TempDir())
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { database.Close() })

	bridge := &SeerBridge{DB: database}
	bridge.EmitEvent("agent-1", "response", map[string]string{"content": "ok"})
	events, err := database.ListSeerEvents(5)
	if err != nil || len(events) != 1 {
		t.Fatalf("events=%v err=%v", events, err)
	}
	if events[0].EventType != "llm_response" {
		t.Fatalf("event type: %s", events[0].EventType)
	}
}