import type * as Effect from "effect/Effect";
import type { DomainRecord } from "../control-plane/domain-metadata.ts";
import type { RegistryFailure } from "../control-plane/installation-errors.ts";
import type { Installation } from "../control-plane/installation-metadata.ts";
import type {
  InstallationRegistry,
  InstallationPage,
  InstallationState,
} from "../control-plane/installation-registry.ts";
import type { InstallationOperation } from "../control-plane/operation.ts";
import type {
  installationRegistry,
  InstallationRegistryClient,
} from "../control-plane/registry-client.ts";

type Equal<A, B> =
  (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2
    ? true
    : false;
type Assert<T extends true> = T;

interface Successes {
  reserve: Installation;
  get: Installation | null;
  getDomain: DomainRecord | null;
  domainReplay: string | null;
  startDomain: DomainRecord;
  updateDomain: DomainRecord;
  list: InstallationPage;
  start: InstallationState;
  replay: Installation | null;
  operation: InstallationOperation | null;
  active: InstallationState;
  intent: InstallationOperation;
  update: Installation;
}

// Assert against application models, independently of the client's mapped type.
type Client = ReturnType<typeof installationRegistry>;
type ClientContract = Assert<Equal<Client, InstallationRegistryClient>>;
type MethodNames = Assert<Equal<keyof Client, keyof Successes>>;
type Results = Assert<
  Equal<
    {
      [K in keyof Successes]: Effect.Success<ReturnType<Client[K]>>;
    },
    Successes
  >
>;
type Failures = Assert<
  Equal<
    {
      [K in keyof Successes]: Effect.Error<ReturnType<Client[K]>>;
    },
    { [K in keyof Successes]: RegistryFailure }
  >
>;
type Requirements = Assert<
  Equal<
    {
      [K in keyof Successes]: Effect.Services<ReturnType<Client[K]>>;
    },
    { [K in keyof Successes]: never }
  >
>;
type Arguments = Assert<
  Equal<
    {
      [K in keyof Successes]: Parameters<Client[K]>;
    },
    { [K in keyof Successes]: Parameters<InstallationRegistry[K]> }
  >
>;

// Exercise real Wrangler/Workers RPC types, not a Promise-only mock.
type NativeGet = ReturnType<DurableObjectStub<InstallationRegistry>["get"]>;
type NativeEnvelopeIsDisposable = Assert<
  Awaited<NativeGet> extends Disposable ? true : false
>;
type NativeEnvelopeIsPipelined = Assert<
  NativeGet["ok"] extends PromiseLike<boolean> ? true : false
>;

declare const client: Client;
declare const installation: Effect.Success<ReturnType<Client["get"]>>;
if (installation) {
  const owner: string = installation.ownerSubject;
  const resources: Installation["resources"] = installation.resources;
  // @ts-expect-error Application values do not expose RPC pipelining.
  installation.ownerSubject.then;
  // @ts-expect-error RPC disposal belongs to the transport envelope.
  installation[Symbol.dispose];
  void owner;
  void resources;
}
// @ts-expect-error Updates require a revision; optional arguments stay optional elsewhere.
client.update("owner", "id", {});
client.list("owner");