// CRITICAL
import { AsyncLock } from "../core/async";
import type { ServiceId } from "../types/services";

export type GpuLease = {
  holder_service_id: ServiceId;
  acquired_at: string;
  reason?: string | null;
};

export type GpuLeaseConflictPayload = {
  code: "gpu_lease_conflict";
  requested_service: { id: ServiceId };
  holder_service: { id: ServiceId };
  recommended_actions: Array<
    | { type: "replace"; label: string }
    | { type: "best_effort"; label: string }
    | { type: "cancel"; label: string }
  >;
};

/**
 * Structured error thrown when a strict GPU lease acquisition conflicts with another holder.
 */
export class GpuLeaseConflictError extends Error {
  public readonly payload: GpuLeaseConflictPayload;

  /**
   * Create a GPU lease conflict error.
   * @param payload - Conflict payload to return to callers.
   */
  public constructor(payload: GpuLeaseConflictPayload) {
    super("GPU lease conflict");
    this.payload = payload;
  }
}

/**
 * Strict-by-default GPU lease manager. Designed for a future N-GPU API but
 * currently manages a single global lease (one holder at a time).
 */
export class GpuLeaseManager {
  private readonly lock = new AsyncLock();
  private lease: GpuLease | null = null;

  /**
   * Get the current lease snapshot.
   * @returns Lease snapshot or null.
   */
  public getLease(): GpuLease | null {
    return this.lease ? { ...this.lease } : null;
  }

  /**
   * Force-set the current lease holder (used to reconcile with external state).
   * @param holder - Service id taking the lease.
   * @param reason - Optional reason.
   * @returns Lease snapshot.
   */
  public async forceSetLease(holder: ServiceId, reason?: string | null): Promise<GpuLease> {
    const release = await this.lock.acquire();
    try {
      this.lease = { holder_service_id: holder, acquired_at: new Date().toISOString(), reason: reason ?? null };
      return { ...this.lease };
    } finally {
      release();
    }
  }

  /**
   * Release the lease if held by the provided service.
   * @param holder - Service id releasing the lease.
   * @returns void
   */
  public async release(holder: ServiceId): Promise<void> {
    const release = await this.lock.acquire();
    try {
      if (this.lease?.holder_service_id === holder) {
        this.lease = null;
      }
    } finally {
      release();
    }
  }

  /**
   * Acquire a strict lease; throws on conflict unless already held by requested.
   * @param requested - Service id requesting the lease.
   * @param reason - Optional reason.
   * @returns Lease snapshot.
   */
  public async acquireStrict(requested: ServiceId, reason?: string | null): Promise<GpuLease> {
    const release = await this.lock.acquire();
    try {
      if (!this.lease) {
        this.lease = { holder_service_id: requested, acquired_at: new Date().toISOString(), reason: reason ?? null };
        return { ...this.lease };
      }
      if (this.lease.holder_service_id === requested) {
        return { ...this.lease };
      }

      throw new GpuLeaseConflictError({
        code: "gpu_lease_conflict",
        requested_service: { id: requested },
        holder_service: { id: this.lease.holder_service_id },
        recommended_actions: [
          { type: "replace", label: "Stop current holder and start requested service" },
          { type: "best_effort", label: "Try best-effort start anyway (may fail/OOM)" },
          { type: "cancel", label: "Cancel" },
        ],
      });
    } finally {
      release();
    }
  }
}