import { Container } from "@earendil-works/pi-tui";
import stripAnsi from "strip-ansi";
import { beforeAll, describe, expect, test, vi } from "vitest";
import { AgentActivityTracker } from "../src/modes/interactive/agent-activity.js";
import { InteractiveMode } from "../src/modes/interactive/interactive-mode.js";
import { initTheme } from "../src/modes/interactive/theme/theme.js";

const handleEvent = Reflect.get(InteractiveMode.prototype, "handleEvent") as (
	this: unknown,
	event: Record<string, unknown>,
) => Promise<void>;

const startCompactionLoader = Reflect.get(InteractiveMode.prototype, "startCompactionLoader") as (
	this: unknown,
	reason: string,
	customInstructions?: string,
) => void;

function createFakeThis(overrides: Record<string, unknown> = {}) {
	return {
		isInitialized: true,
		footer: { invalidate: vi.fn() },
		updateConnectionStateFromEvent: vi.fn(),
		activityTracker: new AgentActivityTracker(),
		updateWorkingLoaderMessage: vi.fn(),
		autoCompactionLoader: undefined,
		retryLoader: undefined,
		startCompactionLoader(this: Record<string, unknown>, reason: string, customInstructions?: string) {
			startCompactionLoader.call(this, reason, customInstructions);
		},
		workingVisible: true,
		stopWorkingLoader: vi.fn(),
		syncWorkingLoader: vi.fn(),
		defaultEditor: {},
		statusContainer: { clear: vi.fn() },
		chatContainer: { clear: vi.fn() },
		rebuildChatFromMessages: vi.fn(function (this: { chatContainer: { clear(): void } }) {
			this.chatContainer.clear();
			return Promise.resolve();
		}),
		addMessageToChat: vi.fn(),
		refreshConnectionContextUsage: vi.fn().mockResolvedValue(undefined),
		showError: vi.fn(),
		showWarning: vi.fn(),
		showStatus: vi.fn(),
		settingsManager: { getShowTerminalProgress: () => false },
		ui: { requestRender: vi.fn(), terminal: { setProgress: vi.fn() } },
		...overrides,
	};
}

describe("InteractiveMode compaction events", () => {
	beforeAll(() => initTheme("dark"));

	test("shows an automatic compaction loader for the full operation", async () => {
		const statusContainer = new Container();
		const fakeThis = createFakeThis({ statusContainer });

		await handleEvent.call(fakeThis, { type: "compaction_start", reason: "threshold" });

		expect(stripAnsi(statusContainer.render(80).join("\n"))).toContain("Auto-compacting");
		expect(fakeThis.ui.requestRender).toHaveBeenCalled();

		await handleEvent.call(fakeThis, {
			type: "compaction_end",
			reason: "threshold",
			result: undefined,
			aborted: true,
			willRetry: false,
		});
		expect(statusContainer.children).toHaveLength(0);
	});

	test.each([
		{ name: "rebuilds successful compaction from its single persisted summary", refresh: "succeeds" },
		{ name: "keeps stale chat and reports a failed post-compaction refresh", refresh: "fails" },
	] as const)("$name", async ({ refresh }) => {
		const fakeThis = createFakeThis(
			refresh === "fails"
				? { rebuildChatFromMessages: vi.fn().mockRejectedValue(new Error("context unavailable")) }
				: {},
		);

		await handleEvent.call(fakeThis, {
			type: "compaction_end",
			reason: "requested",
			result: { tokensBefore: 123, summary: "summary" },
			aborted: false,
			willRetry: false,
		});

		expect(fakeThis.chatContainer.clear).toHaveBeenCalledTimes(refresh === "succeeds" ? 1 : 0);
		expect(fakeThis.rebuildChatFromMessages).toHaveBeenCalledOnce();
		expect(fakeThis.addMessageToChat).not.toHaveBeenCalled();
		if (refresh === "fails") {
			expect(fakeThis.showError).toHaveBeenCalledWith(
				"Compaction succeeded, but the transcript could not be refreshed: context unavailable",
			);
		} else {
			expect(fakeThis.showError).not.toHaveBeenCalled();
		}
	});

	test("shows manual warning-severity outcomes as warnings, not errors", async () => {
		const fakeThis = createFakeThis();

		await handleEvent.call(fakeThis, {
			type: "compaction_end",
			reason: "manual",
			result: undefined,
			aborted: false,
			willRetry: false,
			errorMessage: "Session is too short to compact",
			errorSeverity: "warning",
		});

		expect(fakeThis.showWarning).toHaveBeenCalledWith("Session is too short to compact");
		expect(fakeThis.showError).not.toHaveBeenCalled();
	});

	test("restores the compaction loader from state when no start event was seen", () => {
		const statusContainer = new Container();
		const fakeThis = createFakeThis({
			statusContainer,
			connectionState: { isCompacting: true },
			isAgentCompacting() {
				return true;
			},
			loadingAnimation: undefined,
			workingVisible: true,
			isAgentStreaming: () => false,
			stopWorkingLoader: vi.fn(),
			startWorkingLoader: vi.fn(),
		});

		(Reflect.get(InteractiveMode.prototype, "syncWorkingLoader") as (this: unknown) => void).call(fakeThis);

		expect(stripAnsi(statusContainer.render(80).join("\n"))).toContain("Compacting context");
	});
});