import {
  ASSISTANT_CITATION_MAX_TEXT_LENGTH,
  EnvironmentId,
  MessageId,
  PROVIDER_SEND_TURN_MAX_INPUT_CHARS,
  ThreadId,
} from "@t3tools/contracts";
import {
  expandAssistantCitationsForProvider,
  serializeAssistantCitation,
} from "@t3tools/shared/assistantCitations";
import { describe, expect, it, vi } from "vite-plus/test";

import { submitComposerDraft } from "./composerSubmission";

const assistantCitation = {
  version: 1 as const,
  environmentId: EnvironmentId.make("source-environment"),
  threadId: ThreadId.make("source-thread"),
  messageId: MessageId.make("source-message"),
  text: "Keep the parser shared.",
  start: 0,
  end: 23,
  prefix: "",
  suffix: "",
};

describe("submitComposerDraft", () => {
  it("keeps an oversized draft editable and sends a corrected follow-up", () => {
    let draft = "x".repeat(PROVIDER_SEND_TURN_MAX_INPUT_CHARS + 1);
    let validationMessage: string | null = null;
    const dispatchedDrafts: string[] = [];
    const preventDefault = vi.fn();

    const submit = () => {
      const result = submitComposerDraft({
        prompt: draft,
        submissionTarget: "provider-turn",
        event: { preventDefault },
        onSend: () => {
          dispatchedDrafts.push(draft);
        },
      });
      validationMessage = result.validationMessage;
    };

    submit();

    expect(dispatchedDrafts).toEqual([]);
    expect(draft).toHaveLength(PROVIDER_SEND_TURN_MAX_INPUT_CHARS + 1);
    expect(validationMessage).toBe(
      "Prompt is 1 character over the 120,000-character limit. Shorten or split it before sending.",
    );
    expect(preventDefault).toHaveBeenCalledOnce();

    draft = "Corrected prompt";
    submit();

    expect(dispatchedDrafts).toEqual(["Corrected prompt"]);
    expect(validationMessage).toBeNull();
  });

  it("allows a draft at the shared character limit through the normal send path", () => {
    const draft = "x".repeat(PROVIDER_SEND_TURN_MAX_INPUT_CHARS);
    const onSend = vi.fn();
    const preventDefault = vi.fn();

    const result = submitComposerDraft({
      prompt: draft,
      submissionTarget: "provider-turn",
      event: { preventDefault },
      onSend,
    });

    expect(result).toEqual({ validationMessage: null, didDispatch: true });
    expect(onSend).toHaveBeenCalledOnce();
    expect(preventDefault).not.toHaveBeenCalled();
  });

  it("blocks when appended context pushes the provider input over the shared limit", () => {
    const draft = "x".repeat(PROVIDER_SEND_TURN_MAX_INPUT_CHARS);
    const onSend = vi.fn();

    const result = submitComposerDraft({
      prompt: draft,
      providerInput: `${draft}\n\nTerminal context`,
      submissionTarget: "provider-turn",
      event: undefined,
      onSend,
    });

    expect(result).toEqual({
      validationMessage:
        "Prompt is 18 characters over the 120,000-character limit. Shorten or split it before sending.",
      didDispatch: false,
    });
    expect(draft).toHaveLength(PROVIDER_SEND_TURN_MAX_INPUT_CHARS);
    expect(onSend).not.toHaveBeenCalled();

    const correctedResult = submitComposerDraft({
      prompt: "Corrected prompt",
      providerInput: "Corrected prompt\n\nShort terminal context",
      submissionTarget: "provider-turn",
      event: undefined,
      onSend,
    });

    expect(correctedResult).toEqual({ validationMessage: null, didDispatch: true });
    expect(onSend).toHaveBeenCalledOnce();
  });

  it("does not finish submission when the send boundary rejects composed provider input", () => {
    const preventDefault = vi.fn();

    const result = submitComposerDraft({
      prompt: "Sendable raw draft",
      submissionTarget: "provider-turn",
      event: { preventDefault },
      onSend: () => false,
    });

    expect(result).toEqual({ validationMessage: null, didDispatch: false });
    expect(preventDefault).toHaveBeenCalledOnce();
  });

  it("allows fully composed provider input at the shared character limit", () => {
    const onSend = vi.fn();

    const result = submitComposerDraft({
      prompt: "Short draft",
      providerInput: "x".repeat(PROVIDER_SEND_TURN_MAX_INPUT_CHARS),
      submissionTarget: "provider-turn",
      event: undefined,
      onSend,
    });

    expect(result).toEqual({ validationMessage: null, didDispatch: true });
    expect(onSend).toHaveBeenCalledOnce();
  });

  it.each(["draft", "composed provider input"])(
    "blocks a %s when citation expansion exceeds the shared limit",
    (source) => {
      const citation = serializeAssistantCitation(assistantCitation);
      const followUp = `Explain ${citation}\n\nTerminal context`;
      const providerInput = `${"x".repeat(
        PROVIDER_SEND_TURN_MAX_INPUT_CHARS -
          expandAssistantCitationsForProvider(followUp).length +
          1,
      )}${followUp}`;
      const onSend = vi.fn();
      const preventDefault = vi.fn();

      expect(providerInput.length).toBeLessThan(PROVIDER_SEND_TURN_MAX_INPUT_CHARS);
      const result = submitComposerDraft({
        prompt: source === "draft" ? providerInput : "Explain the quote",
        ...(source === "composed provider input" ? { providerInput } : {}),
        submissionTarget: "provider-turn",
        event: { preventDefault },
        onSend,
      });

      expect(result).toEqual({
        validationMessage:
          "Prompt is 1 character over the 120,000-character limit. Shorten or split it before sending.",
        didDispatch: false,
      });
      expect(onSend).not.toHaveBeenCalled();
      expect(preventDefault).toHaveBeenCalledOnce();
    },
  );

  it("keeps the encoded-message limit when citation expansion is shorter", () => {
    const citation = serializeAssistantCitation({
      ...assistantCitation,
      text: "é".repeat(ASSISTANT_CITATION_MAX_TEXT_LENGTH),
      end: ASSISTANT_CITATION_MAX_TEXT_LENGTH,
    });
    const draft = `${"x".repeat(
      PROVIDER_SEND_TURN_MAX_INPUT_CHARS - citation.length + 1,
    )}${citation}`;
    const onSend = vi.fn();

    expect(expandAssistantCitationsForProvider(draft).length).toBeLessThan(
      PROVIDER_SEND_TURN_MAX_INPUT_CHARS,
    );
    const result = submitComposerDraft({
      prompt: draft,
      submissionTarget: "provider-turn",
      event: undefined,
      onSend,
    });

    expect(result).toEqual({
      validationMessage:
        "Prompt is 1 character over the 120,000-character limit. Shorten or split it before sending.",
      didDispatch: false,
    });
    expect(onSend).not.toHaveBeenCalled();
  });

  it("sends canonical citations when expanded input fits exactly after trimming", () => {
    const citation = serializeAssistantCitation(assistantCitation);
    const draft = ` ${"x".repeat(
      PROVIDER_SEND_TURN_MAX_INPUT_CHARS - expandAssistantCitationsForProvider(citation).length,
    )}${citation} \n`;
    const dispatchedDrafts: string[] = [];

    const result = submitComposerDraft({
      prompt: draft,
      submissionTarget: "provider-turn",
      event: undefined,
      onSend: () => {
        dispatchedDrafts.push(draft);
      },
    });

    expect(result).toEqual({ validationMessage: null, didDispatch: true });
    expect(dispatchedDrafts).toEqual([draft]);
    expect(dispatchedDrafts[0]).toContain(citation);
    expect(dispatchedDrafts[0]).not.toContain("<assistant_citations>");
  });

  it("blocks a generated plan follow-up that exceeds the shared limit", () => {
    const onSend = vi.fn();

    const result = submitComposerDraft({
      prompt: "",
      providerInput: `PLEASE IMPLEMENT THIS PLAN:\n${"x".repeat(
        PROVIDER_SEND_TURN_MAX_INPUT_CHARS,
      )}`,
      submissionTarget: "provider-turn",
      event: undefined,
      onSend,
    });

    expect(result.didDispatch).toBe(false);
    expect(result.validationMessage).toContain("over the 120,000-character limit");
    expect(onSend).not.toHaveBeenCalled();
  });

  it("allows surrounding whitespace that the provider turn contract trims", () => {
    const draft = ` ${"x".repeat(PROVIDER_SEND_TURN_MAX_INPUT_CHARS)} `;
    const onSend = vi.fn();
    const preventDefault = vi.fn();

    const result = submitComposerDraft({
      prompt: draft,
      submissionTarget: "provider-turn",
      event: { preventDefault },
      onSend,
    });

    expect(result).toEqual({ validationMessage: null, didDispatch: true });
    expect(onSend).toHaveBeenCalledOnce();
    expect(preventDefault).not.toHaveBeenCalled();
  });

  it("dispatches pending user input answers on their separate response path", () => {
    const answer = "x".repeat(PROVIDER_SEND_TURN_MAX_INPUT_CHARS + 1);
    const onSend = vi.fn();
    const preventDefault = vi.fn();

    const result = submitComposerDraft({
      prompt: answer,
      submissionTarget: "pending-user-input",
      event: { preventDefault },
      onSend,
    });

    expect(result).toEqual({ validationMessage: null, didDispatch: true });
    expect(onSend).toHaveBeenCalledOnce();
    expect(preventDefault).not.toHaveBeenCalled();
  });

  it("does not apply citation-expanded prompt limits to pending user input answers", () => {
    const citation = serializeAssistantCitation(assistantCitation);
    const answer = `${"x".repeat(PROVIDER_SEND_TURN_MAX_INPUT_CHARS - citation.length)}${citation}`;
    const onSend = vi.fn();

    expect(expandAssistantCitationsForProvider(answer).length).toBeGreaterThan(
      PROVIDER_SEND_TURN_MAX_INPUT_CHARS,
    );
    const result = submitComposerDraft({
      prompt: answer,
      submissionTarget: "pending-user-input",
      event: undefined,
      onSend,
    });

    expect(result).toEqual({ validationMessage: null, didDispatch: true });
    expect(onSend).toHaveBeenCalledOnce();
  });
});