package parser

import (
	"context"
	"database/sql"
	"os"
	"path/filepath"
	"testing"
	"time"

	_ "github.com/mattn/go-sqlite3"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

const zcodeTestSchema = `
	CREATE TABLE session (
		id TEXT PRIMARY KEY NOT NULL,
		project_id TEXT,
		workspace_id TEXT,
		directory TEXT,
		title TEXT,
		time_created INTEGER,
		time_updated INTEGER
	);
	CREATE TABLE model_usage (
		session_id TEXT NOT NULL,
		turn_id TEXT,
		provider_id TEXT,
		model_id TEXT,
		status TEXT,
		input_tokens INTEGER,
		output_tokens INTEGER,
		reasoning_tokens INTEGER,
		cache_creation_input_tokens INTEGER,
		cache_read_input_tokens INTEGER,
		computed_total_tokens INTEGER,
		started_at INTEGER,
		completed_at INTEGER,
		duration_ms INTEGER,
		tool_call_count INTEGER
	);
	CREATE TABLE message (
		id TEXT PRIMARY KEY NOT NULL,
		session_id TEXT NOT NULL,
		time_created TEXT,
		data TEXT
	);
	CREATE TABLE part (
		id TEXT PRIMARY KEY NOT NULL,
		message_id TEXT NOT NULL,
		session_id TEXT NOT NULL,
		time_created TEXT,
		data TEXT
	);
`

type zcodeTestFixture struct {
	Root     string
	CLIRoot  string
	DBDir    string
	DBPath   string
	database *sql.DB
}

func newZCodeTestFixture(t *testing.T) *zcodeTestFixture {
	t.Helper()
	root := t.TempDir()
	cliRoot := filepath.Join(root, ".zcode", "cli")
	dbDir := filepath.Join(cliRoot, "db")
	require.NoError(t, os.MkdirAll(dbDir, 0o755))
	dbPath := filepath.Join(dbDir, zcodeDBName)

	database, err := sql.Open("sqlite3", dbPath)
	require.NoError(t, err)
	t.Cleanup(func() { _ = database.Close() })
	_, err = database.Exec(zcodeTestSchema)
	require.NoError(t, err)

	return &zcodeTestFixture{
		Root:     root,
		CLIRoot:  cliRoot,
		DBDir:    dbDir,
		DBPath:   dbPath,
		database: database,
	}
}

func (f *zcodeTestFixture) insertSession(
	t *testing.T,
	id, directory, title string,
	createdAt, updatedAt any,
	projectID, workspaceID string,
) {
	t.Helper()
	_, err := f.database.Exec(`
		INSERT INTO session (
			id, project_id, workspace_id, directory, title,
			time_created, time_updated
		) VALUES (?, ?, ?, ?, ?, ?, ?)
	`, id, nullableZCodeString(projectID), nullableZCodeString(workspaceID), directory, title, createdAt, updatedAt)
	require.NoError(t, err)
}

func (f *zcodeTestFixture) insertUsage(
	t *testing.T,
	sessionID string,
	turnID string,
	providerID string,
	modelID, status string,
	inputTokens, outputTokens, reasoningTokens,
	cacheCreationTokens, cacheReadTokens, computedTotalTokens int64,
	startedAt, completedAt string,
	durationMS, toolCallCount int64,
) {
	t.Helper()
	_, err := f.database.Exec(`
		INSERT INTO model_usage (
			session_id, turn_id, provider_id, model_id, status,
			input_tokens, output_tokens, reasoning_tokens,
			cache_creation_input_tokens, cache_read_input_tokens,
			computed_total_tokens, started_at, completed_at,
			duration_ms, tool_call_count
		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
	`, sessionID, nullableZCodeString(turnID), nullableZCodeString(providerID), modelID, status,
		inputTokens, outputTokens, reasoningTokens,
		cacheCreationTokens, cacheReadTokens, computedTotalTokens,
		startedAt, completedAt, durationMS, toolCallCount)
	require.NoError(t, err)
}

func (f *zcodeTestFixture) insertMessage(
	t *testing.T,
	id, sessionID string,
	createdAt any,
	data string,
) {
	t.Helper()
	_, err := f.database.Exec(`
		INSERT INTO message (
			id, session_id, time_created, data
		) VALUES (?, ?, ?, ?)
	`, id, sessionID, createdAt, data)
	require.NoError(t, err)
}

func (f *zcodeTestFixture) insertPart(
	t *testing.T,
	id, messageID, sessionID string,
	data string,
) {
	t.Helper()
	f.insertPartAt(t, id, messageID, sessionID, nil, data)
}

func (f *zcodeTestFixture) insertPartAt(
	t *testing.T,
	id, messageID, sessionID string,
	createdAt any,
	data string,
) {
	t.Helper()
	_, err := f.database.Exec(`
		INSERT INTO part (
			id, message_id, session_id, time_created, data
		) VALUES (?, ?, ?, ?, ?)
	`, id, messageID, sessionID, createdAt, data)
	require.NoError(t, err)
}

func TestZCodeProviderCapabilities(t *testing.T) {
	caps := zcodeProviderCapabilities()
	assert.Equal(t, CapabilitySupported, caps.Content.FirstMessage)
	assert.Equal(t, CapabilitySupported, caps.Content.SessionName)
	assert.Equal(t, CapabilitySupported, caps.Content.Cwd)
	assert.Equal(t, CapabilitySupported, caps.Content.Thinking)
	assert.Equal(t, CapabilitySupported, caps.Content.ToolCalls)
	assert.Equal(t, CapabilitySupported, caps.Content.ToolResults)
	assert.Equal(t, CapabilitySupported, caps.Content.AggregateUsageEvents)
	assert.Equal(t, CapabilitySupported, caps.Content.Model)
}

func TestZCodeParsesReportedIntegerTimestamps(t *testing.T) {
	fixture := newZCodeTestFixture(t)
	fixture.insertSession(
		t,
		"session-ms",
		"/Users/alice/code/ms-app",
		"Integer timestamps",
		int64(1783352401000),
		int64(1783352700000),
		"",
		"",
	)
	oldDBMtime := time.Date(2026, 7, 6, 13, 0, 0, 0, time.UTC)
	require.NoError(t, os.Chtimes(fixture.DBPath, oldDBMtime, oldDBMtime))

	provider, ok := NewProvider(AgentZCode, ProviderConfig{
		Roots:   []string{fixture.CLIRoot},
		Machine: "devbox",
	})
	require.True(t, ok)

	sources, err := provider.Discover(context.Background())
	require.NoError(t, err)
	require.Len(t, sources, 1)

	outcome, err := provider.Parse(context.Background(), ParseRequest{
		Source:  sources[0],
		Machine: "devbox",
	})
	require.NoError(t, err)
	require.Len(t, outcome.Results, 1)
	assert.Equal(t, int64(1783352401000000000), outcome.Results[0].Result.Session.StartedAt.UnixNano())
	assert.Equal(t, int64(1783352700000000000), outcome.Results[0].Result.Session.EndedAt.UnixNano())
	assert.Equal(t, int64(1783352700000000000), outcome.Results[0].Result.Session.File.Mtime)
}

func TestZCodeProviderSourceMethodsAndParse(t *testing.T) {
	fixture := newZCodeTestFixture(t)
	fixture.insertSession(
		t,
		"session-001",
		"/Users/alice/code/acme-app",
		"Acme session",
		"2026-07-06T13:00:01Z",
		"2026-07-06T13:05:00Z",
		"project-7",
		"workspace-19",
	)
	fixture.insertUsage(
		t,
		"session-001",
		"1",
		"builtin:bigmodel-coding-plan",
		"claude-sonnet-4-6",
		"done",
		1000, 200, 40, 50, 25, 1315,
		"2026-07-06T13:00:02Z",
		"2026-07-06T13:00:03Z",
		1000,
		2,
	)
	fixture.insertUsage(
		t,
		"session-001",
		"2",
		"builtin:bigmodel-coding-plan",
		"claude-sonnet-4-6",
		"done",
		800, 75, 5, 10, 0, 890,
		"2026-07-06T13:04:00Z",
		"2026-07-06T13:05:00Z",
		600,
		0,
	)
	fixture.insertMessage(
		t,
		"msg-1",
		"session-001",
		"2026-07-06T13:00:01Z",
		`{"role":"user"}`,
	)
	fixture.insertPart(
		t,
		"part-1",
		"msg-1",
		"session-001",
		`{"type":"text","text":"Inspect the login flow."}`,
	)
	fixture.insertMessage(
		t,
		"msg-2",
		"session-001",
		"2026-07-06T13:00:02Z",
		`{"role":"assistant","model":{"modelID":"claude-sonnet-4-6"}}`,
	)
	fixture.insertPartAt(
		t,
		"part-z",
		"msg-2",
		"session-001",
		"2026-07-06T13:00:02Z",
		`{"type":"thinking","thinking":"I should read the auth code first."}`,
	)
	fixture.insertPartAt(
		t,
		"part-a",
		"msg-2",
		"session-001",
		"2026-07-06T13:00:03Z",
		`{"type":"text","text":"I'll inspect the auth code first."}`,
	)
	fixture.insertPartAt(
		t,
		"part-4",
		"msg-2",
		"session-001",
		"2026-07-06T13:00:04Z",
		`{"type":"tool_use","id":"call-1","name":"Read","input":{"file_path":"auth.go"}}`,
	)
	fixture.insertMessage(
		t,
		"msg-3",
		"session-001",
		"2026-07-06T13:00:03Z",
		`{"role":"user"}`,
	)
	fixture.insertPart(
		t,
		"part-5",
		"msg-3",
		"session-001",
		`{"type":"tool_result","tool_use_id":"call-1","content":"package auth"}`,
	)

	provider, ok := NewProvider(AgentZCode, ProviderConfig{
		Roots: []string{
			fixture.CLIRoot,
			fixture.DBDir,
		},
		Machine: "devbox",
	})
	require.True(t, ok)

	plan, err := provider.WatchPlan(context.Background())
	require.NoError(t, err)
	require.Len(t, plan.Roots, 1)
	assert.Equal(t, fixture.DBDir, plan.Roots[0].Path)
	assert.Contains(t, plan.Roots[0].IncludeGlobs, zcodeDBName)
	assert.Contains(t, plan.Roots[0].IncludeGlobs, zcodeDBName+"-*")

	sources, err := provider.Discover(context.Background())
	require.NoError(t, err)
	require.Len(t, sources, 1)
	source := sources[0]
	assert.Equal(t, AgentZCode, source.Provider)
	assert.Equal(t, fixture.DBPath+"#session-001", source.DisplayPath)

	fingerprint, err := provider.Fingerprint(context.Background(), source)
	require.NoError(t, err)
	assert.Equal(t, fixture.DBPath+"#session-001", fingerprint.Key)
	assert.NotZero(t, fingerprint.MTimeNS)

	foundSource, found, err := provider.FindSource(context.Background(), FindSourceRequest{
		RawSessionID:  "session-001",
		FullSessionID: "zcode:session-001",
	})
	require.NoError(t, err)
	require.True(t, found)
	assert.Equal(t, source.DisplayPath, foundSource.DisplayPath)

	outcome, err := provider.Parse(context.Background(), ParseRequest{
		Source:      foundSource,
		Fingerprint: fingerprint,
		Machine:     "devbox",
	})
	require.NoError(t, err)
	require.True(t, outcome.ResultSetComplete)
	require.True(t, outcome.ForceReplace)
	require.Len(t, outcome.Results, 1)

	result := outcome.Results[0]
	sess := result.Result.Session
	assert.Equal(t, "zcode:session-001", sess.ID)
	assert.Equal(t, AgentZCode, sess.Agent)
	assert.Equal(t, "devbox", sess.Machine)
	assert.Equal(t, "acme_app", sess.Project)
	assert.Equal(t, "/Users/alice/code/acme-app", sess.Cwd)
	assert.Equal(t, "Acme session", sess.SessionName)
	assert.Equal(t, "Acme session", sess.FirstMessage)
	assert.Equal(t, 3, sess.MessageCount)
	assert.Equal(t, 2, sess.UserMessageCount)
	assert.Equal(t, fixture.DBPath+"#session-001", sess.File.Path)
	assert.NotZero(t, sess.File.Size)
	require.Len(t, result.Result.Messages, 3)
	assert.Equal(t, RoleUser, result.Result.Messages[0].Role)
	assert.Equal(t, "Inspect the login flow.", result.Result.Messages[0].Content)
	assert.Equal(t, RoleAssistant, result.Result.Messages[1].Role)
	assert.True(t, result.Result.Messages[1].HasThinking)
	assert.True(t, result.Result.Messages[1].HasToolUse)
	assert.Equal(t, "claude-sonnet-4-6", result.Result.Messages[1].Model)
	assert.Equal(
		t,
		"[Thinking]\nI should read the auth code first.\n[/Thinking]\nI'll inspect the auth code first.",
		result.Result.Messages[1].Content,
	)
	require.Len(t, result.Result.Messages[1].ToolCalls, 1)
	assert.Equal(t, "Read", result.Result.Messages[1].ToolCalls[0].Category)
	assert.Equal(t, RoleUser, result.Result.Messages[2].Role)
	require.Len(t, result.Result.Messages[2].ToolResults, 1)
	assert.Equal(t, "package auth", DecodeContent(result.Result.Messages[2].ToolResults[0].ContentRaw))
	assert.Equal(t, 2, len(result.Result.UsageEvents))
	assert.Equal(t, 275, sess.TotalOutputTokens)
	assert.True(t, sess.HasTotalOutputTokens)
	assert.Equal(t, 1075, sess.PeakContextTokens)
	assert.True(t, sess.HasPeakContextTokens)

	first := result.Result.UsageEvents[0]
	second := result.Result.UsageEvents[1]
	require.NotNil(t, first.MessageOrdinal)
	require.NotNil(t, second.MessageOrdinal)
	assert.Equal(t, 1, *first.MessageOrdinal)
	assert.Equal(t, 2, *second.MessageOrdinal)
	assert.Equal(t, "zcode:session-001", first.SessionID)
	assert.Equal(t, "session", first.Source)
	assert.Equal(t, "claude-sonnet-4-6", first.Model)
	assert.Equal(t, 1000, first.InputTokens)
	assert.Equal(t, 200, first.OutputTokens)
	assert.Equal(t, 40, first.ReasoningTokens)
	assert.Equal(t, 50, first.CacheCreationInputTokens)
	assert.Equal(t, 25, first.CacheReadInputTokens)
	assert.Equal(t, "zcode:session-001", second.SessionID)
	assert.NotEqual(t, first.DedupKey, second.DedupKey)
	assert.Contains(t, first.DedupKey, "session:zcode:session-001")
	assert.Contains(t, first.DedupKey, "turn=1")
	assert.Contains(t, first.DedupKey, "provider=builtin:bigmodel-coding-plan")
	assert.Contains(t, first.DedupKey, "model=claude-sonnet-4-6")
	assert.Contains(t, first.DedupKey, "input_tokens=1000")
}

func TestZCodeUsageEventMapping(t *testing.T) {
	fixture := newZCodeTestFixture(t)
	fixture.insertSession(
		t,
		"session-usage",
		"/Users/alice/code/acme-app",
		"Usage session",
		"2026-07-06T13:00:01Z",
		"2026-07-06T13:05:00Z",
		"",
		"",
	)
	fixture.insertUsage(
		t,
		"session-usage",
		"turn-alpha",
		"builtin:bigmodel-coding-plan",
		"claude-sonnet-4-6",
		"done",
		1000, 200, 40, 50, 25, 1315,
		"2026-07-06T13:00:02Z",
		"2026-07-06T13:00:03Z",
		1000,
		2,
	)

	provider, ok := NewProvider(AgentZCode, ProviderConfig{
		Roots:   []string{fixture.CLIRoot},
		Machine: "devbox",
	})
	require.True(t, ok)

	sources, err := provider.Discover(context.Background())
	require.NoError(t, err)
	require.Len(t, sources, 1)

	outcome, err := provider.Parse(context.Background(), ParseRequest{
		Source:      sources[0],
		Fingerprint: SourceFingerprint{Key: fixture.DBPath + "#session-usage"},
		Machine:     "devbox",
	})
	require.NoError(t, err)
	require.Len(t, outcome.Results, 1)

	result := outcome.Results[0]
	require.Len(t, result.Result.UsageEvents, 1)
	event := result.Result.UsageEvents[0]
	assert.Equal(t, "zcode:session-usage", event.SessionID)
	assert.Nil(t, event.MessageOrdinal)
	assert.Equal(t, "claude-sonnet-4-6", event.Model)
	assert.Equal(t, 1000, event.InputTokens)
	assert.Equal(t, 200, event.OutputTokens)
	assert.Equal(t, 40, event.ReasoningTokens)
	assert.Equal(t, 50, event.CacheCreationInputTokens)
	assert.Equal(t, 25, event.CacheReadInputTokens)
	assert.Contains(t, event.DedupKey, "session:zcode:session-usage")
	assert.Contains(t, event.DedupKey, "turn=turn-alpha")
	assert.Contains(t, event.DedupKey, "provider=builtin:bigmodel-coding-plan")
	assert.Contains(t, event.DedupKey, "model=claude-sonnet-4-6")
}

func TestZCodeIngestsTranscriptMessages(t *testing.T) {
	fixture := newZCodeTestFixture(t)
	fixture.insertSession(
		t,
		"session-transcript",
		"/Users/alice/code/acme-app",
		"Transcript session",
		"2026-07-06T13:00:01Z",
		"2026-07-06T13:05:00Z",
		"",
		"",
	)
	fixture.insertMessage(
		t,
		"msg-1",
		"session-transcript",
		"2026-07-06T13:00:01Z",
		`{"role":"user"}`,
	)
	fixture.insertPart(
		t,
		"part-1",
		"msg-1",
		"session-transcript",
		`{"type":"text","text":"Fix the login bug."}`,
	)
	fixture.insertMessage(
		t,
		"msg-2",
		"session-transcript",
		"2026-07-06T13:00:02Z",
		`{"role":"assistant","model":{"modelID":"claude-sonnet-4-6"}}`,
	)
	fixture.insertPartAt(
		t,
		"part-z",
		"msg-2",
		"session-transcript",
		"2026-07-06T13:00:02Z",
		`{"type":"thinking","thinking":"I should inspect the auth flow."}`,
	)
	fixture.insertPartAt(
		t,
		"part-a",
		"msg-2",
		"session-transcript",
		"2026-07-06T13:00:03Z",
		`{"type":"text","text":"I'll inspect the auth flow."}`,
	)

	result, err := parseZCodeSession(fixture.DBPath, "session-transcript", "devbox")
	require.NoError(t, err)
	require.NotNil(t, result)
	assert.Equal(t, 2, result.Session.MessageCount)
	assert.Equal(t, 1, result.Session.UserMessageCount)
	require.Len(t, result.Messages, 2)
	assert.Equal(t, RoleUser, result.Messages[0].Role)
	assert.Equal(t, "Fix the login bug.", result.Messages[0].Content)
	assert.Equal(t, RoleAssistant, result.Messages[1].Role)
	assert.True(t, result.Messages[1].HasThinking)
	assert.Equal(t, "I should inspect the auth flow.", result.Messages[1].ThinkingText)
	assert.Equal(
		t,
		"[Thinking]\nI should inspect the auth flow.\n[/Thinking]\nI'll inspect the auth flow.",
		result.Messages[1].Content,
	)
	assert.Equal(t, "claude-sonnet-4-6", result.Messages[1].Model)
}

func TestZCodeToolCallsAndResults(t *testing.T) {
	fixture := newZCodeTestFixture(t)
	fixture.insertSession(
		t,
		"session-tools",
		"/Users/alice/code/acme-app",
		"Tool session",
		"2026-07-06T13:00:01Z",
		"2026-07-06T13:05:00Z",
		"",
		"",
	)
	fixture.insertMessage(
		t,
		"msg-1",
		"session-tools",
		"2026-07-06T13:00:01Z",
		`{"role":"assistant","modelID":"claude-sonnet-4-6"}`,
	)
	fixture.insertPart(
		t,
		"part-1",
		"msg-1",
		"session-tools",
		`{"type":"tool_use","id":"call-read","name":"Read","input":{"file_path":"auth.go"}}`,
	)
	fixture.insertMessage(
		t,
		"msg-2",
		"session-tools",
		"2026-07-06T13:00:02Z",
		`{"role":"user"}`,
	)
	fixture.insertPart(
		t,
		"part-2",
		"msg-2",
		"session-tools",
		`{"type":"tool_result","tool_use_id":"call-read","content":"package auth"}`,
	)

	result, err := parseZCodeSession(fixture.DBPath, "session-tools", "devbox")
	require.NoError(t, err)
	require.NotNil(t, result)
	require.Len(t, result.Messages, 2)

	assistant := result.Messages[0]
	assert.Equal(t, RoleAssistant, assistant.Role)
	assert.True(t, assistant.HasToolUse)
	require.Len(t, assistant.ToolCalls, 1)
	assert.Equal(t, "call-read", assistant.ToolCalls[0].ToolUseID)
	assert.Equal(t, "Read", assistant.ToolCalls[0].ToolName)
	assert.Equal(t, "Read", assistant.ToolCalls[0].Category)
	assert.Equal(t, `{"file_path":"auth.go"}`, assistant.ToolCalls[0].InputJSON)

	toolResult := result.Messages[1]
	assert.Equal(t, RoleUser, toolResult.Role)
	require.Len(t, toolResult.ToolResults, 1)
	assert.Equal(t, "call-read", toolResult.ToolResults[0].ToolUseID)
	assert.Equal(t, len("package auth"), toolResult.ToolResults[0].ContentLength)
	assert.Equal(t, "package auth", DecodeContent(toolResult.ToolResults[0].ContentRaw))
}

func TestZCodeOpenCodeStyleReasoningAndToolParts(t *testing.T) {
	fixture := newZCodeTestFixture(t)
	fixture.insertSession(
		t,
		"session-opencode-parts",
		"/Users/alice/code/acme-app",
		"OpenCode-style parts",
		"2026-07-06T13:00:01Z",
		"2026-07-06T13:05:00Z",
		"",
		"",
	)
	fixture.insertMessage(
		t,
		"msg-1",
		"session-opencode-parts",
		"2026-07-06T13:00:01Z",
		`{"role":"user"}`,
	)
	fixture.insertPart(
		t,
		"part-1",
		"msg-1",
		"session-opencode-parts",
		`{"type":"text","text":"Inspect the auth flow."}`,
	)
	fixture.insertMessage(
		t,
		"msg-2",
		"session-opencode-parts",
		"2026-07-06T13:00:02Z",
		`{"role":"assistant","modelID":"claude-sonnet-4-6"}`,
	)
	fixture.insertPartAt(
		t,
		"part-b",
		"msg-2",
		"session-opencode-parts",
		"2026-07-06T13:00:02Z",
		`{"type":"reasoning","text":"I should inspect the auth flow."}`,
	)
	fixture.insertPartAt(
		t,
		"part-c",
		"msg-2",
		"session-opencode-parts",
		"2026-07-06T13:00:03Z",
		`{"type":"text","text":"I'll inspect the auth flow."}`,
	)
	fixture.insertPartAt(
		t,
		"part-a",
		"msg-2",
		"session-opencode-parts",
		"2026-07-06T13:00:04Z",
		`{"type":"tool","tool":"Read","callID":"call-read","state":{"input":{"file_path":"auth.go"},"output":"package auth"}}`,
	)

	result, err := parseZCodeSession(fixture.DBPath, "session-opencode-parts", "devbox")
	require.NoError(t, err)
	require.NotNil(t, result)
	require.Len(t, result.Messages, 2)

	assistant := result.Messages[1]
	assert.Equal(t, RoleAssistant, assistant.Role)
	assert.True(t, assistant.HasThinking)
	assert.True(t, assistant.HasToolUse)
	assert.Equal(t, "I should inspect the auth flow.", assistant.ThinkingText)
	assert.Equal(
		t,
		"[Thinking]\nI should inspect the auth flow.\n[/Thinking]\nI'll inspect the auth flow.",
		assistant.Content,
	)
	require.Len(t, assistant.ToolCalls, 1)
	assert.Equal(t, "call-read", assistant.ToolCalls[0].ToolUseID)
	assert.Equal(t, "Read", assistant.ToolCalls[0].ToolName)
	assert.Equal(t, `{"file_path":"auth.go"}`, assistant.ToolCalls[0].InputJSON)
	require.Len(t, assistant.ToolResults, 1)
	assert.Equal(t, "call-read", assistant.ToolResults[0].ToolUseID)
	assert.Equal(t, len("package auth"), assistant.ToolResults[0].ContentLength)
	assert.Equal(t, "package auth", DecodeContent(assistant.ToolResults[0].ContentRaw))
}

func TestZCodeOpenCodeStyleFailedToolPart(t *testing.T) {
	fixture := newZCodeTestFixture(t)
	fixture.insertSession(
		t,
		"session-tool-error",
		"/Users/alice/code/acme-app",
		"Tool error",
		"2026-07-06T13:00:01Z",
		"2026-07-06T13:05:00Z",
		"",
		"",
	)
	fixture.insertMessage(
		t,
		"msg-1",
		"session-tool-error",
		"2026-07-06T13:00:02Z",
		`{"role":"assistant","modelID":"claude-sonnet-4-6"}`,
	)
	fixture.insertPartAt(
		t,
		"part-1",
		"msg-1",
		"session-tool-error",
		"2026-07-06T13:00:03Z",
		`{"type":"tool","tool":"Read","callID":"call-read","state":{"input":{"file_path":"auth.go"},"error":"permission denied"}}`,
	)

	result, err := parseZCodeSession(fixture.DBPath, "session-tool-error", "devbox")
	require.NoError(t, err)
	require.NotNil(t, result)
	require.Len(t, result.Messages, 1)

	assistant := result.Messages[0]
	assert.Equal(t, RoleAssistant, assistant.Role)
	assert.True(t, assistant.HasToolUse)
	require.Len(t, assistant.ToolCalls, 1)
	require.Len(t, assistant.ToolResults, 1)
	assert.Equal(t, "call-read", assistant.ToolResults[0].ToolUseID)
	assert.Equal(t, len("permission denied"), assistant.ToolResults[0].ContentLength)
	assert.Equal(t, "permission denied", DecodeContent(assistant.ToolResults[0].ContentRaw))
}

func TestZCodeFingerprintTracksUsageMtime(t *testing.T) {
	fixture := newZCodeTestFixture(t)
	fixture.insertSession(
		t,
		"session-usage-mtime",
		"/Users/alice/code/acme-app",
		"Usage mtime",
		"2026-07-06T13:00:01Z",
		"2026-07-06T13:01:00Z",
		"",
		"",
	)
	fixture.insertUsage(
		t,
		"session-usage-mtime",
		"turn-alpha",
		"builtin:bigmodel-coding-plan",
		"claude-sonnet-4-6",
		"done",
		1000, 200, 40, 50, 25, 1315,
		"2026-07-06T13:09:00Z",
		"2026-07-06T13:10:00Z",
		1000,
		2,
	)
	oldDBMtime := time.Date(2026, 7, 6, 13, 0, 0, 0, time.UTC)
	require.NoError(t, os.Chtimes(fixture.DBPath, oldDBMtime, oldDBMtime))

	provider, ok := NewProvider(AgentZCode, ProviderConfig{
		Roots:   []string{fixture.CLIRoot},
		Machine: "devbox",
	})
	require.True(t, ok)

	sources, err := provider.Discover(context.Background())
	require.NoError(t, err)
	require.Len(t, sources, 1)

	fingerprint, err := provider.Fingerprint(context.Background(), sources[0])
	require.NoError(t, err)
	expected := time.Date(2026, 7, 6, 13, 10, 0, 0, time.UTC).UnixNano()
	assert.Equal(t, expected, fingerprint.MTimeNS)
}

func TestZCodeFingerprintTracksDBMtimeForUsageOnlyChanges(t *testing.T) {
	fixture := newZCodeTestFixture(t)
	fixture.insertSession(
		t,
		"session-db-mtime",
		"/Users/alice/code/acme-app",
		"DB mtime",
		"2026-07-06T13:00:01Z",
		"2026-07-06T13:10:00Z",
		"",
		"",
	)
	fixture.insertUsage(
		t,
		"session-db-mtime",
		"turn-alpha",
		"builtin:bigmodel-coding-plan",
		"claude-sonnet-4-6",
		"done",
		1000, 200, 40, 50, 25, 1315,
		"2026-07-06T13:04:00Z",
		"2026-07-06T13:05:00Z",
		1000,
		2,
	)
	dbMtime := time.Date(2026, 7, 6, 13, 20, 0, 0, time.UTC)
	require.NoError(t, os.Chtimes(fixture.DBPath, dbMtime, dbMtime))

	provider, ok := NewProvider(AgentZCode, ProviderConfig{
		Roots:   []string{fixture.CLIRoot},
		Machine: "devbox",
	})
	require.True(t, ok)

	sources, err := provider.Discover(context.Background())
	require.NoError(t, err)
	require.Len(t, sources, 1)

	fingerprint, err := provider.Fingerprint(context.Background(), sources[0])
	require.NoError(t, err)
	assert.Equal(t, dbMtime.UnixNano(), fingerprint.MTimeNS)
}

func TestZCodeFallsBackToDBMtimeWhenTimestampsAreMissing(t *testing.T) {
	fixture := newZCodeTestFixture(t)
	fixture.insertSession(
		t,
		"session-no-timestamps",
		"/Users/alice/code/acme-app",
		"No timestamps",
		nil,
		nil,
		"",
		"",
	)
	dbMtime := time.Date(2026, 7, 6, 13, 20, 0, 0, time.UTC)
	require.NoError(t, os.Chtimes(fixture.DBPath, dbMtime, dbMtime))

	provider, ok := NewProvider(AgentZCode, ProviderConfig{
		Roots:   []string{fixture.CLIRoot},
		Machine: "devbox",
	})
	require.True(t, ok)

	sources, err := provider.Discover(context.Background())
	require.NoError(t, err)
	require.Len(t, sources, 1)

	outcome, err := provider.Parse(context.Background(), ParseRequest{
		Source:  sources[0],
		Machine: "devbox",
	})
	require.NoError(t, err)
	require.Len(t, outcome.Results, 1)
	assert.Equal(t, dbMtime.UnixNano(), outcome.Results[0].Result.Session.File.Mtime)
}

func TestZCodeParsesSessionWhenUsageTableIsMissing(t *testing.T) {
	fixture := newZCodeTestFixture(t)
	_, err := fixture.database.Exec(`DROP TABLE model_usage`)
	require.NoError(t, err)
	fixture.insertSession(
		t,
		"session-no-usage-table",
		"/Users/alice/code/acme-app",
		"No usage table",
		"2026-07-06T13:00:01Z",
		"2026-07-06T13:05:00Z",
		"",
		"",
	)

	provider, ok := NewProvider(AgentZCode, ProviderConfig{
		Roots:   []string{fixture.CLIRoot},
		Machine: "devbox",
	})
	require.True(t, ok)

	sources, err := provider.Discover(context.Background())
	require.NoError(t, err)
	require.Len(t, sources, 1)

	outcome, err := provider.Parse(context.Background(), ParseRequest{
		Source:  sources[0],
		Machine: "devbox",
	})
	require.NoError(t, err)
	require.Len(t, outcome.Results, 1)

	result := outcome.Results[0].Result
	assert.Equal(t, "zcode:session-no-usage-table", result.Session.ID)
	assert.Equal(t, 0, result.Session.MessageCount)
	assert.Empty(t, result.UsageEvents)
	assert.False(t, result.Session.HasTotalOutputTokens)
	assert.False(t, result.Session.HasPeakContextTokens)
}

func TestZCodeMissingTranscriptTables(t *testing.T) {
	fixture := newZCodeTestFixture(t)
	_, err := fixture.database.Exec(`DROP TABLE part`)
	require.NoError(t, err)
	_, err = fixture.database.Exec(`DROP TABLE message`)
	require.NoError(t, err)
	fixture.insertSession(
		t,
		"session-no-transcript",
		"/Users/alice/code/acme-app",
		"No transcript",
		"2026-07-06T13:00:01Z",
		"2026-07-06T13:05:00Z",
		"",
		"",
	)
	fixture.insertUsage(
		t,
		"session-no-transcript",
		"1",
		"builtin:bigmodel-coding-plan",
		"claude-sonnet-4-6",
		"done",
		1000, 200, 40, 50, 25, 1315,
		"2026-07-06T13:00:02Z",
		"2026-07-06T13:00:03Z",
		1000,
		2,
	)

	result, err := parseZCodeSession(fixture.DBPath, "session-no-transcript", "devbox")
	require.NoError(t, err)
	require.NotNil(t, result)
	assert.Equal(t, 0, result.Session.MessageCount)
	assert.Equal(t, 0, result.Session.UserMessageCount)
	assert.Empty(t, result.Messages)
	require.Len(t, result.UsageEvents, 1)
	assert.Equal(t, 200, result.Session.TotalOutputTokens)
	assert.True(t, result.Session.HasTotalOutputTokens)
}

func TestZCodeProviderRootWithoutDB(t *testing.T) {
	root := t.TempDir()
	cliRoot := filepath.Join(root, ".zcode", "cli")
	require.NoError(t, os.MkdirAll(cliRoot, 0o755))

	provider, ok := NewProvider(AgentZCode, ProviderConfig{
		Roots:   []string{cliRoot},
		Machine: "devbox",
	})
	require.True(t, ok)

	sources, err := provider.Discover(context.Background())
	require.NoError(t, err)
	assert.Empty(t, sources)
}

func nullableZCodeString(v string) any {
	if v == "" {
		return nil
	}
	return v
}
func TestZCodeSystemMessagesAreMarkedSystem(t *testing.T) {
	fixture := newZCodeTestFixture(t)
	fixture.insertSession(
		t,
		"session-system",
		"/Users/alice/code/acme-app",
		"System session",
		"2026-07-06T13:00:01Z",
		"2026-07-06T13:05:00Z",
		"",
		"",
	)
	fixture.insertMessage(
		t,
		"msg-system",
		"session-system",
		"2026-07-06T13:00:01Z",
		`{"role":"system"}`,
	)
	fixture.insertPart(
		t,
		"part-system",
		"msg-system",
		"session-system",
		`{"type":"text","text":"You are a code reviewer."}`,
	)

	result, err := parseZCodeSession(fixture.DBPath, "session-system", "devbox")
	require.NoError(t, err)
	require.NotNil(t, result)
	require.Len(t, result.Messages, 1)
	assert.Equal(t, RoleSystem, result.Messages[0].Role)
	assert.True(t, result.Messages[0].IsSystem)
}