import * as NodeAsyncHooks from "node:async_hooks";

import type {
  Contribution,
  PluginDefinition,
  PluginRuntime,
  PluginRuntimeFactory,
  PluginRuntimeSnapshot,
} from "./contract.ts";

type Finalizer = () => void | Promise<void>;

interface PluginInstance {
  readonly definition: PluginDefinition;
  readonly contributions: Map<string, Array<Contribution>>;
  readonly finalizers: Array<Finalizer>;
  activated: boolean;
}

interface Composition {
  readonly instances: ReadonlyArray<PluginInstance>;
  readonly snapshot: PluginRuntimeSnapshot;
}

interface CompositionPlan {
  readonly active: ReadonlyArray<PluginDefinition>;
  readonly blocked: Readonly<Record<string, string>>;
  readonly providers: ReadonlyMap<string, PluginDefinition>;
}

const createSnapshot = (
  instances: ReadonlyArray<PluginInstance>,
  blocked: Readonly<Record<string, string>>,
): PluginRuntimeSnapshot => {
  const contributions: Record<string, Array<Contribution>> = Object.create(null);

  for (const instance of instances) {
    for (const [slot, registrations] of instance.contributions) {
      const items = Object.hasOwn(contributions, slot) ? contributions[slot] : [];
      if (items === undefined) continue;
      items.push(...registrations);
      contributions[slot] = items;
    }
  }

  const frozenContributions: Record<string, ReadonlyArray<Contribution>> = Object.create(null);
  for (const [slot, registrations] of Object.entries(contributions)) {
    frozenContributions[slot] = Object.freeze([...registrations]);
  }

  const frozenBlocked: Record<string, string> = Object.assign(Object.create(null), blocked);

  return Object.freeze({
    active: Object.freeze(instances.map(({ definition }) => definition.id)),
    blocked: Object.freeze(frozenBlocked),
    contributions: Object.freeze(frozenContributions),
  });
};

const emptyComposition = (): Composition => ({
  instances: [],
  snapshot: createSnapshot([], {}),
});

const planComposition = (definitions: ReadonlyArray<PluginDefinition>): CompositionPlan => {
  const byId = new Map<string, PluginDefinition>();
  const providers = new Map<string, PluginDefinition>();

  for (const definition of definitions) {
    if (byId.has(definition.id)) {
      throw new Error(`duplicate plugin id: ${definition.id}`);
    }
    byId.set(definition.id, definition);

    for (const capability of Object.keys(definition.provides ?? {})) {
      const previous = providers.get(capability);
      if (previous !== undefined) {
        throw new Error(`duplicate provider for ${capability}: ${previous.id}, ${definition.id}`);
      }
      providers.set(capability, definition);
    }
  }

  interface VisitFrame {
    readonly definition: PluginDefinition;
    requirementIndex: number;
    reason: string | undefined;
  }

  const states = new Map<string, "visiting" | "visited">();
  const path: Array<string> = [];
  const pathIndexes = new Map<string, number>();
  const active: Array<PluginDefinition> = [];
  const blocked: Record<string, string> = Object.create(null);

  for (const root of definitions) {
    if (states.has(root.id)) continue;

    const stack: Array<VisitFrame> = [{ definition: root, requirementIndex: 0, reason: undefined }];
    states.set(root.id, "visiting");
    pathIndexes.set(root.id, path.length);
    path.push(root.id);

    while (stack.length > 0) {
      const frame = stack.at(-1);
      if (frame === undefined) break;
      const requirements = frame.definition.requires ?? [];
      const capability = requirements[frame.requirementIndex];

      if (capability !== undefined) {
        const provider = providers.get(capability);
        if (provider === undefined) {
          frame.reason ??= `missing dependency: ${capability}`;
          frame.requirementIndex += 1;
          continue;
        }

        const state = states.get(provider.id);
        if (state === "visiting") {
          const cycleStart = pathIndexes.get(provider.id);
          if (cycleStart === undefined) throw new Error(`missing dependency path: ${provider.id}`);
          const cycle = [...path.slice(cycleStart), provider.id];
          throw new Error(`dependency cycle detected: ${cycle.join(" -> ")}`);
        }
        if (state === undefined) {
          stack.push({ definition: provider, requirementIndex: 0, reason: undefined });
          states.set(provider.id, "visiting");
          pathIndexes.set(provider.id, path.length);
          path.push(provider.id);
          continue;
        }

        if (Object.hasOwn(blocked, provider.id)) {
          frame.reason ??= `dependency unavailable: ${capability}`;
        }
        frame.requirementIndex += 1;
        continue;
      }

      stack.pop();
      path.pop();
      pathIndexes.delete(frame.definition.id);
      states.set(frame.definition.id, "visited");
      if (frame.reason === undefined) {
        active.push(frame.definition);
      } else {
        blocked[frame.definition.id] = frame.reason;
      }
    }
  }
  return { active, blocked, providers };
};

const sameDefinitionShape = (previous: PluginDefinition, desired: PluginDefinition) => {
  const previousRequires = [...(previous.requires ?? [])].sort();
  const desiredRequires = [...(desired.requires ?? [])].sort();
  const previousProvidedServices = previous.provides ?? {};
  const desiredProvidedServices = desired.provides ?? {};
  const previousProvides = Object.keys(previousProvidedServices);
  const desiredProvides = Object.keys(desiredProvidedServices);

  return (
    previous.version === desired.version &&
    Object.is(previous.activate, desired.activate) &&
    previousRequires.length === desiredRequires.length &&
    previousRequires.every((capability, index) => capability === desiredRequires[index]) &&
    previousProvides.length === desiredProvides.length &&
    previousProvides.every(
      (capability) =>
        Object.hasOwn(desiredProvidedServices, capability) &&
        Object.is(previousProvidedServices[capability], desiredProvidedServices[capability]),
    )
  );
};

export const createPureRuntime: PluginRuntimeFactory = (options = {}): PluginRuntime => {
  let current = emptyComposition();
  let disposed = false;
  let transition = Promise.resolve();
  const callbackContext = new NodeAsyncHooks.AsyncLocalStorage<{ active: boolean }>();

  const invokePluginCallback = async <Result>(
    invoke: () => Result | PromiseLike<Result>,
    onSettled?: () => void,
  ): Promise<Result> => {
    const callbackState = { active: true };
    let settled = false;
    const settle = () => {
      if (settled) return;
      settled = true;
      callbackState.active = false;
      onSettled?.();
    };
    try {
      const result = callbackContext.run(callbackState, invoke);
      if (typeof result === "object" && result !== null && "then" in result) {
        return await Promise.resolve(result).finally(settle);
      }
      settle();
      return result;
    } catch (error) {
      settle();
      throw error;
    }
  };

  const reportLifecycle = (phase: "activate" | "deactivate", pluginId: string) => {
    try {
      options.onLifecycle?.({ phase, pluginId });
    } catch (error) {
      try {
        options.onLifecycleError?.({ phase, pluginId, error });
      } catch {
        // Lifecycle error reporting must not invalidate a commit or interrupt cleanup.
      }
    }
  };

  const deactivate = async (instance: PluginInstance): Promise<Array<unknown>> => {
    const errors: Array<unknown> = [];

    if (instance.activated) {
      reportLifecycle("deactivate", instance.definition.id);
    }

    for (let index = instance.finalizers.length - 1; index >= 0; index -= 1) {
      const finalizer = instance.finalizers[index];
      if (finalizer === undefined) continue;
      try {
        await invokePluginCallback(finalizer);
      } catch (error) {
        errors.push(error);
      }
    }

    return errors;
  };

  const deactivateAll = async (
    instances: ReadonlyArray<PluginInstance>,
  ): Promise<Array<unknown>> => {
    const errors: Array<unknown> = [];
    for (let index = instances.length - 1; index >= 0; index -= 1) {
      const instance = instances[index];
      if (instance !== undefined) errors.push(...(await deactivate(instance)));
    }
    return errors;
  };

  const reportCleanupErrors = (phase: "retire" | "rollback", errors: ReadonlyArray<unknown>) => {
    for (const error of errors) {
      try {
        options.onCleanupError?.({ phase, error });
      } catch {
        // Cleanup reporting must not replace an activation failure or invalidate a commit.
      }
    }
  };

  const stage = async (
    definitions: ReadonlyArray<PluginDefinition>,
    previous: Composition,
  ): Promise<Composition> => {
    const plan = planComposition(definitions);
    const previousById = new Map(
      previous.instances.map((instance) => [instance.definition.id, instance]),
    );
    const restart = new Set<string>();

    for (const definition of plan.active) {
      const existing = previousById.get(definition.id);
      if (existing === undefined || !sameDefinitionShape(existing.definition, definition)) {
        restart.add(definition.id);
      }
    }

    for (const definition of plan.active) {
      if (
        (definition.requires ?? []).some((capability) => {
          const provider = plan.providers.get(capability);
          return provider !== undefined && restart.has(provider.id);
        })
      ) {
        restart.add(definition.id);
      }
    }

    const services = new Map<string, unknown>();
    const staged: Array<PluginInstance> = [];
    const stagedById = new Map<string, PluginInstance>();

    for (const definition of plan.active) {
      if (restart.has(definition.id)) continue;
      const instance = previousById.get(definition.id);
      if (instance === undefined) {
        throw new Error(`missing reusable plugin instance: ${definition.id}`);
      }
      for (const [capability, service] of Object.entries(instance.definition.provides ?? {})) {
        services.set(capability, service);
      }
    }

    try {
      for (const definition of plan.active) {
        if (!restart.has(definition.id)) continue;

        const instance: PluginInstance = {
          definition,
          contributions: new Map(),
          finalizers: [],
          activated: false,
        };
        staged.push(instance);
        stagedById.set(definition.id, instance);

        let activating = true;
        const assertActivating = () => {
          if (!activating) {
            throw new Error(`activation context for ${definition.id} is no longer active`);
          }
        };

        try {
          await invokePluginCallback(
            () =>
              definition.activate({
                resolve: <Service>(capability: string): Service => {
                  assertActivating();
                  if (!services.has(capability)) {
                    throw new Error(`plugin ${definition.id} could not resolve ${capability}`);
                  }
                  return services.get(capability) as Service;
                },
                register: (slot, contribution) => {
                  assertActivating();
                  const items = instance.contributions.get(slot) ?? [];
                  items.push(Object.freeze({ id: contribution.id, label: contribution.label }));
                  instance.contributions.set(slot, items);
                },
                onDispose: (finalizer) => {
                  assertActivating();
                  instance.finalizers.push(finalizer);
                },
              }),
            () => {
              activating = false;
            },
          );
        } finally {
          activating = false;
        }

        for (const [capability, service] of Object.entries(definition.provides ?? {})) {
          services.set(capability, service);
        }
      }

      const instances = plan.active.map((definition) => {
        const instance = stagedById.get(definition.id) ?? previousById.get(definition.id);
        if (instance === undefined) {
          throw new Error(`missing plugin instance after staging: ${definition.id}`);
        }
        return instance;
      });
      return {
        instances,
        snapshot: createSnapshot(instances, plan.blocked),
      };
    } catch (activationError) {
      const cleanupErrors = await deactivateAll(staged);
      reportCleanupErrors("rollback", cleanupErrors);
      throw activationError;
    }
  };

  const runExclusive = <Result>(operation: () => Promise<Result>): Promise<Result> => {
    if (callbackContext.getStore()?.active === true) {
      return Promise.reject(new Error("reentrant plugin runtime operation"));
    }
    const result = transition.then(operation);
    transition = result.then(
      () => undefined,
      () => undefined,
    );
    return result;
  };

  return {
    reconcile: (definitions) => {
      const desired = [...definitions];
      return runExclusive(async () => {
        if (disposed) throw new Error("plugin runtime is disposed");

        const previous = current;
        const candidate = await stage(desired, previous);
        current = candidate;

        for (const instance of candidate.instances) {
          if (instance.activated) continue;
          instance.activated = true;
          reportLifecycle("activate", instance.definition.id);
        }

        const retained = new Set(candidate.instances);
        const retired = previous.instances.filter((instance) => !retained.has(instance));
        const cleanupErrors = await deactivateAll(retired);
        reportCleanupErrors("retire", cleanupErrors);
        return candidate.snapshot;
      });
    },
    snapshot: () => current.snapshot,
    dispose: () =>
      runExclusive(async () => {
        if (disposed) return;
        disposed = true;

        const previous = current;
        current = emptyComposition();
        const cleanupErrors = await deactivateAll(previous.instances);
        if (cleanupErrors.length > 0) {
          throw new AggregateError(cleanupErrors, "plugin runtime disposal failed");
        }
      }),
  };
};