import { describe, expect, it, vi } from "vitest";
import {
  normalizeTitle,
  DisabledProvider,
  ApiModelTitleProvider,
  SessionTitleGenerator,
  type SessionTitleGeneratorDeps,
  type TitleGenerationMetrics,
} from "./session-title-generator.js";

// ─── normalizeTitle ───

describe("normalizeTitle", () => {
  it("returns null for null/undefined/empty", () => {
    expect(normalizeTitle(null)).toBeNull();
    expect(normalizeTitle(undefined)).toBeNull();
    expect(normalizeTitle("")).toBeNull();
    expect(normalizeTitle("   ")).toBeNull();
  });

  it("takes first line only", () => {
    expect(normalizeTitle("Fix WebSocket Bug\nSome extra text")).toBe("Fix WebSocket Bug");
  });

  it("strips Title: prefix (case-insensitive)", () => {
    expect(normalizeTitle("Title: Fix WebSocket Bug")).toBe("Fix WebSocket Bug");
    expect(normalizeTitle("title: Fix WebSocket Bug")).toBe("Fix WebSocket Bug");
    expect(normalizeTitle("TITLE:  Fix WebSocket Bug")).toBe("Fix WebSocket Bug");
  });

  it("strips wrapping quotes (straight, curly, backticks)", () => {
    expect(normalizeTitle('"Fix WebSocket Bug"')).toBe("Fix WebSocket Bug");
    expect(normalizeTitle("'Fix WebSocket Bug'")).toBe("Fix WebSocket Bug");
    expect(normalizeTitle("`Fix WebSocket Bug`")).toBe("Fix WebSocket Bug");
    expect(normalizeTitle("\u201cFix WebSocket Bug\u201d")).toBe("Fix WebSocket Bug");
    expect(normalizeTitle("\u2018Fix WebSocket Bug\u2019")).toBe("Fix WebSocket Bug");
  });

  it("strips wrapping brackets and parens", () => {
    expect(normalizeTitle("[Fix WebSocket Bug]")).toBe("Fix WebSocket Bug");
    expect(normalizeTitle("(Fix WebSocket Bug)")).toBe("Fix WebSocket Bug");
  });

  it("strips trailing punctuation", () => {
    expect(normalizeTitle("Fix WebSocket Bug.")).toBe("Fix WebSocket Bug");
    expect(normalizeTitle("Fix WebSocket Bug!")).toBe("Fix WebSocket Bug");
    expect(normalizeTitle("Fix WebSocket Bug?")).toBe("Fix WebSocket Bug");
    expect(normalizeTitle("Fix WebSocket Bug;")).toBe("Fix WebSocket Bug");
    expect(normalizeTitle("Fix WebSocket Bug:")).toBe("Fix WebSocket Bug");
    expect(normalizeTitle("Fix WebSocket Bug,")).toBe("Fix WebSocket Bug");
  });

  it("collapses whitespace", () => {
    expect(normalizeTitle("Fix   WebSocket   Bug")).toBe("Fix WebSocket Bug");
    expect(normalizeTitle("  Fix  WebSocket  Bug  ")).toBe("Fix WebSocket Bug");
  });

  it("caps at 48 chars at word boundary", () => {
    const long = "Investigate Really Long Session Title That Exceeds The Maximum Allowed Length";
    const result = normalizeTitle(long);
    expect(result).not.toBeNull();
    expect(result!.length).toBeLessThanOrEqual(48);
    // Should break at a word boundary
    expect(result).not.toMatch(/\s$/);
  });

  it("handles combined artifacts", () => {
    expect(normalizeTitle('Title: "Fix WebSocket Bug!"')).toBe("Fix WebSocket Bug");
  });

  it("preserves valid titles", () => {
    expect(normalizeTitle("Fix WebSocket Bug")).toBe("Fix WebSocket Bug");
    expect(normalizeTitle("Debug Auth Flow")).toBe("Debug Auth Flow");
  });

  it("returns null if nothing left after stripping", () => {
    expect(normalizeTitle('""')).toBeNull();
    expect(normalizeTitle("Title:")).toBeNull();
    expect(normalizeTitle("...")).toBeNull();
  });
});

// ─── DisabledProvider ───

describe("DisabledProvider", () => {
  it("returns null", async () => {
    const provider = new DisabledProvider();
    expect(provider.name).toBe("disabled");
    expect(await provider.generateTitle("fix the websocket bug")).toBeNull();
  });
});

// ─── ApiModelTitleProvider ───

describe("ApiModelTitleProvider", () => {
  it("returns null when model is not found", async () => {
    const mockRegistry = {
      find: vi.fn(() => undefined),
      getApiKey: vi.fn(),
    };
    const onMetrics = vi.fn();
    const provider = new ApiModelTitleProvider(
      "anthropic/nonexistent",
      mockRegistry as never,
      onMetrics,
    );
    const result = await provider.generateTitle("fix the websocket bug");
    expect(result).toBeNull();
    expect(onMetrics).toHaveBeenCalledWith(
      expect.objectContaining({ status: "error", model: "anthropic/nonexistent" }),
    );
  });

  it("reports metrics on error", async () => {
    const mockRegistry = {
      find: vi.fn(() => undefined),
      getApiKey: vi.fn(),
    };
    const onMetrics = vi.fn();
    const provider = new ApiModelTitleProvider("bad/model-id", mockRegistry as never, onMetrics);
    await provider.generateTitle("some message");
    expect(onMetrics).toHaveBeenCalledTimes(1);
    const metrics = onMetrics.mock.calls[0][0] as TitleGenerationMetrics;
    expect(metrics.status).toBe("error");
    expect(metrics.durationMs).toBeGreaterThanOrEqual(0);
    expect(metrics.tokens).toBe(0);
  });

  it("returns null for unparseable model ID", async () => {
    const mockRegistry = {
      find: vi.fn(() => undefined),
      getApiKey: vi.fn(),
    };
    const provider = new ApiModelTitleProvider("no-slash", mockRegistry as never);
    const result = await provider.generateTitle("fix the websocket bug");
    expect(result).toBeNull();
  });
});

// ─── SessionTitleGenerator (orchestrator) ───

describe("SessionTitleGenerator", () => {
  function makeDeps(overrides?: Partial<SessionTitleGeneratorDeps>): SessionTitleGeneratorDeps {
    return {
      getConfig: () => ({ enabled: true, model: "anthropic/claude-haiku-3" }),
      modelRegistry: { find: vi.fn(() => undefined), getApiKey: vi.fn() } as never,
      getSession: vi.fn((id: string) => ({ id, name: undefined })),
      updateSessionName: vi.fn(),
      broadcastSessionUpdate: vi.fn(),
      onMetrics: vi.fn(),
      ...overrides,
    };
  }

  it("skips when disabled", () => {
    const deps = makeDeps({
      getConfig: () => ({ enabled: false }),
    });
    const gen = new SessionTitleGenerator(deps);
    gen.tryGenerateTitle({ id: "s1", firstMessage: "fix the websocket reconnect bug" });
    // Should not even attempt — no async work
    expect(deps.updateSessionName).not.toHaveBeenCalled();
  });

  it("skips when session already has a name", () => {
    const deps = makeDeps();
    const gen = new SessionTitleGenerator(deps);
    gen.tryGenerateTitle({
      id: "s1",
      name: "Existing Title",
      firstMessage: "fix the websocket reconnect bug",
    });
    expect(deps.updateSessionName).not.toHaveBeenCalled();
  });

  it("skips when firstMessage is too short", () => {
    const deps = makeDeps();
    const gen = new SessionTitleGenerator(deps);
    gen.tryGenerateTitle({ id: "s1", firstMessage: "hi" });
    expect(deps.updateSessionName).not.toHaveBeenCalled();
  });

  it("skips when no model configured", () => {
    const deps = makeDeps({
      getConfig: () => ({ enabled: true, model: undefined }),
    });
    const gen = new SessionTitleGenerator(deps);
    gen.tryGenerateTitle({ id: "s1", firstMessage: "fix the websocket reconnect bug" });
    expect(deps.updateSessionName).not.toHaveBeenCalled();
  });

  it("skips save if session name was set during generation", async () => {
    const deps = makeDeps({
      // Simulate: by the time generation completes, session already has a name
      getSession: vi.fn(() => ({ id: "s1", name: "Already Named" })),
      modelRegistry: {
        find: vi.fn(() => undefined),
        getApiKey: vi.fn(),
      } as never,
    });
    const gen = new SessionTitleGenerator(deps);
    gen.tryGenerateTitle({ id: "s1", firstMessage: "fix the websocket reconnect bug" });

    // Wait for the async fire-and-forget to complete
    await new Promise((r) => setTimeout(r, 50));

    // Model not found → no title → no save attempted anyway
    // But the re-check logic is tested by the path
    expect(deps.updateSessionName).not.toHaveBeenCalled();
  });

  it("skips save if session no longer exists", async () => {
    const deps = makeDeps({
      getSession: vi.fn(() => undefined),
      modelRegistry: {
        find: vi.fn(() => undefined),
        getApiKey: vi.fn(),
      } as never,
    });
    const gen = new SessionTitleGenerator(deps);
    gen.tryGenerateTitle({ id: "s1", firstMessage: "fix the websocket reconnect bug" });

    await new Promise((r) => setTimeout(r, 50));
    expect(deps.updateSessionName).not.toHaveBeenCalled();
  });
});

// ─── appendSessionMessage trigger ───

describe("appendSessionMessage trigger", () => {
  it("returns true when firstMessage is first captured", async () => {
    // Import the actual function
    const { appendSessionMessage } = await import("./session-protocol.js");
    const session: Record<string, unknown> = {
      id: "s1",
      status: "ready" as const,
      createdAt: Date.now(),
      lastActivity: Date.now(),
      messageCount: 0,
      tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
      cost: 0,
    };

    const result = appendSessionMessage(session as never, {
      role: "user",
      content: "fix the websocket reconnect state drift in the session manager",
      timestamp: Date.now(),
    });

    expect(result).toBe(true);
    expect(session.firstMessage).toBe(
      "fix the websocket reconnect state drift in the session manager",
    );
  });

  it("returns false for subsequent user messages", async () => {
    const { appendSessionMessage } = await import("./session-protocol.js");
    const session = {
      id: "s1",
      status: "ready" as const,
      createdAt: Date.now(),
      lastActivity: Date.now(),
      messageCount: 1,
      firstMessage: "first message",
      tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
      cost: 0,
    };

    const result = appendSessionMessage(session, {
      role: "user",
      content: "second message",
      timestamp: Date.now(),
    });

    expect(result).toBe(false);
    expect(session.firstMessage).toBe("first message");
  });

  it("returns false for assistant messages", async () => {
    const { appendSessionMessage } = await import("./session-protocol.js");
    const session: Record<string, unknown> = {
      id: "s1",
      status: "ready" as const,
      createdAt: Date.now(),
      lastActivity: Date.now(),
      messageCount: 0,
      tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
      cost: 0,
    };

    const result = appendSessionMessage(session as never, {
      role: "assistant",
      content: "I'll help you fix that",
      timestamp: Date.now(),
    });

    expect(result).toBe(false);
    expect(session.firstMessage).toBeUndefined();
  });
});