package inbox

import (
	"bytes"
	"encoding/json"
	"path/filepath"
	"testing"
)

func TestInboxLifecycle(t *testing.T) {
	t.Parallel()

	dbPath := filepath.Join(t.TempDir(), "coord.db")

	initOut := runInboxCommand(t, "--db", dbPath, "--json", "init")
	var initResp map[string]any
	mustDecodeJSON(t, initOut, &initResp)
	if initResp["ok"] != true {
		t.Fatalf("expected init ok=true, got %#v", initResp)
	}

	sendOut := runInboxCommand(
		t,
		"--db", dbPath,
		"--json",
		"send",
		"--from", "leader",
		"--to", "worker-a",
		"--subject", "Implement feature X",
		"--summary", "Add retry policy",
		"--body", "Implement retry handling for the HTTP client.",
		"--run", "run_blog_001",
		"--task", "T1",
	)

	var sendResp map[string]any
	mustDecodeJSON(t, sendOut, &sendResp)
	threadID := nestedString(t, sendResp, "data", "thread", "thread_id")
	threadStatus := nestedString(t, sendResp, "data", "thread", "status")
	if threadStatus != "pending" {
		t.Fatalf("expected pending thread, got %q", threadStatus)
	}

	fetchOut := runInboxCommand(
		t,
		"--db", dbPath,
		"--json",
		"fetch",
		"--agent", "worker-a",
		"--status", "pending",
	)

	var fetchResp map[string]any
	mustDecodeJSON(t, fetchOut, &fetchResp)
	threadsValue := nestedValue(t, fetchResp, "data", "threads")
	threads, ok := threadsValue.([]any)
	if !ok || len(threads) != 1 {
		t.Fatalf("expected one fetched thread, got %#v", threadsValue)
	}

	claimOut := runInboxCommand(
		t,
		"--db", dbPath,
		"--json",
		"claim",
		"--agent", "worker-a",
		"--thread", threadID,
		"--lease-seconds", "300",
	)

	var claimResp map[string]any
	mustDecodeJSON(t, claimOut, &claimResp)
	claimedStatus := nestedString(t, claimResp, "data", "thread", "status")
	if claimedStatus != "claimed" {
		t.Fatalf("expected claimed thread, got %q", claimedStatus)
	}

	showOut := runInboxCommand(
		t,
		"--db", dbPath,
		"--json",
		"show",
		"--thread", threadID,
	)

	var showResp map[string]any
	mustDecodeJSON(t, showOut, &showResp)
	showStatus := nestedString(t, showResp, "data", "thread", "status")
	if showStatus != "claimed" {
		t.Fatalf("expected show status claimed, got %q", showStatus)
	}
	messagesValue := nestedValue(t, showResp, "data", "messages")
	messages, ok := messagesValue.([]any)
	if !ok || len(messages) != 2 {
		t.Fatalf("expected two messages in thread history, got %#v", messagesValue)
	}
}

func runInboxCommand(t *testing.T, args ...string) string {
	t.Helper()

	cmd := NewRootCmd()
	var stdout bytes.Buffer
	var stderr bytes.Buffer
	cmd.SetOut(&stdout)
	cmd.SetErr(&stderr)
	cmd.SetArgs(args)

	if err := cmd.Execute(); err != nil {
		t.Fatalf("execute inbox command %v: %v\nstderr:\n%s", args, err, stderr.String())
	}

	return stdout.String()
}

func mustDecodeJSON(t *testing.T, raw string, target any) {
	t.Helper()

	if err := json.Unmarshal([]byte(raw), target); err != nil {
		t.Fatalf("decode json %q: %v", raw, err)
	}
}

func nestedString(t *testing.T, value map[string]any, keys ...string) string {
	t.Helper()

	current := nestedValue(t, value, keys...)
	str, ok := current.(string)
	if !ok {
		t.Fatalf("expected string at %v, got %#v", keys, current)
	}
	return str
}

func nestedValue(t *testing.T, value map[string]any, keys ...string) any {
	t.Helper()

	var current any = value
	for _, key := range keys {
		obj, ok := current.(map[string]any)
		if !ok {
			t.Fatalf("expected object at %q in %v, got %#v", key, keys, current)
		}
		current, ok = obj[key]
		if !ok {
			t.Fatalf("missing key %q in %v", key, keys)
		}
	}
	return current
}