import * as Cause from "effect/Cause";
import { AsyncResult } from "effect/unstable/reactivity";
import { act, StrictMode, type ReactNode } from "react";
import { create, type ReactTestRenderer } from "react-test-renderer";
import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";

vi.mock("./ui/dialog", () => ({
  Dialog: ({ open, children }: { open: boolean; children: ReactNode }) => (open ? children : null),
  DialogDescription: "p",
  DialogFooter: "footer",
  DialogHeader: "header",
  DialogPanel: "section",
  DialogPopup: "section",
  DialogTitle: "h2",
}));
vi.mock("./ui/alert-dialog", () => ({
  AlertDialog: ({ open, children }: { open: boolean; children: ReactNode }) =>
    open ? children : null,
  AlertDialogClose: "button",
  AlertDialogDescription: "p",
  AlertDialogFooter: "footer",
  AlertDialogHeader: "header",
  AlertDialogPopup: "section",
  AlertDialogTitle: "h2",
}));
vi.mock("./ui/button", () => ({ Button: "button" }));
vi.mock("./ui/input", () => ({ Input: "input" }));
vi.mock("./ui/label", () => ({ Label: "label" }));
vi.mock("./ui/popover", () => ({
  Popover: ({ children }: { children: ReactNode }) => children,
  PopoverPopup: () => null,
  PopoverTrigger: "button",
}));
vi.mock("./ui/switch", () => ({ Switch: "input" }));
vi.mock("./ui/textarea", () => ({ Textarea: "textarea" }));

import {
  EMPTY_PROJECT_SCRIPT_INPUT,
  ProjectScriptEditorDialog,
  type ProjectScriptActionResult,
  type ProjectScriptEditorRequest,
} from "./projectScriptEditor";

const onSubmit = vi.fn<Parameters<typeof ProjectScriptEditorDialog>[0]["onSubmit"]>();
const onClose = vi.fn();
const onDelete = vi.fn();
let renderer: ReactTestRenderer | null;

function request(name: string, error?: string): ProjectScriptEditorRequest {
  return {
    scriptId: name,
    initial: { ...EMPTY_PROJECT_SCRIPT_INPUT, name, command: `run-${name}` },
    ...(error === undefined ? {} : { error }),
  };
}

function editor(nextRequest: ProjectScriptEditorRequest) {
  return (
    <StrictMode>
      <ProjectScriptEditorDialog
        request={nextRequest}
        scripts={[]}
        onSubmit={onSubmit}
        onClose={onClose}
        onDelete={onDelete}
      />
    </StrictMode>
  );
}

function open(nextRequest: ProjectScriptEditorRequest) {
  act(() => {
    if (renderer) renderer.update(editor(nextRequest));
    else renderer = create(editor(nextRequest));
  });
}

function submit(): Promise<void> {
  return renderer!.root.findByType("form").props.onSubmit({ preventDefault() {} });
}

function saveButton() {
  return renderer!.root.findAllByType("button").find((button) => button.props.type === "submit")!;
}

function deferredSave() {
  let resolve!: (result: ProjectScriptActionResult) => void;
  let reject!: (error: Error) => void;
  const promise = new Promise<ProjectScriptActionResult>((resolveResult, rejectResult) => {
    resolve = resolveResult;
    reject = rejectResult;
  });
  return { promise, resolve, reject };
}

beforeEach(() => {
  renderer = null;
  vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
  onSubmit.mockReset();
  onClose.mockReset();
  onDelete.mockReset();
});

afterEach(async () => {
  await act(async () => renderer?.unmount());
  vi.unstubAllGlobals();
});

describe("project action editor save lifecycle", () => {
  it("blocks repeated submits and edits until the current save completes", async () => {
    const save = deferredSave();
    onSubmit.mockReturnValue(save.promise);
    open(request("build"));

    let completion!: Promise<void>;
    act(() => {
      completion = submit();
      void submit();
    });

    expect(onSubmit).toHaveBeenCalledTimes(1);
    expect(saveButton().props.disabled).toBe(true);
    expect(renderer!.root.findByType("fieldset").props.disabled).toBe(true);
    const cancel = renderer!.root
      .findAllByType("button")
      .find((button) => button.children.includes("Cancel"))!;
    expect(cancel.props.disabled).not.toBe(true);

    await act(async () => {
      save.resolve(AsyncResult.success(undefined));
      await completion;
    });
    expect(onClose).toHaveBeenCalledTimes(1);
  });

  it("does not close a replacement request or release its in-flight save", async () => {
    const first = deferredSave();
    const second = deferredSave();
    onSubmit.mockReturnValueOnce(first.promise).mockReturnValueOnce(second.promise);
    open(request("build"));
    let firstCompletion!: Promise<void>;
    act(() => {
      firstCompletion = submit();
    });

    open(request("test"));
    expect(saveButton().props.disabled).toBe(false);
    expect(renderer!.root.findByProps({ id: "script-name" }).props.value).toBe("test");
    let secondCompletion!: Promise<void>;
    act(() => {
      secondCompletion = submit();
    });

    await act(async () => {
      first.resolve(AsyncResult.success(undefined));
      await firstCompletion;
    });
    expect(onClose).not.toHaveBeenCalled();
    expect(saveButton().props.disabled).toBe(true);

    await act(async () => {
      second.resolve(AsyncResult.success(undefined));
      await secondCompletion;
    });
    expect(onClose).toHaveBeenCalledTimes(1);
    expect(onSubmit.mock.calls.map(([scriptId]) => scriptId)).toEqual(["build", "test"]);
  });

  it.each(["failure", "rejection"] as const)(
    "ignores a stale %s after the request changes",
    async (outcome) => {
      const save = deferredSave();
      onSubmit.mockReturnValue(save.promise);
      open(request("build"));
      let completion!: Promise<void>;
      act(() => {
        completion = submit();
      });

      open(request("test", "New request error"));
      await act(async () => {
        if (outcome === "failure")
          save.resolve(AsyncResult.failure(Cause.fail(new Error("Old save error"))));
        else save.reject(new Error("Old save error"));
        await completion;
      });

      const messages = renderer!.root.findAllByType("p").flatMap((paragraph) => paragraph.children);
      expect(messages).toContain("New request error");
      expect(messages).not.toContain("Old save error");
      expect(saveButton().props.disabled).toBe(false);
      expect(onClose).not.toHaveBeenCalled();
    },
  );

  it("shows a current save error and allows retry", async () => {
    onSubmit.mockResolvedValueOnce(AsyncResult.failure(Cause.fail(new Error("Save failed"))));
    onSubmit.mockResolvedValueOnce(AsyncResult.success(undefined));
    open(request("build"));

    await act(async () => {
      await submit();
    });
    expect(renderer!.root.findAllByType("p").flatMap((paragraph) => paragraph.children)).toContain(
      "Save failed",
    );
    expect(saveButton().props.disabled).toBe(false);
    expect(renderer!.root.findByType("fieldset").props.disabled).toBe(false);
    expect(onClose).not.toHaveBeenCalled();

    await act(async () => {
      await submit();
    });
    expect(onSubmit).toHaveBeenCalledTimes(2);
    expect(onClose).toHaveBeenCalledTimes(1);
  });

  it.each(["cancel", "unmount"] as const)("ignores save completion after %s", async (exit) => {
    const save = deferredSave();
    onSubmit.mockReturnValue(save.promise);
    open(request("build"));
    let completion!: Promise<void>;
    act(() => {
      completion = submit();
    });

    act(() => {
      if (exit === "cancel") {
        renderer!.root
          .findAllByType("button")
          .find((button) => button.children.includes("Cancel"))!
          .props.onClick();
      } else {
        renderer!.unmount();
        renderer = null;
      }
    });
    onClose.mockClear();
    await act(async () => {
      save.resolve(AsyncResult.success(undefined));
      await completion;
    });
    expect(onClose).not.toHaveBeenCalled();
  });
});