import {
  deleteDaytonaSandboxByIdWithOutcome,
  readDetachedDaytonaRuntimeCompletion,
} from './backends/daytona';
import {
  deleteModalSandboxById,
  readDetachedModalRuntimeCompletion,
} from './backends/modal';
import type { DetachedRunnerSuspension } from '@shared_libs/play-runtime/suspension';

export type RuntimeSandboxProviderId = 'daytona' | 'modal';

export type RuntimeSandboxRef = {
  schemaVersion: 1;
  provider: RuntimeSandboxProviderId;
  resourceId: string;
  routingDomain: string | null;
};

export type RuntimeSandboxReconciliationAdapter = {
  provider: RuntimeSandboxProviderId;
  delete(ref: RuntimeSandboxRef): Promise<RuntimeSandboxDeleteOutcome>;
  readWorkCompletedAt(
    ref: RuntimeSandboxRef,
    path: string,
  ): Promise<number | null>;
};

export type RuntimeSandboxReconciliation = {
  delete(ref: RuntimeSandboxRef): Promise<RuntimeSandboxDeleteOutcome>;
  readWorkCompletedAt(
    ref: RuntimeSandboxRef,
    path: string,
  ): Promise<number | null>;
};

export type RuntimeSandboxDeleteOutcome =
  | {
      kind: 'deleted' | 'already_absent';
      routingDomain: string | null;
    }
  | {
      kind: 'timed_out' | 'rate_limited' | 'failed';
      routingDomain: string | null;
      code: string;
      detail: string;
    };

export function runtimeSandboxDeleteSucceeded(
  outcome: RuntimeSandboxDeleteOutcome,
): outcome is Extract<
  RuntimeSandboxDeleteOutcome,
  { kind: 'deleted' | 'already_absent' }
> {
  return outcome.kind === 'deleted' || outcome.kind === 'already_absent';
}

/** Stable identity for deduplication and task idempotency at provider seams. */
export function runtimeSandboxRefIdentityKey(ref: RuntimeSandboxRef): string {
  return JSON.stringify([ref.provider, ref.resourceId, ref.routingDomain]);
}

function registry(
  adapters: readonly RuntimeSandboxReconciliationAdapter[],
): Map<RuntimeSandboxProviderId, RuntimeSandboxReconciliationAdapter> {
  const result = new Map<
    RuntimeSandboxProviderId,
    RuntimeSandboxReconciliationAdapter
  >();
  for (const adapter of adapters) {
    if (result.has(adapter.provider)) {
      throw new Error(
        `Duplicate Runtime Sandbox Adapter: ${adapter.provider}.`,
      );
    }
    result.set(adapter.provider, adapter);
  }
  return result;
}

export function createRuntimeSandboxReconciliation(input: {
  adapters: readonly RuntimeSandboxReconciliationAdapter[];
}): RuntimeSandboxReconciliation {
  const adapters = registry(input.adapters);
  const resolve = (ref: RuntimeSandboxRef) => {
    const adapter = adapters.get(ref.provider);
    if (!adapter) {
      throw new Error(
        `No Runtime Sandbox Adapter is registered for ${ref.provider}.`,
      );
    }
    return adapter;
  };
  return {
    delete: (ref) => resolve(ref).delete(ref),
    readWorkCompletedAt: (ref, path) =>
      resolve(ref).readWorkCompletedAt(ref, path),
  };
}

export function runtimeSandboxRefFromResource(
  value: unknown,
): RuntimeSandboxRef | null {
  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
  const resource = value as Record<string, unknown>;
  const resourceId =
    typeof resource.sandboxId === 'string' ? resource.sandboxId.trim() : '';
  if (!resourceId) return null;
  if (resource.kind === 'daytona_sandbox') {
    return {
      schemaVersion: 1,
      provider: 'daytona',
      resourceId,
      routingDomain:
        typeof resource.daytonaOrganizationId === 'string' &&
        resource.daytonaOrganizationId.trim()
          ? resource.daytonaOrganizationId.trim()
          : null,
    };
  }
  if (resource.kind === 'modal_sandbox') {
    return {
      schemaVersion: 1,
      provider: 'modal',
      resourceId,
      routingDomain:
        typeof resource.modalAppId === 'string' && resource.modalAppId.trim()
          ? resource.modalAppId.trim()
          : null,
    };
  }
  return null;
}

export function runtimeSandboxRefFromSuspension(
  suspension: DetachedRunnerSuspension,
): RuntimeSandboxRef {
  const storedRef = (suspension as { runtimeSandboxRef?: unknown })
    .runtimeSandboxRef;
  if (storedRef !== undefined) {
    if (
      !storedRef ||
      typeof storedRef !== 'object' ||
      Array.isArray(storedRef)
    ) {
      throw new Error('Persisted Runtime Sandbox Ref is not an object.');
    }
    const candidate = storedRef as Record<string, unknown>;
    const resourceId =
      typeof candidate.resourceId === 'string'
        ? candidate.resourceId.trim()
        : '';
    const provider = candidate.provider;
    const routingDomain = candidate.routingDomain;
    if (
      candidate.schemaVersion !== 1 ||
      (provider !== 'daytona' && provider !== 'modal') ||
      !resourceId ||
      resourceId !== suspension.sandboxId.trim() ||
      (routingDomain !== null && typeof routingDomain !== 'string') ||
      (typeof routingDomain === 'string' && !routingDomain.trim()) ||
      (suspension.sandboxProvider !== undefined &&
        suspension.sandboxProvider !== provider)
    ) {
      throw new Error(
        `Persisted Runtime Sandbox Ref is invalid or inconsistent for sandbox ${suspension.sandboxId}.`,
      );
    }
    return {
      schemaVersion: 1,
      provider,
      resourceId,
      routingDomain:
        typeof routingDomain === 'string' ? routingDomain.trim() : null,
    };
  }
  if (
    suspension.sandboxProvider !== undefined &&
    suspension.sandboxProvider !== 'daytona' &&
    suspension.sandboxProvider !== 'modal'
  ) {
    throw new Error(
      `Legacy detached runner has unsupported sandbox provider ${String(suspension.sandboxProvider)}.`,
    );
  }
  return {
    schemaVersion: 1,
    provider: suspension.sandboxProvider === 'modal' ? 'modal' : 'daytona',
    resourceId: suspension.sandboxId,
    // Legacy suspensions never persisted ownership. Cleanup still uses the
    // provider-scoped credential; resource-backed cleanup carries the domain.
    routingDomain: null,
  };
}

export const defaultRuntimeSandboxReconciliation =
  createRuntimeSandboxReconciliation({
    adapters: [
      {
        provider: 'daytona',
        delete: async (ref) => {
          const outcome = await deleteDaytonaSandboxByIdWithOutcome({
            sandboxId: ref.resourceId,
            timeoutSeconds: 30,
            expectedOrganizationId: ref.routingDomain,
            allowUnscopedAlreadyAbsent: ref.routingDomain === null,
          });
          return {
            ...outcome,
            routingDomain: outcome.organizationId,
          };
        },
        readWorkCompletedAt: (ref, path) =>
          readDetachedDaytonaRuntimeCompletion({
            sandboxId: ref.resourceId,
            runtimeCompletedPath: path,
            expectedOrganizationId: ref.routingDomain,
          }),
      },
      {
        provider: 'modal',
        delete: async (ref) => {
          const outcome = await deleteModalSandboxById({
            sandboxId: ref.resourceId,
            expectedAppId: ref.routingDomain,
          });
          return {
            ...outcome,
            routingDomain: outcome.appId,
          };
        },
        readWorkCompletedAt: (ref, path) =>
          readDetachedModalRuntimeCompletion({
            sandboxId: ref.resourceId,
            runtimeCompletedPath: path,
            expectedAppId: ref.routingDomain,
          }),
      },
    ],
  });