import type { AppEnvironmentId } from '../environments';
import type { INFRA_ADAPTER_CATALOG } from '../infra/constants';
import type {
  InfraDestroyRequest,
  InfraGeneratedArtifact,
  InfraLedger,
  InfraOutput,
  InfraOwnedResource,
  InfraPlanAction,
  InfraResourceStatus,
  InfraResult,
} from './infraLifecycle';
import type {
  InfraAdapterId,
  InfraComputeProviderId,
  InfraComputeSelection,
  InfraEnvironmentSpec,
  InfraRuntimeProviderId,
  InfraRuntimeSelection,
} from './infraManifest';
import type { InfraControlPlaneCredentialRef, InfraSecretReference } from './infraSecrets';
import type { InfraComputeTarget } from './infraTargets';
import type { InfraWorkloadSpec } from './infraWorkload';

/** Package exports must match this exact catalog entry; optional operations are advertised explicitly. */
export type InfraAdapterDescriptor<P extends InfraAdapterId = InfraAdapterId> = {
  [K in P]: (typeof INFRA_ADAPTER_CATALOG)[K] & {
    readonly operations?: readonly ('suspend' | 'resume' | 'generate' | 'diagnostics')[];
  };
}[P];

/** Trusted execution-only control-plane credential lookup, resolution and persistence. */
export interface InfraCredentialPort {
  /** Return a credential bundle when present; absence is not an error. */
  findAsync(
    reference: InfraControlPlaneCredentialRef,
  ): Promise<InfraResult<Readonly<Record<string, string>> | null>>;
  /** Resolve a required credential bundle; absence is an error. */
  resolveAsync(
    reference: InfraControlPlaneCredentialRef,
  ): Promise<InfraResult<Readonly<Record<string, string>>>>;
  /** Persist an opaque provider-owned credential bundle without exposing its schema to the host. */
  persistAsync(
    reference: InfraControlPlaneCredentialRef,
    values: Readonly<Record<string, string>>,
  ): Promise<InfraResult<null>>;
}

/** Trusted execution-only ports. Implementations must not serialize resolved credential values. */
export interface InfraExecutionContext {
  readonly projectId: string;
  readonly environment: AppEnvironmentId;
  readonly desired: InfraEnvironmentSpec;
  readonly previous?: InfraLedger;
  readonly signal?: AbortSignal;
  readonly credentials: InfraCredentialPort;
  readonly secrets: {
    resolveAsync(reference: InfraSecretReference): Promise<InfraResult<string>>;
  };
}

export interface InfraReconcileResult {
  readonly resources: readonly InfraOwnedResource[];
  readonly outputs: readonly InfraOutput[];
}

/** Current portable compute state resolved without creating, updating or deleting resources. */
export interface InfraComputeSnapshot extends InfraReconcileResult {
  readonly targets: readonly InfraComputeTarget[];
}

export interface InfraComputeAdapter<P extends InfraComputeProviderId = InfraComputeProviderId> {
  readonly descriptor: InfraAdapterDescriptor<P>;
  /** Read-only prerequisites, config and control-plane credential validation. */
  validateAsync(
    context: InfraExecutionContext,
    selection: InfraComputeSelection<P>,
  ): Promise<InfraResult<null>>;
  /** Read-only discovery for planning and stateless runtime projection. Missing compute is empty. */
  inspectAsync(
    context: InfraExecutionContext,
    selection: InfraComputeSelection<P>,
  ): Promise<InfraResult<InfraComputeSnapshot>>;
  planAsync(
    context: InfraExecutionContext,
    selection: InfraComputeSelection<P>,
  ): Promise<InfraResult<readonly InfraPlanAction[]>>;
  ensureAsync(
    context: InfraExecutionContext,
    selection: InfraComputeSelection<P>,
  ): Promise<InfraResult<InfraComputeSnapshot>>;
  statusAsync(context: InfraExecutionContext): Promise<InfraResult<readonly InfraResourceStatus[]>>;
  destroyAsync(
    context: InfraExecutionContext,
    request: InfraDestroyRequest,
  ): Promise<InfraResult<InfraReconcileResult>>;
}

export interface InfraRuntimeDesiredState<
  P extends InfraRuntimeProviderId = InfraRuntimeProviderId,
> {
  readonly selection: InfraRuntimeSelection<P>;
  readonly targets: readonly InfraComputeTarget[];
  readonly workloads: readonly InfraWorkloadSpec[];
  /** Previously resolved outputs available to portable workload value references. */
  readonly availableOutputs: readonly InfraOutput[];
}

export interface InfraRuntimeAdapter<P extends InfraRuntimeProviderId = InfraRuntimeProviderId> {
  readonly descriptor: InfraAdapterDescriptor<P>;
  /** Read-only prerequisites and desired-state validation; no cluster creation. */
  validateAsync(
    context: InfraExecutionContext,
    desired: InfraRuntimeDesiredState<P>,
  ): Promise<InfraResult<null>>;
  planAsync(
    context: InfraExecutionContext,
    desired: InfraRuntimeDesiredState<P>,
  ): Promise<InfraResult<readonly InfraPlanAction[]>>;
  ensureAsync(
    context: InfraExecutionContext,
    desired: InfraRuntimeDesiredState<P>,
  ): Promise<InfraResult<InfraReconcileResult>>;
  statusAsync(
    context: InfraExecutionContext,
    desired: InfraRuntimeDesiredState<P>,
  ): Promise<InfraResult<readonly InfraResourceStatus[]>>;
  suspendAsync(
    context: InfraExecutionContext,
    desired: InfraRuntimeDesiredState<P>,
  ): Promise<InfraResult<InfraReconcileResult>>;
  destroyAsync(
    context: InfraExecutionContext,
    desired: InfraRuntimeDesiredState<P>,
    request: InfraDestroyRequest,
  ): Promise<InfraResult<InfraReconcileResult>>;
  generateAsync?(
    context: InfraExecutionContext,
    desired: InfraRuntimeDesiredState<P>,
  ): Promise<InfraResult<readonly InfraGeneratedArtifact[]>>;
}

/** A service can own several capabilities but contributes one deduplicated platform instance. */
export interface InfraServiceAdapter {
  readonly descriptor: InfraAdapterDescriptor<'supabase' | 'cerbos' | 'r2' | 'supabase-vault'>;
  /** Read-only service config, bootstrap credentials and dependency validation. */
  validateAsync(context: InfraExecutionContext): Promise<InfraResult<null>>;
  planAsync(context: InfraExecutionContext): Promise<InfraResult<readonly InfraPlanAction[]>>;
  /** Mutating pre-runtime preparation invoked only by an orchestrated `up` operation. */
  prepareAsync?(context: InfraExecutionContext): Promise<InfraResult<null>>;
  desiredWorkloadsAsync(
    context: InfraExecutionContext,
  ): Promise<InfraResult<readonly InfraWorkloadSpec[]>>;
  reconcileAsync(
    context: InfraExecutionContext,
    runtimeOutputs: readonly InfraOutput[],
  ): Promise<InfraResult<InfraReconcileResult>>;
  statusAsync(context: InfraExecutionContext): Promise<InfraResult<readonly InfraResourceStatus[]>>;
  destroyAsync(
    context: InfraExecutionContext,
    request: InfraDestroyRequest,
  ): Promise<InfraResult<InfraReconcileResult>>;
  suspendAsync?(context: InfraExecutionContext): Promise<InfraResult<InfraReconcileResult>>;
}