import { describe, expect, it, vi } from "vitest";
import { clawPackageRemovalRequestSchema } from "./package-remove-contract.js";
import { applyClawPackageRemovalPhase } from "./package-remove-phase.js";
import { digestClawPackageRemovalPlan } from "./package-remove-plan.js";
import {
  planClawPackageRemovals,
  type ClawPackageRemovalDecision,
  type ClawReferencedCleanup,
} from "./package-remove.js";
import type { PersistedClawPackageRef } from "./provenance.js";

const mocks = vi.hoisted(() => ({ local: vi.fn() }));
vi.mock("./package-remove.js", async (original) => ({
  ...(await original<typeof import("./package-remove.js")>()),
  applyClawPackageRemovals: (...args: unknown[]) => mocks.local(...args),
}));
vi.mock("./provenance.js", async (original) => ({
  ...(await original<typeof import("./provenance.js")>()),
  readClawInstallRecord: () => undefined,
}));

function reference(relationship: "managed" | "referenced"): PersistedClawPackageRef {
  return {
    schemaVersion: "openclaw.clawPackageRef.v1",
    agentId: "worker",
    clawName: "worker",
    kind: "plugin",
    source: "clawhub",
    ref: "audit",
    version: "1.0.0",
    integrity: "sha256:audit",
    status: "complete",
    relationship,
    origin: "claw-introduced",
    independentOwner: false,
    installedAtMs: 1,
    updatedAtMs: 1,
  };
}
const application = { operationId: "runtime-removal", generation: 2, pluginIds: ["audit"] };
const uninstalled = {
  kind: "plugin" as const,
  ref: "audit",
  version: "1.0.0",
  action: "uninstalled" as const,
};
const options = {
  agentId: "worker",
  operationId: "deletion-operation",
  assertCurrent: () => undefined,
};

async function decisions(relationship: "managed" | "referenced", cleanup: ClawReferencedCleanup) {
  const ref = reference(relationship);
  return await planClawPackageRemovals({ workspace: "/synthetic-workspace" }, [ref], {
    referencedCleanup: cleanup,
    deps: {
      readPackageRefs: () => [ref],
      resolvePlugin: async () => ({
        status: "found",
        pluginId: "audit",
        installedVersion: "1.0.0",
        record: {
          source: "clawhub",
          integrity: ref.integrity,
          installedAt: "1970-01-01T00:00:00.001Z",
        },
      }),
    },
  });
}

describe("Claw package phase handoff", () => {
  it.each(["retain", "remove-if-unused"] as const)(
    "keeps referenced plugins retained under %s",
    async (mode) => {
      const cleanup = { mode };
      const planned = await decisions("referenced", cleanup);
      expect(planned[0]?.action).toBe("retain");
      const packageGateway = vi.fn();
      mocks.local.mockResolvedValue({ packages: [{ ...uninstalled, action: "retained" }] });
      await applyClawPackageRemovalPhase(planned, {
        ...options,
        referencedCleanup: cleanup,
        packageGateway,
      });
      expect(packageGateway).not.toHaveBeenCalled();
    },
  );

  it.each(["managed", "referenced"] as const)(
    "hands off the canonical %s plugin removal decision without local mutation",
    async (relationship) => {
      mocks.local.mockClear();
      const cleanup: ClawReferencedCleanup =
        relationship === "managed"
          ? { mode: "retain" }
          : { mode: "remove-selected", selected: ["plugin:audit@1.0.0"] };
      const planned = await decisions(relationship, cleanup);
      expect(planned[0]?.action).toBe("uninstall");
      const packageGateway = vi.fn(async (request) => {
        const wireRequest = JSON.stringify(request);
        const received = clawPackageRemovalRequestSchema.parse({
          ...JSON.parse(wireRequest),
          binding: {
            configPath: "/synthetic-config",
            statePath: "/synthetic-state",
            cronStorePath: "/synthetic-cron",
          },
        });
        expect(received.expectedPackagePlanDigest).toBe(
          digestClawPackageRemovalPlan(planned, received.cleanup),
        );
        return { packages: [uninstalled], application };
      });
      expect(
        await applyClawPackageRemovalPhase(planned, {
          ...options,
          referencedCleanup: cleanup,
          packageGateway,
        }),
      ).toEqual({ packages: [uninstalled], application });
      expect(packageGateway).toHaveBeenCalledOnce();
      expect(mocks.local).not.toHaveBeenCalled();
    },
  );

  it("preserves managed-before-referenced ordering for a mixed phase", async () => {
    mocks.local.mockClear();
    const cleanup = { mode: "remove-selected" as const, selected: ["plugin:audit@1.0.0"] };
    const planned = await decisions("referenced", cleanup);
    const skill: ClawPackageRemovalDecision = {
      ...planned[0]!,
      packageRef: { ...reference("managed"), kind: "skill", ref: "triage" },
    };
    const packages = [{ ...uninstalled, kind: "skill" as const, ref: "triage" }, uninstalled];
    const packageGateway = vi.fn(async () => ({ packages, application }));
    expect(
      (
        await applyClawPackageRemovalPhase([...planned, skill], {
          ...options,
          referencedCleanup: cleanup,
          packageGateway,
        })
      ).packages,
    ).toEqual(packages);
    expect(mocks.local).not.toHaveBeenCalled();
  });

  it.each(["transport", "missing outcome", "wrong owner", "missing application"])(
    "rejects %s without retry or local fallback",
    async (failure) => {
      mocks.local.mockClear();
      const cleanup = { mode: "remove-selected" as const, selected: ["plugin:audit@1.0.0"] };
      const planned = await decisions("referenced", cleanup);
      const packageGateway = vi.fn(async () => {
        if (failure === "transport") {
          throw new Error("connection lost");
        }
        return {
          packages:
            failure === "missing outcome"
              ? []
              : [{ ...uninstalled, ref: failure === "wrong owner" ? "other" : "audit" }],
          ...(failure === "missing application" ? {} : { application }),
        };
      });
      await expect(
        applyClawPackageRemovalPhase(planned, {
          ...options,
          referencedCleanup: cleanup,
          packageGateway,
        }),
      ).rejects.toThrow();
      expect(packageGateway).toHaveBeenCalledOnce();
      expect(mocks.local).not.toHaveBeenCalled();
    },
  );
});