import { it } from "@effect/vitest";
import { describe, expect } from "vite-plus/test";
import * as NodeTimersPromises from "node:timers/promises";
import * as Cause from "effect/Cause";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Fiber from "effect/Fiber";
import * as Option from "effect/Option";

import * as PluginRuntime from "../src/runtime.ts";
import type { PluginDefinition, PluginRuntimeSnapshot } from "../src/contract.ts";

describe("plugin runtime live contributions", () => {
  it.effect("invokes the handler from the listed committed generation", () =>
    Effect.scoped(
      Effect.gen(function* () {
        const runtime = yield* PluginRuntime.make();
        yield* runtime.reconcile([
          {
            id: "acme.commands",
            version: "1.0.0",
            activate(context) {
              context.register(
                "commands",
                {
                  id: "acme.hello",
                  label: "Say hello",
                  data: { surfaces: ["web", "desktop", "mobile"] },
                },
                (name: string) => Effect.succeed(`hello ${name}`),
              );
            },
          },
        ]);

        const catalog = yield* runtime.contributions("commands");
        expect(catalog.generation).toBe(1);
        expect(catalog.entries).toEqual([
          {
            id: "acme.hello",
            label: "Say hello",
            data: { surfaces: ["web", "desktop", "mobile"] },
          },
        ]);
        expect(Object.isFrozen(catalog.entries[0]?.data)).toBe(true);

        const greeting = yield* runtime.useContribution(
          "commands",
          "acme.hello",
          catalog.generation,
          (handler: (name: string) => Effect.Effect<string>) => handler("t3"),
        );
        expect(greeting).toBe("hello t3");
      }),
    ),
  );

  it.effect("rejects invocation from a stale catalog generation", () =>
    Effect.scoped(
      Effect.gen(function* () {
        const runtime = yield* PluginRuntime.make();
        const definition = (version: string) => ({
          id: "acme.commands",
          version,
          activate(
            context: Parameters<Parameters<typeof runtime.reconcile>[0][number]["activate"]>[0],
          ) {
            context.register("commands", { id: "acme.hello", label: `Say hello ${version}` }, () =>
              Effect.succeed(version),
            );
          },
        });

        yield* runtime.reconcile([definition("1.0.0")]);
        const firstCatalog = yield* runtime.contributions("commands");
        yield* runtime.reconcile([definition("2.0.0")]);

        const staleExit = yield* Effect.exit(
          runtime.useContribution(
            "commands",
            "acme.hello",
            firstCatalog.generation,
            (handler: () => Effect.Effect<string>) => handler(),
          ),
        );
        expect(Exit.isFailure(staleExit)).toBe(true);
        if (Exit.isFailure(staleExit)) {
          expect(Cause.squash(staleExit.cause)).toMatchObject({
            _tag: "PluginContributionGenerationError",
            actual: 2,
            expected: 1,
          });
        }
      }),
    ),
  );

  it.effect("rejects duplicate contribution ids before publishing", () =>
    Effect.scoped(
      Effect.gen(function* () {
        const runtime = yield* PluginRuntime.make();
        const plugin = (id: string, label: string) => ({
          id,
          version: "1.0.0",
          activate(
            context: Parameters<Parameters<typeof runtime.reconcile>[0][number]["activate"]>[0],
          ) {
            context.register("commands", { id: "acme.duplicate", label }, () => Effect.void);
          },
        });

        const reconcileExit = yield* Effect.exit(
          runtime.reconcile([
            plugin("acme.first", "First command"),
            plugin("acme.second", "Second command"),
          ]),
        );
        expect(Exit.isFailure(reconcileExit)).toBe(true);
        if (Exit.isFailure(reconcileExit)) {
          expect(Cause.squash(reconcileExit.cause)).toMatchObject({
            _tag: "PluginDuplicateContributionError",
            id: "acme.duplicate",
            slot: "commands",
          });
        }
        expect((yield* runtime.contributions("commands")).entries).toEqual([]);
      }),
    ),
  );

  it.effect("rejects runtime reentrancy from a contribution handler", () =>
    Effect.gen(function* () {
      const runtime = yield* PluginRuntime.make();
      const definition: PluginDefinition = {
        id: "acme.commands",
        version: "1.0.0",
        activate(context) {
          context.register("commands", { id: "status", label: "Status" }, () =>
            runtime.reconcile([]),
          );
        },
      };
      yield* runtime.reconcile([definition]);
      const catalog = yield* runtime.contributions("commands");

      const result = yield* runtime
        .useContribution<
          () => ReturnType<typeof runtime.reconcile>,
          PluginRuntimeSnapshot,
          PluginRuntime.PluginRuntimeReconcileError,
          never
        >("commands", "status", catalog.generation, (handler) => handler())
        .pipe(Effect.exit, Effect.timeoutOption(Duration.millis(100)));

      expect(Option.isSome(result)).toBe(true);
      if (Option.isSome(result) && Exit.isFailure(result.value)) {
        const error = Cause.squash(result.value.cause);
        expect(error).toMatchObject({
          _tag: "PluginRuntimeReentrancyError",
          callback: "contribution",
          operation: "reconcile",
        });
      }
    }),
  );

  it.effect("rejects contribution reentrancy through a fresh effect runtime", () =>
    Effect.gen(function* () {
      const runtime = yield* PluginRuntime.make();
      const definition: PluginDefinition = {
        id: "acme.commands",
        version: "1.0.0",
        activate(context) {
          context.register(
            "commands",
            { id: "status", label: "Status" },
            Effect.promise(async () => {
              // oxlint-disable-next-line t3code/no-manual-effect-runtime-in-tests -- the regression is specifically a fresh-runtime bridge from plugin code
              const nested = Effect.runPromiseExit(runtime.reconcile([])).then((exit) => ({
                exit,
                kind: "nested" as const,
              }));
              const timeout = NodeTimersPromises.setTimeout(50, { kind: "timeout" as const });
              return Promise.race([nested, timeout]);
            }),
          );
        },
      };
      yield* runtime.reconcile([definition]);
      const catalog = yield* runtime.contributions("commands");

      const result = yield* runtime.useContribution(
        "commands",
        "status",
        catalog.generation,
        (
          handler: Effect.Effect<
            | { readonly kind: "timeout" }
            | {
                readonly exit: Exit.Exit<
                  PluginRuntimeSnapshot,
                  PluginRuntime.PluginRuntimeReconcileError
                >;
                readonly kind: "nested";
              }
          >,
        ) => handler,
      );

      expect(result.kind).toBe("nested");
      if (result.kind === "nested") {
        expect(Exit.isFailure(result.exit)).toBe(true);
        if (Exit.isFailure(result.exit)) {
          expect(Cause.squash(result.exit.cause)).toMatchObject({
            _tag: "PluginRuntimeReentrancyError",
            callback: "contribution",
            operation: "reconcile",
          });
        }
      }
    }),
  );

  it.effect("installs contribution context before calling the host consumer", () =>
    Effect.gen(function* () {
      const runtime = yield* PluginRuntime.make();
      const definition: PluginDefinition = {
        id: "acme.commands",
        version: "1.0.0",
        activate(context) {
          context.register("commands", { id: "status", label: "Status" }, Effect.void);
        },
      };
      yield* runtime.reconcile([definition]);
      const catalog = yield* runtime.contributions("commands");

      const result = yield* runtime.useContribution(
        "commands",
        "status",
        catalog.generation,
        () => {
          // oxlint-disable-next-line t3code/no-manual-effect-runtime-in-tests -- verifies context before the host callback returns its Effect
          const nested = Effect.runPromiseExit(runtime.reconcile([])).then((exit) => ({
            exit,
            kind: "nested" as const,
          }));
          const timeout = NodeTimersPromises.setTimeout(50, { kind: "timeout" as const });
          return Effect.promise(() => Promise.race([nested, timeout]));
        },
      );

      expect(result.kind).toBe("nested");
      if (result.kind === "nested") {
        expect(Exit.isFailure(result.exit)).toBe(true);
        if (Exit.isFailure(result.exit)) {
          expect(Cause.squash(result.exit.cause)).toMatchObject({
            _tag: "PluginRuntimeReentrancyError",
            callback: "contribution",
            operation: "reconcile",
          });
        }
      }
    }),
  );

  it.effect("keeps interrupted asynchronous contribution descendants reentrancy guarded", () =>
    Effect.gen(function* () {
      const runtime = yield* PluginRuntime.make();
      let markStarted!: () => void;
      let releaseHandler!: () => void;
      let resolveNested!: (
        exit: Exit.Exit<PluginRuntimeSnapshot, PluginRuntime.PluginRuntimeReconcileError>,
      ) => void;
      const started = new Promise<void>((resolve) => {
        markStarted = resolve;
      });
      const handlerGate = new Promise<void>((resolve) => {
        releaseHandler = resolve;
      });
      const nestedResult = new Promise<
        Exit.Exit<PluginRuntimeSnapshot, PluginRuntime.PluginRuntimeReconcileError>
      >((resolve) => {
        resolveNested = resolve;
      });
      const definition: PluginDefinition = {
        id: "acme.commands",
        version: "1.0.0",
        activate(context) {
          context.register(
            "commands",
            { id: "status", label: "Status" },
            Effect.promise(async () => {
              markStarted();
              await handlerGate;
              // oxlint-disable-next-line t3code/no-manual-effect-runtime-in-tests -- verifies an interrupted native promise descendant cannot reenter
              resolveNested(await Effect.runPromiseExit(runtime.reconcile([])));
            }),
          );
        },
      };
      yield* runtime.reconcile([definition]);
      const catalog = yield* runtime.contributions("commands");
      const invocation = yield* Effect.forkChild(
        runtime.useContribution(
          "commands",
          "status",
          catalog.generation,
          (handler: Effect.Effect<void>) => handler,
        ),
      );
      yield* Effect.promise(() => started);
      yield* Fiber.interrupt(invocation);
      releaseHandler();
      const nestedExit = yield* Effect.promise(() => nestedResult);

      expect(Exit.isFailure(nestedExit)).toBe(true);
      if (Exit.isFailure(nestedExit)) {
        expect(Cause.squash(nestedExit.cause)).toMatchObject({
          _tag: "PluginRuntimeReentrancyError",
          callback: "contribution",
          operation: "reconcile",
        });
      }
      expect((yield* runtime.contributions("commands")).generation).toBe(catalog.generation);
    }),
  );

  it.effect("keeps the contribution generation stable for an unchanged composition", () =>
    Effect.gen(function* () {
      const runtime = yield* PluginRuntime.make();
      const definition: PluginDefinition = {
        id: "acme.commands",
        version: "1.0.0",
        activate(context) {
          context.register("commands", { id: "status", label: "Status" }, Effect.void);
        },
      };

      yield* runtime.reconcile([definition]);
      const first = yield* runtime.contributions("commands");
      yield* runtime.reconcile([definition]);
      const second = yield* runtime.contributions("commands");

      expect(second.generation).toBe(first.generation);
      expect(second.entries).toEqual(first.entries);
    }),
  );

  it.effect("rejects non-declarative contribution data without replacing the composition", () =>
    Effect.gen(function* () {
      const runtime = yield* PluginRuntime.make();
      const stable: PluginDefinition = {
        id: "acme.commands",
        version: "1.0.0",
        activate(context) {
          context.register("commands", { id: "status", label: "Status" }, Effect.void);
        },
      };
      yield* runtime.reconcile([stable]);
      const committed = yield* runtime.contributions("commands");
      const circular: { self?: unknown } = {};
      circular.self = circular;
      const invalidValues: ReadonlyArray<unknown> = [
        circular,
        new Map([["status", true]]),
        new Uint8Array([1]),
      ];

      for (const [index, data] of invalidValues.entries()) {
        const failed = yield* Effect.exit(
          runtime.reconcile([
            {
              id: "acme.commands",
              version: `2.0.${index}`,
              activate(context) {
                context.register("commands", {
                  id: "status",
                  label: "Status",
                  data: data as never,
                });
              },
            },
          ]),
        );
        expect(Exit.isFailure(failed)).toBe(true);
        if (Exit.isFailure(failed)) {
          expect(Cause.squash(failed.cause)).toMatchObject({ _tag: "PluginCallbackError" });
        }
        expect((yield* runtime.contributions("commands")).generation).toBe(committed.generation);
      }
    }),
  );

  it.effect("uses detached metadata as the default live contribution value", () =>
    Effect.gen(function* () {
      const runtime = yield* PluginRuntime.make();
      const contribution = { id: "status", label: "Status", data: { source: "original" } };
      const definition: PluginDefinition = {
        id: "acme.commands",
        version: "1.0.0",
        activate(context) {
          context.register("commands", contribution);
        },
      };

      yield* runtime.reconcile([definition]);
      const catalog = yield* runtime.contributions("commands");
      contribution.id = "mutated";
      contribution.label = "Mutated";
      contribution.data.source = "mutated";
      const used = yield* runtime.useContribution(
        "commands",
        "status",
        catalog.generation,
        (value: typeof contribution) => Effect.succeed(value),
      );

      expect(used).toEqual({ id: "status", label: "Status", data: { source: "original" } });
      expect(Object.isFrozen(used)).toBe(true);
      expect(Object.isFrozen(used.data)).toBe(true);
    }),
  );

  it.effect("preserves an explicitly undefined live contribution value", () =>
    Effect.gen(function* () {
      const runtime = yield* PluginRuntime.make();
      const definition: PluginDefinition = {
        id: "acme.commands",
        version: "1.0.0",
        activate(context) {
          context.register("commands", { id: "status", label: "Status" }, undefined);
        },
      };

      yield* runtime.reconcile([definition]);
      const catalog = yield* runtime.contributions("commands");
      const isUndefined = yield* runtime.useContribution(
        "commands",
        "status",
        catalog.generation,
        (value: undefined) => Effect.succeed(value === undefined),
      );

      expect(isUndefined).toBe(true);
    }),
  );
});