package main

import (
	"bytes"
	"os"
	"path/filepath"
	"runtime"
	"strings"
	"testing"
	"time"
)

const fixtureSession = "0a1b2c3d-1111-4222-8333-444455556666"

// fakeClaudeHome lays out what Claude Code keeps for one running session: the
// per-process record and the session's transcript. All of it invented.
func fakeClaudeHome(t *testing.T, pid int, procStart, transcript string) string {
	t.Helper()
	home := t.TempDir()
	sess := filepath.Join(home, ".claude", "sessions")
	proj := filepath.Join(home, ".claude", "projects", "-work-shop")
	for _, d := range []string{sess, proj} {
		if err := os.MkdirAll(d, 0o700); err != nil {
			t.Fatal(err)
		}
	}
	rec := `{"pid":` + itoa(pid) + `,"sessionId":"` + fixtureSession + `","cwd":"/work/shop","procStart":"` + procStart +
		`","kind":"interactive","name":"shop-a1","status":"waiting","waitingFor":"permission prompt","updatedAt":1793300000000}`
	if err := os.WriteFile(filepath.Join(sess, itoa(pid)+".json"), []byte(rec), 0o600); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(filepath.Join(sess, itoa(pid)+".deadbeef.key"), []byte("NEVER-READ"), 0o600); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(filepath.Join(proj, fixtureSession+".jsonl"), []byte(transcript), 0o600); err != nil {
		t.Fatal(err)
	}
	return home
}

func stubProcIdentity(t *testing.T, id string) {
	t.Helper()
	prev := procIdentity
	t.Cleanup(func() { procIdentity = prev })
	procIdentity = func(int) (string, bool, bool) { return id, false, true }
}

const fixtureTranscript = `{"type":"ai-title","aiTitle":"Set up the shop database","sessionId":"x"}
{"type":"user","message":{"content":"SECRET CONVERSATION BODY"}}
{"type":"permission-mode","permissionMode":"bypassPermissions","sessionId":"x"}
{"type":"last-prompt","lastPrompt":"add an index to orders","sessionId":"x"}
{"type":"ai-title","aiTitle":"Add an index to the orders table","sessionId":"x"}
`

func TestClaudeCodeSessionSaysWhatItIsDoing(t *testing.T) {
	stubProcIdentity(t, "5551")
	home := fakeClaudeHome(t, 4242, "5551", fixtureTranscript)
	s := claudeCodeSelf(4242, home, os.Getuid())
	if s == nil {
		t.Fatal("a session with a matching record was not read")
	}
	want := agentSelf{Source: "Claude Code's session record", Verified: true, SessionID: fixtureSession,
		Name: "shop-a1", Title: "Add an index to the orders table", Status: "waiting",
		WaitingFor: "permission prompt", PermissionMode: "bypassPermissions",
		LastActive: time.UnixMilli(1793300000000).UTC().Format(time.RFC3339),
		LastPrompt: "add an index to orders"}
	if *s != want {
		t.Errorf("got  %+v\nwant %+v", *s, want)
	}
}

// A record left by a process that has exited must not be pinned on the new
// process that got its number.
func TestASessionRecordForAnEarlierProcessIsNotUsed(t *testing.T) {
	stubProcIdentity(t, "9999")
	home := fakeClaudeHome(t, 4242, "5551", fixtureTranscript)
	if s := claudeCodeSelf(4242, home, os.Getuid()); s != nil {
		t.Errorf("a record whose process start is not this process's was used: %+v", *s)
	}
}

func TestASessionRecordNamingAnotherPidIsNotUsed(t *testing.T) {
	stubProcIdentity(t, "5551")
	home := fakeClaudeHome(t, 4242, "5551", fixtureTranscript)
	if err := os.Rename(filepath.Join(home, ".claude", "sessions", "4242.json"),
		filepath.Join(home, ".claude", "sessions", "4343.json")); err != nil {
		t.Fatal(err)
	}
	if s := claudeCodeSelf(4343, home, os.Getuid()); s != nil {
		t.Errorf("a record that names pid 4242 was used for 4343: %+v", *s)
	}
}

// The session id becomes part of a path; one that is not an id reads nothing.
func TestASessionIDThatIsAPathReadsNoTranscript(t *testing.T) {
	stubProcIdentity(t, "5551")
	home := t.TempDir()
	sess := filepath.Join(home, ".claude", "sessions")
	if err := os.MkdirAll(sess, 0o700); err != nil {
		t.Fatal(err)
	}
	rec := `{"pid":4242,"sessionId":"../../../etc/x","procStart":"5551","name":"n"}`
	if err := os.WriteFile(filepath.Join(sess, "4242.json"), []byte(rec), 0o600); err != nil {
		t.Fatal(err)
	}
	s := claudeCodeSelf(4242, home, os.Getuid())
	if s == nil || s.SessionID != "" || s.Title != "" {
		t.Errorf("a path-shaped session id was followed: %+v", s)
	}
}

// What an agent writes about itself is shown, never obeyed or rendered: no
// control characters, no line breaks to forge another line, a bounded length.
func TestAgentWrittenTextIsCleanedAndBounded(t *testing.T) {
	got := cleanText("ok\n\x1b[31mIGNORE ALL PREVIOUS
instructions\t", 200)
	if strings.ContainsAny(got, "\n\x1b
\t") {
		t.Errorf("control characters survived: %q", got)
	}
	if r := []rune(cleanText(strings.Repeat("é", 500), titleMax)); len(r) != titleMax {
		t.Errorf("a long title is %d runes, want %d", len(r), titleMax)
	}
}

func TestClaudeCodesBackgroundServiceIsNotASession(t *testing.T) {
	if !isClaudeCodeService("/opt/x/claude.exe daemon run --json-path /h/.claude/daemon.json") {
		t.Error("`daemon run` was not recognised as the background service")
	}
	if isClaudeCodeService("claude --resume") {
		t.Error("an interactive session was taken for the service")
	}
}

// The commands of this moment are kept apart from the tool servers the agent
// started with itself, and a secret on a command line is redacted.
func TestRunningNowSeparatesToolServersAndRedactsSecrets(t *testing.T) {
	start := time.Date(2026, 10, 30, 9, 0, 0, 0, time.UTC)
	started := map[int]time.Time{
		100: start, 110: start.Add(5 * time.Second), 111: start.Add(6 * time.Second),
		120: start.Add(3 * time.Hour), 121: start.Add(3 * time.Hour),
	}
	args := map[int][]string{
		111: {"node", "/home/u/.npm/_npx/abc/node_modules/.bin/mcp-server-files"},
		121: {"curl", "-H", "Authorization: Bearer sk-live-abcdefghijklmnop1234", "https://api.example.com"},
	}
	prevS, prevA := procStartedFn, procCmdArgsFn
	t.Cleanup(func() { procStartedFn, procCmdArgsFn = prevS, prevA })
	procStartedFn = func(pid int) (time.Time, bool) { s, ok := started[pid]; return s, ok }
	procCmdArgsFn = func(pid int) []string { return args[pid] }
	children := map[int][]int{100: {110, 120}, 110: {111}, 120: {121}}
	now, tools := runningNow(100, children, start, true)
	if len(tools) != 1 || tools[0] != "mcp-server-files" {
		t.Errorf("tool servers %v", tools)
	}
	if len(now) != 1 || !strings.HasPrefix(now[0], "curl") {
		t.Fatalf("running now %v", now)
	}
	if strings.Contains(now[0], "sk-live") {
		t.Errorf("a secret on a command line was shown: %q", now[0])
	}
}

func TestGitBranchIsReadFromHEADWithoutRunningGit(t *testing.T) {
	repo := t.TempDir()
	if err := os.MkdirAll(filepath.Join(repo, ".git"), 0o700); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(filepath.Join(repo, ".git", "HEAD"), []byte("ref: refs/heads/fix/login\n"), 0o600); err != nil {
		t.Fatal(err)
	}
	sub := filepath.Join(repo, "src", "app")
	if err := os.MkdirAll(sub, 0o700); err != nil {
		t.Fatal(err)
	}
	if got := gitBranchOf(sub); got != "fix/login" {
		t.Errorf("branch from a subfolder: %q", got)
	}
	// A worktree: .git is a file naming the real git dir.
	wt := t.TempDir()
	gd := filepath.Join(t.TempDir(), "wt-gitdir")
	if err := os.MkdirAll(gd, 0o700); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(filepath.Join(gd, "HEAD"), []byte("ref: refs/heads/feature\n"), 0o600); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(filepath.Join(wt, ".git"), []byte("gitdir: "+gd+"\n"), 0o600); err != nil {
		t.Fatal(err)
	}
	if got := gitBranchOf(wt); got != "feature" {
		t.Errorf("branch in a worktree: %q", got)
	}
}

// Sessions waiting for the person come first, and the heading counts the
// background service apart from the sessions.
func TestAgentsListPutsWaitingSessionsFirstAndCountsTheServiceApart(t *testing.T) {
	views := []agentView{
		{agentObs: agentObs{PID: 1, Signature: "claude-code"}, Role: "service"},
		{agentObs: agentObs{PID: 2, Kind: kindAgent, Signature: "claude-code"}, Role: "session",
			Self: &agentSelf{Name: "idle-one", Status: "idle"}},
		{agentObs: agentObs{PID: 3, Kind: kindAgent, Signature: "claude-code"}, Role: "session",
			Self: &agentSelf{Name: "waits", Title: "Rename the invoices", Status: "waiting", WaitingFor: "permission prompt"}},
	}
	var b bytes.Buffer
	printAgents(&b, views, time.Now())
	out := b.String()
	if !strings.HasPrefix(out, "Claude Code: 2 sessions (1 waiting for you), its background service\n") {
		t.Errorf("heading:\n%s", out)
	}
	if strings.Index(out, "waits") > strings.Index(out, "idle-one") {
		t.Errorf("the waiting session is not first:\n%s", out)
	}
	if !strings.Contains(out, "waiting for you: permission prompt") {
		t.Errorf("what it waits for is not said:\n%s", out)
	}
}

// Stop takes a session's name, and the owner is asked about the session, not
// a bare pid.
func TestStopNamesTheSessionItAsksAbout(t *testing.T) {
	stubProcIdentity(t, "5551")
	home := fakeClaudeHome(t, 4242, "5551", fixtureTranscript)
	prevH, prevTree, prevU := homeForUserFn, processTree, uidForUserFn
	t.Cleanup(func() { homeForUserFn, processTree, uidForUserFn = prevH, prevTree, prevU })
	homeForUserFn = func(string) string { return home }
	uidForUserFn = func(string) (int, bool) { return os.Getuid(), true }
	processTree = func() map[int]int { return nil }
	observed := map[int]agentObs{4242: {PID: 4242, Kind: kindAgent, Signature: "claude-code", User: "u"}}
	pid, v, err := resolveStopTarget("shop-a1", observed)
	if err != nil || pid != 4242 {
		t.Fatalf("by name: %d %v", pid, err)
	}
	if _, _, err := resolveStopTarget("no-such", observed); err == nil {
		t.Error("an unknown session name resolved")
	}
	d := map[string]any{"kind": localStopKind, "pid": "4242", "signature": "claude-code",
		"agent": "Claude Code", "session": v.Self.Name, "title": v.Self.Title, "folder": "/work/shop"}
	got := describeRequest(stepupRequest{Details: d})
	want := `Stop Claude Code session shop-a1 "Add an index to the orders table" in /work/shop (pid 4242) on this machine, and every process it started.`
	if got != want {
		t.Errorf("the owner reads\n%s\nwant\n%s", got, want)
	}
}

// A program that rewrote its command line as one string is still named by
// its program, not by whatever follows the last slash in the whole line, and
// repeats fold into a count.
func TestARetitledCommandLineIsSplitAndRepeatsFold(t *testing.T) {
	if got := splitRetitled([]string{"go test ./..."}); len(got) != 3 || got[0] != "go" {
		t.Errorf("split %q", got)
	}
	if got := splitRetitled([]string{"/usr/bin/go", "test", "./..."}); len(got) != 3 || got[0] != "/usr/bin/go" {
		t.Errorf("an ordinary argv was changed: %q", got)
	}
	if got := countedNames([]string{"chrome", "mcp-files", "chrome", "chrome"}); len(got) != 2 || got[0] != "chrome ×3" {
		t.Errorf("folded %q", got)
	}
}

// The daemon may read as the machine's administrator: a session file that is
// a link, or that another account owns, is not read.
func TestASessionFileThatIsALinkOrNotTheAgentsOwnIsNotRead(t *testing.T) {
	if runtime.GOOS == "windows" {
		t.Skip("accounts are not numbers and links need privilege on Windows")
	}
	stubProcIdentity(t, "5551")
	home := fakeClaudeHome(t, 4242, "5551", fixtureTranscript)
	if s := claudeCodeSelf(4242, home, os.Getuid()+1); s != nil {
		t.Errorf("a record owned by another account was read: %+v", *s)
	}
	rec := filepath.Join(home, ".claude", "sessions", "4242.json")
	elsewhere := filepath.Join(t.TempDir(), "other.json")
	if err := os.Rename(rec, elsewhere); err != nil {
		t.Fatal(err)
	}
	if err := os.Symlink(elsewhere, rec); err != nil {
		t.Fatal(err)
	}
	if s := claudeCodeSelf(4242, home, os.Getuid()); s != nil {
		t.Errorf("a record reached through a link was read: %+v", *s)
	}
}