import { describe, expect, it } from "vitest";

import {
  PROVIDER_SEND_TURN_MAX_ATTACHMENTS,
  providerCheckpointSchema,
  providerEventSchema,
  providerGetCheckpointDiffInputSchema,
  providerGetCheckpointDiffResultSchema,
  providerListCheckpointsInputSchema,
  providerListCheckpointsResultSchema,
  providerRevertToCheckpointInputSchema,
  providerRevertToCheckpointResultSchema,
  providerRespondToRequestInputSchema,
  providerSendTurnInputSchema,
  providerSessionStartInputSchema,
} from "./provider";

describe("providerSessionStartInputSchema", () => {
  it("defaults to codex with safe policies", () => {
    const parsed = providerSessionStartInputSchema.parse({});
    expect(parsed.provider).toBe("codex");
    expect(parsed.approvalPolicy).toBe("never");
    expect(parsed.sandboxMode).toBe("workspace-write");
  });

  it("accepts optional resumeThreadId", () => {
    const parsed = providerSessionStartInputSchema.parse({
      resumeThreadId: "thread_123",
    });
    expect(parsed.resumeThreadId).toBe("thread_123");
  });

  it("rejects blank resumeThreadId", () => {
    expect(() =>
      providerSessionStartInputSchema.parse({
        resumeThreadId: "   ",
      }),
    ).toThrow();
  });

  it("accepts optional codex binary and home path overrides", () => {
    const parsed = providerSessionStartInputSchema.parse({
      codexBinaryPath: "/opt/codex/bin/codex",
      codexHomePath: "/Users/theo/.codex",
    });
    expect(parsed.codexBinaryPath).toBe("/opt/codex/bin/codex");
    expect(parsed.codexHomePath).toBe("/Users/theo/.codex");
  });

  it("rejects blank codex overrides", () => {
    expect(() =>
      providerSessionStartInputSchema.parse({
        codexBinaryPath: "   ",
      }),
    ).toThrow();
    expect(() =>
      providerSessionStartInputSchema.parse({
        codexHomePath: "   ",
      }),
    ).toThrow();
  });
});

describe("providerSendTurnInputSchema", () => {
  it("trims input text and optional model/effort", () => {
    const parsed = providerSendTurnInputSchema.parse({
      sessionId: "sess_1",
      input: "  summarize this repo  ",
      model: "  gpt-5.2-codex  ",
      effort: "  high  ",
    });
    expect(parsed.input).toBe("summarize this repo");
    expect(parsed.attachments).toEqual([]);
    expect(parsed.model).toBe("gpt-5.2-codex");
    expect(parsed.effort).toBe("high");
  });

  it("accepts image-only turns", () => {
    const parsed = providerSendTurnInputSchema.parse({
      sessionId: "sess_1",
      attachments: [
        {
          type: "image",
          name: "diagram.png",
          mimeType: "image/png",
          sizeBytes: 1_024,
          dataUrl: "data:image/png;base64,AAAA",
        },
      ],
    });
    expect(parsed.input).toBeUndefined();
    expect(parsed.attachments).toHaveLength(1);
  });

  it("rejects turns with neither text nor attachments", () => {
    expect(() =>
      providerSendTurnInputSchema.parse({
        sessionId: "sess_1",
      }),
    ).toThrow();
  });

  it("rejects non-image data urls", () => {
    expect(() =>
      providerSendTurnInputSchema.parse({
        sessionId: "sess_1",
        attachments: [
          {
            type: "image",
            name: "not-image.txt",
            mimeType: "text/plain",
            sizeBytes: 25,
            dataUrl: "data:text/plain;base64,QQ==",
          },
        ],
      }),
    ).toThrow();
  });

  it("rejects more than the max attachment count", () => {
    expect(() =>
      providerSendTurnInputSchema.parse({
        sessionId: "sess_1",
        attachments: Array.from({ length: PROVIDER_SEND_TURN_MAX_ATTACHMENTS + 1 }, (_, index) => ({
          type: "image" as const,
          name: `image-${index}.png`,
          mimeType: "image/png",
          sizeBytes: 1_024,
          dataUrl: "data:image/png;base64,AAAA",
        })),
      }),
    ).toThrow();
  });
});

describe("providerEventSchema", () => {
  it("accepts notification events with routing metadata", () => {
    const parsed = providerEventSchema.parse({
      id: "evt_1",
      kind: "notification",
      provider: "codex",
      sessionId: "sess_1",
      createdAt: "2026-01-01T00:00:00.000Z",
      method: "item/agentMessage/delta",
      threadId: "thr_1",
      turnId: "turn_1",
      itemId: "item_1",
      textDelta: "hi",
    });
    expect(parsed.method).toBe("item/agentMessage/delta");
  });

  it("accepts request approval metadata", () => {
    const parsed = providerEventSchema.parse({
      id: "evt_2",
      kind: "request",
      provider: "codex",
      sessionId: "sess_1",
      createdAt: "2026-01-01T00:00:00.000Z",
      method: "item/commandExecution/requestApproval",
      requestId: "req_123",
      requestKind: "command",
    });
    expect(parsed.requestId).toBe("req_123");
    expect(parsed.requestKind).toBe("command");
  });
});

describe("providerRespondToRequestInputSchema", () => {
  it("accepts valid decisions", () => {
    const parsed = providerRespondToRequestInputSchema.parse({
      sessionId: "sess_1",
      requestId: "req_1",
      decision: "acceptForSession",
    });
    expect(parsed.decision).toBe("acceptForSession");
  });

  it("rejects unknown decisions", () => {
    expect(() =>
      providerRespondToRequestInputSchema.parse({
        sessionId: "sess_1",
        requestId: "req_1",
        decision: "always",
      }),
    ).toThrow();
  });
});

describe("provider checkpoint schemas", () => {
  it("accepts list checkpoint inputs", () => {
    const parsed = providerListCheckpointsInputSchema.parse({
      sessionId: "sess_1",
    });
    expect(parsed.sessionId).toBe("sess_1");
  });

  it("accepts checkpoint records and list results", () => {
    const checkpoint = providerCheckpointSchema.parse({
      id: "turn_1",
      turnCount: 1,
      messageCount: 2,
      label: "Turn 1",
      preview: "Summarize this file",
      isCurrent: true,
    });
    expect(checkpoint.turnCount).toBe(1);

    const listResult = providerListCheckpointsResultSchema.parse({
      threadId: "thr_1",
      checkpoints: [checkpoint],
    });
    expect(listResult.checkpoints).toHaveLength(1);
  });

  it("accepts revert checkpoint input/result", () => {
    const input = providerRevertToCheckpointInputSchema.parse({
      sessionId: "sess_1",
      turnCount: 2,
    });
    expect(input.turnCount).toBe(2);

    const result = providerRevertToCheckpointResultSchema.parse({
      threadId: "thr_1",
      turnCount: 2,
      messageCount: 4,
      rolledBackTurns: 1,
      checkpoints: [
        {
          id: "root",
          turnCount: 0,
          messageCount: 0,
          label: "Start of conversation",
          isCurrent: false,
        },
        {
          id: "turn_2",
          turnCount: 2,
          messageCount: 4,
          label: "Turn 2",
          isCurrent: true,
        },
      ],
    });
    expect(result.rolledBackTurns).toBe(1);
  });

  it("rejects negative turn counts", () => {
    expect(() =>
      providerRevertToCheckpointInputSchema.parse({
        sessionId: "sess_1",
        turnCount: -1,
      }),
    ).toThrow();
  });

  it("accepts checkpoint diff input/result", () => {
    const input = providerGetCheckpointDiffInputSchema.parse({
      sessionId: "sess_1",
      fromTurnCount: 1,
      toTurnCount: 2,
    });
    expect(input.fromTurnCount).toBe(1);

    const result = providerGetCheckpointDiffResultSchema.parse({
      threadId: "thr_1",
      fromTurnCount: 1,
      toTurnCount: 2,
      diff: "diff --git a/src/app.ts b/src/app.ts",
    });
    expect(result.toTurnCount).toBe(2);
  });

  it("rejects checkpoint diff ranges where start is after end", () => {
    expect(() =>
      providerGetCheckpointDiffInputSchema.parse({
        sessionId: "sess_1",
        fromTurnCount: 3,
        toTurnCount: 2,
      }),
    ).toThrow();
  });
});