package agent

import (
	"encoding/json"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"

	"reasonix/internal/provider"
)

const legacyEventLog = `{"type":"model.turn.started","id":1,"ts":"t","turn":0,"model":"deepseek"}
{"type":"user.message","id":2,"ts":"t","turn":0,"text":"list the files"}
{"type":"model.delta","id":3,"ts":"t","turn":0,"channel":"content","text":"sure"}
{"type":"model.final","id":4,"ts":"t","turn":0,"content":"On it.","toolCalls":[{"id":"call_1","type":"function","function":{"name":"ls","arguments":"{\"path\":\".\"}"}}],"usage":{},"costUsd":0}
{"type":"tool.result","id":5,"ts":"t","turn":0,"callId":"call_1","ok":true,"output":"a.go\nb.go","durationMs":3}
{"type":"model.final","id":6,"ts":"t","turn":0,"content":"There are two files.","toolCalls":[],"usage":{},"costUsd":0}
`

func TestMigrateLegacySessionsReconstructsConversation(t *testing.T) {
	src := t.TempDir()
	dest := t.TempDir()
	if err := os.WriteFile(filepath.Join(src, "chat-1.events.jsonl"), []byte(legacyEventLog), 0o644); err != nil {
		t.Fatal(err)
	}

	n, err := MigrateLegacySessions(src, dest, nil)
	if err != nil {
		t.Fatalf("migrate: %v", err)
	}
	if n != 1 {
		t.Fatalf("imported %d sessions, want 1", n)
	}

	loaded, err := LoadSession(filepath.Join(dest, "chat-1.jsonl"))
	if err != nil {
		t.Fatalf("reload migrated session: %v", err)
	}
	got := loaded.Messages
	if len(got) != 4 {
		t.Fatalf("message count = %d, want 4 (user, assistant+toolcall, tool, assistant):\n%+v", len(got), got)
	}
	if got[0].Role != provider.RoleUser || got[0].Content != "list the files" {
		t.Errorf("msg0 = %+v, want user 'list the files'", got[0])
	}
	if got[1].Role != provider.RoleAssistant || len(got[1].ToolCalls) != 1 ||
		got[1].ToolCalls[0].ID != "call_1" || got[1].ToolCalls[0].Name != "ls" {
		t.Errorf("msg1 = %+v, want assistant with ls tool call call_1", got[1])
	}
	if got[2].Role != provider.RoleTool || got[2].ToolCallID != "call_1" ||
		got[2].Name != "ls" || got[2].Content != "a.go\nb.go" {
		t.Errorf("msg2 = %+v, want tool result for call_1 named ls", got[2])
	}
	if got[3].Role != provider.RoleAssistant || got[3].Content != "There are two files." {
		t.Errorf("msg3 = %+v, want final assistant text", got[3])
	}
}

func TestMigrateLegacySessionsReplaysNativeEventLog(t *testing.T) {
	src := t.TempDir()
	dest := t.TempDir()
	path := filepath.Join(src, "native.jsonl")
	base := NewSession("sys")
	base.Add(provider.Message{Role: provider.RoleUser, Content: "checkpoint prompt"})
	if err := base.Save(path); err != nil {
		t.Fatalf("Save base: %v", err)
	}
	loaded, err := LoadSession(path)
	if err != nil {
		t.Fatalf("LoadSession base: %v", err)
	}
	loaded.Add(provider.Message{Role: provider.RoleAssistant, Content: "event tail"})
	if err := loaded.SaveSnapshot(path); err != nil {
		t.Fatalf("SaveSnapshot tail: %v", err)
	}

	n, err := MigrateLegacySessions(src, dest, nil)
	if err != nil {
		t.Fatalf("migrate: %v", err)
	}
	if n != 1 {
		t.Fatalf("imported %d sessions, want 1", n)
	}
	migrated, err := LoadSession(filepath.Join(dest, "native.jsonl"))
	if err != nil {
		t.Fatalf("LoadSession migrated: %v", err)
	}
	if got := migrated.Messages[len(migrated.Messages)-1].Content; got != "event tail" {
		t.Fatalf("migrated tail = %q, want event tail", got)
	}
}

func TestMigrateLegacySessionsBackfillsAlongsideExisting(t *testing.T) {
	src := t.TempDir()
	dest := t.TempDir()
	os.WriteFile(filepath.Join(src, "chat-1.events.jsonl"), []byte(legacyEventLog), 0o644)
	os.WriteFile(filepath.Join(dest, "existing.jsonl"), []byte(`{"role":"user","content":"hi"}`+"\n"), 0o644)

	n, err := MigrateLegacySessions(src, dest, nil)
	if err != nil {
		t.Fatalf("migrate: %v", err)
	}
	if n != 1 {
		t.Errorf("should back-fill the legacy session even when dest has others, imported %d", n)
	}
	if _, err := os.Stat(filepath.Join(dest, "chat-1.jsonl")); err != nil {
		t.Errorf("legacy session should have been imported: %v", err)
	}
	if _, err := os.Stat(filepath.Join(dest, "existing.jsonl")); err != nil {
		t.Errorf("pre-existing v1+ session must be left intact: %v", err)
	}
}

func TestMigrateLegacySessionsRunsOnce(t *testing.T) {
	src := t.TempDir()
	dest := t.TempDir()
	os.WriteFile(filepath.Join(src, "chat-1.events.jsonl"), []byte(legacyEventLog), 0o644)

	if n, err := MigrateLegacySessions(src, dest, nil); err != nil || n != 1 {
		t.Fatalf("first run: n=%d err=%v, want 1", n, err)
	}
	// User deletes the imported session, then a second launch happens.
	if err := os.Remove(filepath.Join(dest, "chat-1.jsonl")); err != nil {
		t.Fatal(err)
	}
	if n, err := MigrateLegacySessions(src, dest, nil); err != nil || n != 0 {
		t.Fatalf("second run must be a no-op (marker present): n=%d err=%v", n, err)
	}
	if _, err := os.Stat(filepath.Join(dest, "chat-1.jsonl")); !os.IsNotExist(err) {
		t.Errorf("a deleted import must not reappear after the one-time migration")
	}
	if _, err := os.Stat(filepath.Join(dest, legacyEventsHomeImportMarker)); err != nil {
		t.Errorf("source-specific import marker missing: %v", err)
	}
	if _, err := os.Stat(filepath.Join(dest, legacyImportMarker)); err != nil {
		t.Errorf("legacy compatibility import marker missing: %v", err)
	}
}

func TestMigrateLegacySessionsFromExplicitDirIgnoresDefaultMarkers(t *testing.T) {
	src := t.TempDir()
	dest := t.TempDir()
	if err := os.WriteFile(filepath.Join(src, "custom-install.jsonl"), []byte(legacyMessageLog), 0o644); err != nil {
		t.Fatal(err)
	}
	writeImportMarkers(dest, legacyRoutedHomeImportMarker, legacyJsonlPassMarker)

	if n, err := MigrateLegacySessions(src, dest, nil); err != nil || n != 0 {
		t.Fatalf("default migrate with markers: n=%d err=%v, want 0 nil", n, err)
	}
	n, err := MigrateLegacySessionsFromExplicitDir(src, dest, nil)
	if err != nil {
		t.Fatalf("explicit migrate: %v", err)
	}
	if n != 1 {
		t.Fatalf("explicit imported %d sessions, want 1", n)
	}
	if _, err := os.Stat(filepath.Join(dest, "custom-install.jsonl")); err != nil {
		t.Fatalf("explicit imported session missing: %v", err)
	}
	if n, err := MigrateLegacySessionsFromExplicitDir(src, dest, nil); err != nil || n != 0 {
		t.Fatalf("explicit migrate should be source-marker idempotent: n=%d err=%v", n, err)
	}
}

func TestMigrateLegacySessionsRoutedPassIgnoresFlatMarkers(t *testing.T) {
	src := t.TempDir()
	dest := t.TempDir()
	os.WriteFile(filepath.Join(src, "chat-1.events.jsonl"), []byte(legacyEventLog), 0o644)
	for _, m := range []string{legacyImportMarker, legacyEventsHomeImportMarker} {
		if err := os.WriteFile(filepath.Join(dest, m), nil, 0o644); err != nil {
			t.Fatal(err)
		}
	}

	// Flat markers must not block the routed pass — it has to run once for
	// existing upgraders to re-home sessions the flat import stranded (#3937).
	n, err := MigrateLegacySessions(src, dest, nil)
	if err != nil {
		t.Fatalf("migrate: %v", err)
	}
	if n != 1 {
		t.Fatalf("routed pass should run despite flat markers, got %d", n)
	}
	if n, err := MigrateLegacySessions(src, dest, nil); err != nil || n != 0 {
		t.Fatalf("routed marker must gate the second run: n=%d err=%v", n, err)
	}
}

func TestMigrateLegacySessionsSourceMarkersAreIndependent(t *testing.T) {
	src := t.TempDir()
	dest := t.TempDir()
	os.WriteFile(filepath.Join(src, "appdata-chat.events.jsonl"), []byte(legacyEventLog), 0o644)
	if err := os.MkdirAll(dest, 0o755); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(filepath.Join(dest, legacyImportMarker), nil, 0o644); err != nil {
		t.Fatal(err)
	}

	const appDataMarker = ".legacy-imported.v0-events-appdata"
	n, err := migrateLegacySessions(src, dest, appDataMarker, nil)
	if err != nil {
		t.Fatalf("migrate: %v", err)
	}
	if n != 1 {
		t.Fatalf("independent source marker should allow a new source import, got %d", n)
	}
	if _, err := os.Stat(filepath.Join(dest, "appdata-chat.jsonl")); err != nil {
		t.Errorf("new source session should have been imported: %v", err)
	}
	if _, err := os.Stat(filepath.Join(dest, appDataMarker)); err != nil {
		t.Errorf("new source marker missing: %v", err)
	}
}

func TestMigrateLegacyConfigSourceDoesNotBlockHomeSource(t *testing.T) {
	configSrc := t.TempDir()
	homeSrc := t.TempDir()
	dest := t.TempDir()
	os.WriteFile(filepath.Join(homeSrc, "home-chat.events.jsonl"), []byte(legacyEventLog), 0o644)

	if n, err := MigrateLegacySessionsFromConfigDir(configSrc, dest, nil); err != nil || n != 0 {
		t.Fatalf("config source without events: n=%d err=%v, want 0 nil", n, err)
	}
	if _, err := os.Stat(filepath.Join(dest, legacyRoutedConfigImportMarker)); err != nil {
		t.Fatalf("config source marker missing: %v", err)
	}

	if n, err := MigrateLegacySessions(homeSrc, dest, nil); err != nil || n != 1 {
		t.Fatalf("home source after config source: n=%d err=%v, want 1 nil", n, err)
	}
	if _, err := os.Stat(filepath.Join(dest, "home-chat.jsonl")); err != nil {
		t.Fatalf("home source should still import after config source marker: %v", err)
	}
}

func TestMigrateLegacySessionsSkipsAlreadyImported(t *testing.T) {
	src := t.TempDir()
	dest := t.TempDir()
	os.WriteFile(filepath.Join(src, "chat-1.events.jsonl"), []byte(legacyEventLog), 0o644)
	os.WriteFile(filepath.Join(dest, "chat-1.jsonl"), []byte(`{"role":"user","content":"edited"}`+"\n"), 0o644)

	n, err := MigrateLegacySessions(src, dest, nil)
	if err != nil {
		t.Fatalf("migrate: %v", err)
	}
	if n != 0 {
		t.Errorf("a same-named existing session must not be overwritten, imported %d", n)
	}
	loaded, err := LoadSession(filepath.Join(dest, "chat-1.jsonl"))
	if err != nil {
		t.Fatal(err)
	}
	if len(loaded.Messages) != 1 || loaded.Messages[0].Content != "edited" {
		t.Errorf("existing same-named session was clobbered: %+v", loaded.Messages)
	}
}

func TestMigrateLegacySessionsNoSrcIsNoop(t *testing.T) {
	n, err := MigrateLegacySessions(filepath.Join(t.TempDir(), "nope"), t.TempDir(), nil)
	if err != nil || n != 0 {
		t.Errorf("missing legacy session dir should be a silent no-op, got n=%d err=%v", n, err)
	}
}

func writeLegacyMeta(t *testing.T, srcDir, base, workspace, summary string) {
	t.Helper()
	b, err := json.Marshal(map[string]string{"workspace": workspace, "summary": summary})
	if err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(filepath.Join(srcDir, base+".meta.json"), b, 0o644); err != nil {
		t.Fatal(err)
	}
}

const v1MessageSession = `{"role":"user","content":"recovered after downgrade"}
{"role":"assistant","content":"ok"}
`

// stampMigrated marks src/dest as already through the one-time passes, with the
// routing watermark set to `at`. It mirrors what a completed migration leaves
// behind so the re-home pass (not the full passes) handles the next run.
func stampMigrated(t *testing.T, dest string, at time.Time) {
	t.Helper()
	for _, m := range []string{legacyRoutedHomeImportMarker, legacyJsonlPassMarker, legacyImportMarker} {
		path := filepath.Join(dest, m)
		if err := os.WriteFile(path, nil, 0o644); err != nil {
			t.Fatal(err)
		}
		if err := os.Chtimes(path, at, at); err != nil {
			t.Fatal(err)
		}
	}
}

// TestRehomeStrandedSessionAfterDowngrade reproduces #4666: after the one-time
// routing pass completes, a downgrade-to-old-build writes a project session into
// the flat dir. The next upgrade must re-home it into its workspace dir even
// though the routing marker is present.
func TestRehomeStrandedSessionAfterDowngrade(t *testing.T) {
	src := t.TempDir()
	dest := t.TempDir()
	workspace := t.TempDir()
	projectDest := t.TempDir()
	projectDir := func(root string) string {
		if root == workspace {
			return projectDest
		}
		return ""
	}

	// Migration already ran a day ago.
	past := time.Now().Add(-24 * time.Hour)
	stampMigrated(t, dest, past)

	// The downgraded build then wrote a project session into the flat dir.
	base := "20260101-000000.000000000-deepseek"
	sessionPath := filepath.Join(src, base+".jsonl")
	if err := os.WriteFile(sessionPath, []byte(v1MessageSession), 0o644); err != nil {
		t.Fatal(err)
	}
	if err := SaveBranchMeta(sessionPath, BranchMeta{Scope: "project", WorkspaceRoot: workspace, TopicTitle: "downgrade work"}); err != nil {
		t.Fatal(err)
	}
	ref := "sa_20260101_000000_000000000_aabbccddeeff"
	writeMigratedSubagentArtifact(t, src, ref, base)

	n, err := MigrateLegacySessions(src, dest, projectDir)
	if err != nil {
		t.Fatalf("migrate: %v", err)
	}
	if n != 1 {
		t.Fatalf("stranded project session should be re-homed, imported %d", n)
	}
	if _, err := os.Stat(filepath.Join(projectDest, base+".jsonl")); err != nil {
		t.Errorf("session should land in the project dir: %v", err)
	}
	// The branch sidecar must follow so the sidebar keeps title/topic.
	if _, err := os.Stat(BranchMetaPath(filepath.Join(projectDest, base+".jsonl"))); err != nil {
		t.Errorf("branch meta sidecar should be copied alongside: %v", err)
	}
	if _, err := os.Stat(filepath.Join(projectDest, "subagents", ref+".jsonl")); err != nil {
		t.Errorf("subagent transcript should be copied alongside: %v", err)
	}
	if _, err := os.Stat(filepath.Join(projectDest, "subagents", ref+".meta.json")); err != nil {
		t.Errorf("subagent metadata should be copied alongside: %v", err)
	}
	// Source is never modified.
	if _, err := os.Stat(sessionPath); err != nil {
		t.Errorf("source session must be left intact: %v", err)
	}
}

func TestJsonlPassRoutesBranchMetaWhenJsonlMarkerMissing(t *testing.T) {
	src := t.TempDir()
	dest := t.TempDir()
	workspace := t.TempDir()
	projectDest := t.TempDir()
	projectDir := func(root string) string {
		if root == workspace {
			return projectDest
		}
		return ""
	}

	past := time.Now().Add(-24 * time.Hour)
	routedMarker := filepath.Join(dest, legacyRoutedHomeImportMarker)
	if err := os.WriteFile(routedMarker, nil, 0o644); err != nil {
		t.Fatal(err)
	}
	if err := os.Chtimes(routedMarker, past, past); err != nil {
		t.Fatal(err)
	}

	base := "20260101-003000.000000000-deepseek"
	sessionPath := filepath.Join(src, base+".jsonl")
	if err := os.WriteFile(sessionPath, []byte(v1MessageSession), 0o644); err != nil {
		t.Fatal(err)
	}
	if err := SaveBranchMeta(sessionPath, BranchMeta{Scope: "project", WorkspaceRoot: workspace, TopicTitle: "half-upgraded"}); err != nil {
		t.Fatal(err)
	}
	ref := "sa_20260101_003000_000000000_aabbccddeeff"
	writeMigratedSubagentArtifact(t, src, ref, base)

	n, err := MigrateLegacySessions(src, dest, projectDir)
	if err != nil {
		t.Fatalf("migrate: %v", err)
	}
	if n != 1 {
		t.Fatalf("branch-meta jsonl session should be imported once, got %d", n)
	}
	if _, err := os.Stat(filepath.Join(projectDest, base+".jsonl")); err != nil {
		t.Fatalf("session should be routed to the project dir while the jsonl marker is missing: %v", err)
	}
	if _, err := os.Stat(filepath.Join(dest, base+".jsonl")); !os.IsNotExist(err) {
		t.Fatalf("project session must not be copied into the global dir: %v", err)
	}
	if _, err := os.Stat(BranchMetaPath(filepath.Join(projectDest, base+".jsonl"))); err != nil {
		t.Fatalf("branch meta sidecar should be copied alongside: %v", err)
	}
	if _, err := os.Stat(filepath.Join(projectDest, "subagents", ref+".jsonl")); err != nil {
		t.Fatalf("subagent transcript should be copied alongside: %v", err)
	}
	if _, err := os.Stat(filepath.Join(projectDest, "subagents", ref+".meta.json")); err != nil {
		t.Fatalf("subagent metadata should be copied alongside: %v", err)
	}
	if n, err := MigrateLegacySessions(src, dest, projectDir); err != nil || n != 0 {
		t.Fatalf("second run should be a no-op: n=%d err=%v", n, err)
	}
}

// TestRehomeLeavesGlobalSessionsAlone guards the main risk: the flat dir is also
// where CLI/global sessions live. A session with no project scope must stay put.
func TestRehomeLeavesGlobalSessionsAlone(t *testing.T) {
	src := t.TempDir()
	dest := t.TempDir()
	projectDir := func(string) string { return t.TempDir() }

	stampMigrated(t, dest, time.Now().Add(-24*time.Hour))

	// A global session (no branch meta, no workspace) written post-migration.
	base := "20260101-010000.000000000-deepseek"
	if err := os.WriteFile(filepath.Join(src, base+".jsonl"), []byte(v1MessageSession), 0o644); err != nil {
		t.Fatal(err)
	}

	n, err := MigrateLegacySessions(src, dest, projectDir)
	if err != nil {
		t.Fatalf("migrate: %v", err)
	}
	if n != 0 {
		t.Errorf("a global flat session must not be re-homed, imported %d", n)
	}
}

// TestRehomeIgnoresSessionsOlderThanWatermark ensures a session the user
// imported and then deleted is not resurrected: only files newer than the
// migration watermark are candidates.
func TestRehomeIgnoresSessionsOlderThanWatermark(t *testing.T) {
	src := t.TempDir()
	dest := t.TempDir()
	workspace := t.TempDir()
	projectDest := t.TempDir()
	projectDir := func(root string) string {
		if root == workspace {
			return projectDest
		}
		return ""
	}

	now := time.Now()
	stampMigrated(t, dest, now) // watermark = now

	// A project session whose mtime predates the watermark (it was already seen
	// by the original pass and the user deleted the import).
	base := "20250101-000000.000000000-deepseek"
	sessionPath := filepath.Join(src, base+".jsonl")
	if err := os.WriteFile(sessionPath, []byte(v1MessageSession), 0o644); err != nil {
		t.Fatal(err)
	}
	if err := SaveBranchMeta(sessionPath, BranchMeta{Scope: "project", WorkspaceRoot: workspace}); err != nil {
		t.Fatal(err)
	}
	old := now.Add(-48 * time.Hour)
	if err := os.Chtimes(sessionPath, old, old); err != nil {
		t.Fatal(err)
	}

	n, err := MigrateLegacySessions(src, dest, projectDir)
	if err != nil {
		t.Fatalf("migrate: %v", err)
	}
	if n != 0 {
		t.Errorf("a pre-watermark session must not be revived, imported %d", n)
	}
}

// TestRehomeIsIdempotent verifies the second boot does not re-import: the
// destination check skips already-routed sessions and the watermark advances.
func TestRehomeIsIdempotent(t *testing.T) {
	src := t.TempDir()
	dest := t.TempDir()
	workspace := t.TempDir()
	projectDest := t.TempDir()
	projectDir := func(root string) string {
		if root == workspace {
			return projectDest
		}
		return ""
	}

	stampMigrated(t, dest, time.Now().Add(-24*time.Hour))
	base := "20260101-020000.000000000-deepseek"
	sessionPath := filepath.Join(src, base+".jsonl")
	os.WriteFile(sessionPath, []byte(v1MessageSession), 0o644)
	if err := SaveBranchMeta(sessionPath, BranchMeta{Scope: "project", WorkspaceRoot: workspace}); err != nil {
		t.Fatal(err)
	}

	if n, _ := MigrateLegacySessions(src, dest, projectDir); n != 1 {
		t.Fatalf("first run should re-home 1, got %d", n)
	}
	if n, err := MigrateLegacySessions(src, dest, projectDir); err != nil || n != 0 {
		t.Fatalf("second run must be a no-op: n=%d err=%v", n, err)
	}
}

func TestRehomeKeepsWatermarkWhenProjectCopyFails(t *testing.T) {
	src := t.TempDir()
	dest := t.TempDir()
	workspace := t.TempDir()
	blocker := filepath.Join(t.TempDir(), "not-a-directory")
	if err := os.WriteFile(blocker, []byte("block"), 0o644); err != nil {
		t.Fatal(err)
	}
	projectDir := func(root string) string {
		if root == workspace {
			return filepath.Join(blocker, "sessions")
		}
		return ""
	}

	past := time.Now().Add(-24 * time.Hour).Round(0)
	stampMigrated(t, dest, past)
	base := "20260101-023000.000000000-deepseek"
	sessionPath := filepath.Join(src, base+".jsonl")
	if err := os.WriteFile(sessionPath, []byte(v1MessageSession), 0o644); err != nil {
		t.Fatal(err)
	}
	if err := SaveBranchMeta(sessionPath, BranchMeta{Scope: "project", WorkspaceRoot: workspace}); err != nil {
		t.Fatal(err)
	}

	if n, err := MigrateLegacySessions(src, dest, projectDir); err != nil || n != 0 {
		t.Fatalf("copy failure should not import: n=%d err=%v", n, err)
	}
	info, err := os.Stat(filepath.Join(dest, legacyRoutedHomeImportMarker))
	if err != nil {
		t.Fatal(err)
	}
	if !info.ModTime().Equal(past) {
		t.Fatalf("watermark advanced after copy failure: got %s want %s", info.ModTime(), past)
	}
}

func TestRehomeKeepsWatermarkWhenSubagentCopyFails(t *testing.T) {
	src := t.TempDir()
	dest := t.TempDir()
	workspace := t.TempDir()
	projectDest := t.TempDir()
	projectDir := func(root string) string {
		if root == workspace {
			return projectDest
		}
		return ""
	}

	past := time.Now().Add(-24 * time.Hour).Round(0)
	stampMigrated(t, dest, past)
	base := "20260101-024000.000000000-deepseek"
	sessionPath := filepath.Join(src, base+".jsonl")
	if err := os.WriteFile(sessionPath, []byte(v1MessageSession), 0o644); err != nil {
		t.Fatal(err)
	}
	if err := SaveBranchMeta(sessionPath, BranchMeta{Scope: "project", WorkspaceRoot: workspace}); err != nil {
		t.Fatal(err)
	}
	writeMigratedSubagentArtifact(t, src, "sa_20260101_024000_000000000_aabbccddeeff", base)
	if err := os.MkdirAll(projectDest, 0o755); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(filepath.Join(projectDest, "subagents"), []byte("block"), 0o644); err != nil {
		t.Fatal(err)
	}

	if n, err := MigrateLegacySessions(src, dest, projectDir); err != nil || n != 1 {
		t.Fatalf("parent session should still import: n=%d err=%v", n, err)
	}
	info, err := os.Stat(filepath.Join(dest, legacyRoutedHomeImportMarker))
	if err != nil {
		t.Fatal(err)
	}
	if !info.ModTime().Equal(past) {
		t.Fatalf("watermark advanced after subagent copy failure: got %s want %s", info.ModTime(), past)
	}
}

func writeMigratedSubagentArtifact(t *testing.T, sessionDir, ref, parentSession string) {
	t.Helper()
	subagentDir := filepath.Join(sessionDir, "subagents")
	if err := os.MkdirAll(subagentDir, 0o755); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(filepath.Join(subagentDir, ref+".jsonl"), []byte(`{"role":"user","content":"sub"}`+"\n"), 0o644); err != nil {
		t.Fatal(err)
	}
	meta := SubagentMeta{
		Ref:           ref,
		Status:        SubagentCompleted,
		Kind:          "task",
		Name:          "task",
		ParentSession: parentSession,
	}
	data, err := json.Marshal(meta)
	if err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(filepath.Join(subagentDir, ref+".meta.json"), data, 0o644); err != nil {
		t.Fatal(err)
	}
}

func TestMigrateLegacySessionsRoutesByWorkspaceMeta(t *testing.T) {
	src := t.TempDir()
	global := t.TempDir()
	workspace := t.TempDir()
	projRoot := t.TempDir()
	router := func(ws string) string { return filepath.Join(projRoot, filepath.Base(ws), "sessions") }
	os.WriteFile(filepath.Join(src, "chat-1.events.jsonl"), []byte(legacyEventLog), 0o644)
	writeLegacyMeta(t, src, "chat-1", workspace, "fix the retry test")

	n, err := MigrateLegacySessions(src, global, router)
	if err != nil || n != 1 {
		t.Fatalf("migrate: n=%d err=%v, want 1 nil", n, err)
	}
	dest := filepath.Join(projRoot, filepath.Base(workspace), "sessions")
	if _, err := os.Stat(filepath.Join(dest, "chat-1.jsonl")); err != nil {
		t.Fatalf("session should land in the workspace dir: %v", err)
	}
	if _, err := os.Stat(filepath.Join(global, "chat-1.jsonl")); !os.IsNotExist(err) {
		t.Errorf("session must not also land in the global dir")
	}
	titles, err := os.ReadFile(filepath.Join(dest, ".titles.json"))
	if err != nil {
		t.Fatalf("titles file: %v", err)
	}
	m := map[string]string{}
	if err := json.Unmarshal(titles, &m); err != nil || m["chat-1.jsonl"] != "fix the retry test" {
		t.Errorf("title = %q (err=%v), want legacy summary", m["chat-1.jsonl"], err)
	}
}

func TestMigrateLegacySessionsDeadWorkspaceFallsBackToGlobal(t *testing.T) {
	src := t.TempDir()
	global := t.TempDir()
	projRoot := t.TempDir()
	router := func(ws string) string { return filepath.Join(projRoot, filepath.Base(ws), "sessions") }
	os.WriteFile(filepath.Join(src, "chat-1.events.jsonl"), []byte(legacyEventLog), 0o644)
	writeLegacyMeta(t, src, "chat-1", filepath.Join(src, "no-such-workspace"), "")

	n, err := MigrateLegacySessions(src, global, router)
	if err != nil || n != 1 {
		t.Fatalf("migrate: n=%d err=%v, want 1 nil", n, err)
	}
	if _, err := os.Stat(filepath.Join(global, "chat-1.jsonl")); err != nil {
		t.Errorf("session with a dead workspace should fall back to the global dir: %v", err)
	}
}

func TestMigrateLegacySessionsRehomesFlatImport(t *testing.T) {
	src := t.TempDir()
	global := t.TempDir()
	workspace := t.TempDir()
	projRoot := t.TempDir()
	router := func(ws string) string { return filepath.Join(projRoot, filepath.Base(ws), "sessions") }
	srcLog := filepath.Join(src, "chat-1.events.jsonl")
	os.WriteFile(srcLog, []byte(legacyEventLog), 0o644)
	writeLegacyMeta(t, src, "chat-1", workspace, "fix the retry test")

	// Simulate the old flat import: file in the global dir, mtime stamped from
	// the legacy event log.
	flat := filepath.Join(global, "chat-1.jsonl")
	os.WriteFile(flat, []byte(`{"role":"user","content":"flat-imported"}`+"\n"), 0o644)
	info, err := os.Stat(srcLog)
	if err != nil {
		t.Fatal(err)
	}
	if err := os.Chtimes(flat, info.ModTime(), info.ModTime()); err != nil {
		t.Fatal(err)
	}

	n, err := MigrateLegacySessions(src, global, router)
	if err != nil || n != 1 {
		t.Fatalf("migrate: n=%d err=%v, want 1 nil", n, err)
	}
	moved := filepath.Join(projRoot, filepath.Base(workspace), "sessions", "chat-1.jsonl")
	b, err := os.ReadFile(moved)
	if err != nil {
		t.Fatalf("re-homed session missing: %v", err)
	}
	if !strings.Contains(string(b), "flat-imported") {
		t.Errorf("re-home must move the existing import, not reconstruct: %s", b)
	}
	if _, err := os.Stat(flat); !os.IsNotExist(err) {
		t.Errorf("flat import should be moved out of the global dir")
	}
}

func TestMigrateLegacySessionsKeepsNativeSameNameSession(t *testing.T) {
	src := t.TempDir()
	global := t.TempDir()
	workspace := t.TempDir()
	projRoot := t.TempDir()
	router := func(ws string) string { return filepath.Join(projRoot, filepath.Base(ws), "sessions") }
	srcLog := filepath.Join(src, "chat-1.events.jsonl")
	os.WriteFile(srcLog, []byte(legacyEventLog), 0o644)
	old := time.Now().Add(-48 * time.Hour)
	if err := os.Chtimes(srcLog, old, old); err != nil {
		t.Fatal(err)
	}
	writeLegacyMeta(t, src, "chat-1", workspace, "")

	// A native v1+ session that happens to share the name: mtime won't match
	// the legacy log, so it must stay where it is.
	native := filepath.Join(global, "chat-1.jsonl")
	os.WriteFile(native, []byte(`{"role":"user","content":"native"}`+"\n"), 0o644)

	if _, err := MigrateLegacySessions(src, global, router); err != nil {
		t.Fatalf("migrate: %v", err)
	}
	b, err := os.ReadFile(native)
	if err != nil || !strings.Contains(string(b), "native") {
		t.Errorf("native global session must be left intact: err=%v body=%s", err, b)
	}
	if _, err := os.Stat(filepath.Join(projRoot, filepath.Base(workspace), "sessions", "chat-1.jsonl")); err != nil {
		t.Errorf("legacy session should still be reconstructed into its workspace dir: %v", err)
	}
}

func TestMigrateLegacySessionsSkipsEmptyLog(t *testing.T) {
	src := t.TempDir()
	dest := t.TempDir()
	os.WriteFile(filepath.Join(src, "empty.events.jsonl"), []byte(`{"type":"model.turn.started","id":1,"ts":"t","turn":0}`+"\n"), 0o644)

	n, err := MigrateLegacySessions(src, dest, nil)
	if err != nil {
		t.Fatalf("migrate: %v", err)
	}
	if n != 0 {
		t.Errorf("a log with no user/assistant/tool messages should not produce a session, imported %d", n)
	}
}

const legacyMessageLog = `{"role":"user","content":"hello from v0.x"}
{"role":"assistant","content":"hi there","tool_calls":[{"id":"call_1","name":"read_file","arguments":"{\"path\":\"main.go\"}"}]}
{"role":"tool","tool_call_id":"call_1","name":"read_file","content":"package main"}
{"role":"assistant","content":"I found the file."}
`

func TestMigrateLegacySessionsImportsJsonlOnly(t *testing.T) {
	src := t.TempDir()
	dest := t.TempDir()
	os.WriteFile(filepath.Join(src, "acp-chat.jsonl"), []byte(legacyMessageLog), 0o644)
	writeLegacyMeta(t, src, "acp-chat", "", "ACP session about main.go")

	n, err := MigrateLegacySessions(src, dest, nil)
	if err != nil {
		t.Fatalf("migrate: %v", err)
	}
	if n != 1 {
		t.Fatalf("imported %d sessions, want 1 (jsonl-only)", n)
	}

	destPath := filepath.Join(dest, "acp-chat.jsonl")
	data, err := os.ReadFile(destPath)
	if err != nil {
		t.Fatalf("imported session missing: %v", err)
	}
	if !strings.Contains(string(data), `"hello from v0.x"`) {
		t.Errorf("imported content wrong:\n%s", data)
	}

	// Title from the meta sidecar should be stored.
	titles, err := os.ReadFile(filepath.Join(dest, ".titles.json"))
	if err != nil {
		t.Fatalf("titles file: %v", err)
	}
	m := map[string]string{}
	if err := json.Unmarshal(titles, &m); err != nil || m["acp-chat.jsonl"] != "ACP session about main.go" {
		t.Errorf("title = %q (err=%v), want ACP session about main.go", m["acp-chat.jsonl"], err)
	}

	// Marker must be stamped.
	if _, err := os.Stat(filepath.Join(dest, legacyJsonlPassMarker)); err != nil {
		t.Errorf("jsonl pass marker missing: %v", err)
	}
}

func TestMigrateLegacySessionsPrefersJsonlWhenNewer(t *testing.T) {
	src := t.TempDir()
	dest := t.TempDir()

	eventsPath := filepath.Join(src, "chat-1.events.jsonl")
	jsonlPath := filepath.Join(src, "chat-1.jsonl")

	// Write the event log first (older mtime).
	os.WriteFile(eventsPath, []byte(legacyEventLog), 0o644)
	time.Sleep(10 * time.Millisecond) // ensure mtime differs
	// Write the .jsonl second (newer mtime) — it should be preferred.
	os.WriteFile(jsonlPath, []byte(legacyMessageLog), 0o644)
	writeLegacyMeta(t, src, "chat-1", "", "newer jsonl wins")

	n, err := MigrateLegacySessions(src, dest, nil)
	if err != nil {
		t.Fatalf("migrate: %v", err)
	}
	if n != 1 {
		t.Fatalf("imported %d, want 1", n)
	}

	data, err := os.ReadFile(filepath.Join(dest, "chat-1.jsonl"))
	if err != nil {
		t.Fatal(err)
	}
	// The .jsonl content ("hello from v0.x") should win over the reconstructed
	// event log content ("list the files").
	if !strings.Contains(string(data), `"hello from v0.x"`) {
		t.Errorf("expected .jsonl content to be preferred:\n%s", data)
	}
}

func TestMigrateLegacySessionsFallsBackToEventsWhenJsonlOlder(t *testing.T) {
	src := t.TempDir()
	dest := t.TempDir()

	jsonlPath := filepath.Join(src, "chat-1.jsonl")
	eventsPath := filepath.Join(src, "chat-1.events.jsonl")

	// Write the .jsonl first (older mtime).
	os.WriteFile(jsonlPath, []byte(legacyMessageLog), 0o644)
	time.Sleep(10 * time.Millisecond)
	// Write the events log second (newer mtime) — events should be reconstructed.
	os.WriteFile(eventsPath, []byte(legacyEventLog), 0o644)
	writeLegacyMeta(t, src, "chat-1", "", "events are newer")

	n, err := MigrateLegacySessions(src, dest, nil)
	if err != nil {
		t.Fatalf("migrate: %v", err)
	}
	if n != 1 {
		t.Fatalf("imported %d, want 1", n)
	}

	data, err := os.ReadFile(filepath.Join(dest, "chat-1.jsonl"))
	if err != nil {
		t.Fatal(err)
	}
	// The reconstructed event-log content ("list the files") should win because
	// the events log has a newer mtime.
	if !strings.Contains(string(data), `"list the files"`) {
		t.Errorf("expected events content to be reconstructed:\n%s", data)
	}
}

func TestMigrateLegacySessionsImportsJsonlBakFallback(t *testing.T) {
	src := t.TempDir()
	dest := t.TempDir()

	// Only a .jsonl.bak — no .jsonl, no .events.jsonl. Should recover from bak.
	os.WriteFile(filepath.Join(src, "recovered.jsonl.bak"), []byte(legacyMessageLog), 0o644)
	writeLegacyMeta(t, src, "recovered", "", "recovered from bak")

	n, err := MigrateLegacySessions(src, dest, nil)
	if err != nil {
		t.Fatalf("migrate: %v", err)
	}
	if n != 1 {
		t.Fatalf("imported %d, want 1 (.bak recovery)", n)
	}

	data, err := os.ReadFile(filepath.Join(dest, "recovered.jsonl"))
	if err != nil {
		t.Fatalf("recovered session missing: %v", err)
	}
	if !strings.Contains(string(data), `"hello from v0.x"`) {
		t.Errorf("recovered content wrong:\n%s", data)
	}
}

func TestMigrateLegacySessionsSkipsBakWhenJsonlExists(t *testing.T) {
	src := t.TempDir()
	dest := t.TempDir()

	// Both .jsonl and .jsonl.bak exist — prefer .jsonl.
	os.WriteFile(filepath.Join(src, "chat.jsonl"), []byte(legacyMessageLog), 0o644)
	os.WriteFile(filepath.Join(src, "chat.jsonl.bak"), []byte(`{"role":"user","content":"stale backup"}`+"\n"), 0o644)
	writeLegacyMeta(t, src, "chat", "", "from jsonl not bak")

	n, err := MigrateLegacySessions(src, dest, nil)
	if err != nil {
		t.Fatalf("migrate: %v", err)
	}
	if n != 1 {
		t.Fatalf("imported %d, want 1", n)
	}

	data, err := os.ReadFile(filepath.Join(dest, "chat.jsonl"))
	if err != nil {
		t.Fatal(err)
	}
	if !strings.Contains(string(data), `"hello from v0.x"`) {
		t.Errorf("expected .jsonl content, not .bak:\n%s", data)
	}
}

func TestMigrateLegacySessionsSkipsNonMessageJsonl(t *testing.T) {
	src := t.TempDir()
	dest := t.TempDir()

	// A .jsonl file that is NOT in message format (starts with event-log "id").
	os.WriteFile(filepath.Join(src, "bad.jsonl"), []byte(`{"id":1,"type":"model.turn.started"}`+"\n"), 0o644)

	n, err := MigrateLegacySessions(src, dest, nil)
	if err != nil {
		t.Fatalf("migrate: %v", err)
	}
	if n != 0 {
		t.Errorf("non-message .jsonl should be skipped, imported %d", n)
	}
}

func TestMigrateLegacySessionsRecursesIntoSubdirectories(t *testing.T) {
	src := t.TempDir()
	global := t.TempDir()
	workspace := t.TempDir()
	projRoot := t.TempDir()
	router := func(ws string) string { return filepath.Join(projRoot, filepath.Base(ws), "sessions") }

	// Set up a project-scoped subdirectory with sessions.
	subDir := filepath.Join(src, "Users_Yuki_git_polytone-audio-engine")
	if err := os.MkdirAll(subDir, 0o755); err != nil {
		t.Fatal(err)
	}
	os.WriteFile(filepath.Join(subDir, "proj-chat.events.jsonl"), []byte(legacyEventLog), 0o644)
	writeLegacyMeta(t, subDir, "proj-chat", workspace, "project session")

	// Also add a subdirectory that has no session files — should be skipped.
	emptySub := filepath.Join(src, "empty-dir")
	os.MkdirAll(emptySub, 0o755)

	n, err := MigrateLegacySessions(src, global, router)
	if err != nil {
		t.Fatalf("migrate: %v", err)
	}
	if n != 1 {
		t.Fatalf("imported %d, want 1 (subdirectory session)", n)
	}

	// Should land in the project session dir, not global.
	projDest := filepath.Join(projRoot, filepath.Base(workspace), "sessions", "proj-chat.jsonl")
	if _, err := os.Stat(projDest); err != nil {
		t.Errorf("subdirectory session not in project dir %s: %v", projDest, err)
	}
	if _, err := os.Stat(filepath.Join(global, "proj-chat.jsonl")); !os.IsNotExist(err) {
		t.Errorf("subdirectory session should not land in global dir")
	}
}

func TestMigrateLegacySessionsJsonlPassIsIdempotent(t *testing.T) {
	src := t.TempDir()
	dest := t.TempDir()

	os.WriteFile(filepath.Join(src, "desktop-session.jsonl"), []byte(legacyMessageLog), 0o644)

	// First run imports it.
	n, err := MigrateLegacySessions(src, dest, nil)
	if err != nil || n != 1 {
		t.Fatalf("first run: n=%d err=%v, want 1", n, err)
	}
	// Delete the imported session.
	os.Remove(filepath.Join(dest, "desktop-session.jsonl"))

	// Second run: jsonl pass marker exists, must not re-import.
	n, err = MigrateLegacySessions(src, dest, nil)
	if err != nil || n != 0 {
		t.Fatalf("second run must be no-op: n=%d err=%v", n, err)
	}
	if _, err := os.Stat(filepath.Join(dest, "desktop-session.jsonl")); !os.IsNotExist(err) {
		t.Errorf("deleted session must not reappear after jsonl pass marker")
	}
}

func TestMigrateLegacySessionsJsonlPassRunsForExistingUpgrader(t *testing.T) {
	src := t.TempDir()
	dest := t.TempDir()

	os.WriteFile(filepath.Join(src, "acp-chat.jsonl"), []byte(legacyMessageLog), 0o644)

	// Simulate an upgrader whose events pass already completed in a prior
	// version: the routed marker is stamped but the v3-jsonl marker is not.
	writeImportMarkers(dest, legacyRoutedHomeImportMarker)

	n, err := MigrateLegacySessions(src, dest, nil)
	if err != nil {
		t.Fatalf("migrate: %v", err)
	}
	if n != 1 {
		t.Fatalf("imported %d, want 1 (.jsonl-only must reach existing upgraders)", n)
	}
	if _, err := os.Stat(filepath.Join(dest, "acp-chat.jsonl")); err != nil {
		t.Errorf("jsonl-only session not imported for existing upgrader: %v", err)
	}
}

// legacyNestedFunctionLog uses the OpenAI-style nested-function tool-call format
// that the TS version wrote: name and arguments live under "function".
const legacyNestedFunctionLog = `{"role":"user","content":"read the file"}
{"role":"assistant","content":"","tool_calls":[{"id":"call_1","type":"function","function":{"name":"read_file","arguments":"{\"path\":\"main.go\"}"}}],"reasoning_content":"need to read it"}
{"role":"tool","tool_call_id":"call_1","name":"read_file","content":"package main\nfunc main() {}"}
{"role":"assistant","content":"Found the main function."}
`

func TestTransformAndCopyJsonlFlattensNestedToolCalls(t *testing.T) {
	src := t.TempDir()
	dest := t.TempDir()
	os.WriteFile(filepath.Join(src, "chat.jsonl"), []byte(legacyNestedFunctionLog), 0o644)
	writeLegacyMeta(t, src, "chat", "", "nested tool calls test")

	n, err := MigrateLegacySessions(src, dest, nil)
	if err != nil {
		t.Fatalf("migrate: %v", err)
	}
	if n != 1 {
		t.Fatalf("imported %d, want 1", n)
	}

	// Reload and verify the tool calls are flat, not nested.
	loaded, err := LoadSession(filepath.Join(dest, "chat.jsonl"))
	if err != nil {
		t.Fatal(err)
	}
	msgs := loaded.Messages
	if len(msgs) != 4 {
		t.Fatalf("message count = %d, want 4", len(msgs))
	}
	// Message 1: assistant with tool call.
	if len(msgs[1].ToolCalls) != 1 {
		t.Fatalf("assistant tool_calls = %d, want 1", len(msgs[1].ToolCalls))
	}
	tc := msgs[1].ToolCalls[0]
	if tc.ID != "call_1" {
		t.Errorf("tool call id = %q, want call_1", tc.ID)
	}
	if tc.Name != "read_file" {
		t.Errorf("tool call name = %q, want read_file", tc.Name)
	}
	if tc.Arguments != `{"path":"main.go"}` {
		t.Errorf("tool call arguments = %q, want {\"path\":\"main.go\"}", tc.Arguments)
	}
	// Message 2: tool result.
	if msgs[2].Role != provider.RoleTool || msgs[2].ToolCallID != "call_1" || msgs[2].Name != "read_file" {
		t.Errorf("tool result = %+v, want tool result for call_1", msgs[2])
	}
	// Message 3: final assistant text.
	if msgs[3].Content != "Found the main function." {
		t.Errorf("final content = %q", msgs[3].Content)
	}
}