import type { CinemaQueueTaskKind, CinemaQueueTaskStatus } from './cinema-queue-types.js';
import type { CinemaSha256 } from './cinema-types.js';

export interface CinemaConsoleGate {
  id: string;
  label: string;
  status: 'locked' | 'ready' | 'blocked' | 'external-approval';
  evidenceIds: string[];
}

export interface CinemaConsoleQueueRow {
  taskId: string;
  kind: CinemaQueueTaskKind;
  status: CinemaQueueTaskStatus;
  routeId: string;
  dependencies: string[];
  shotId: string | null;
  providerJobId: string | null;
  providerStatus: string | null;
  reconciliationRequired: boolean;
  reconciliationAttempts: number;
  laneId: string | null;
  lanePosition: number | null;
  laneEtaSeconds: number | null;
  leaseWorkerId: string | null;
  leaseExpiresAt: string | null;
  failure: { code: string; message: string; retryable: boolean } | null;
  authorizationRequirement: 'none' | 'exact-quote';
  spendAuthorizationId: string | null;
  estimatedCost: number;
  actualCost: number;
  currency: string;
}

export interface CinemaConsoleAsset {
  assetId: string;
  label: string;
  role: string;
  path: string;
  contentHash: CinemaSha256;
  faceCount: number;
  faceFragmentCount: number;
  maskArtifactId: string | null;
  lockStatus: 'locked' | 'headless' | 'pending';
  mediaExists: boolean;
}

export interface CinemaConsoleShot {
  shotId: string;
  ordinal: number;
  purpose: string;
  expectedChange: string;
  durationSeconds: number;
  camera: string;
  action: string;
  prompt: string;
  promptHash: CinemaSha256;
  referenceCount: number;
  continuity: string[];
  videoPath: string | null;
  posterPath: string | null;
  mediaExists: boolean;
}

export interface CinemaConsoleCandidate {
  attemptId: string;
  queueTaskId: string | null;
  shotId: string;
  routeId: string;
  status: string;
  parentAttemptId: string | null;
  changedVariables: string[];
  evidenceIds: string[];
  promoted: boolean;
  editorialSlot: string | null;
  actualCost: number;
  currency: string;
  prompt: string;
  promptHash: CinemaSha256;
  providerParameters: Record<string, unknown>;
  providerParametersHash: CinemaSha256;
  referenceAssetIds: string[];
  videoPath: string | null;
  mediaExists: boolean;
  filmstripPath: string | null;
  filmstripExists: boolean;
}

export interface CinemaConsoleQcFinding {
  id: string;
  shotId: string;
  lane: 'technical' | 'identity' | 'continuity' | 'performance' | 'editorial';
  severity: 'pass' | 'info' | 'warning' | 'blocker';
  timeSeconds: number | null;
  summary: string;
  evidenceIds: string[];
}

export interface CinemaConsoleReviewDecision {
  decisionId: string;
  attemptId: string;
  shotId: string;
  kind: 'note' | 'pass' | 'reject' | 'redesign';
  reviewerId: string;
  decidedAt: string;
  reason: string;
  timeSeconds: number | null;
  changedVariable: string | null;
  evidenceIds: string[];
  contentHash: CinemaSha256;
}

export interface CinemaConsoleStoryCoverage {
  beatId: string;
  act: 'setup' | 'confrontation' | 'resolution';
  purpose: string;
  change: string;
  setupIds: string[];
  payoffIds: string[];
  sceneIds: string[];
  shotIds: string[];
  covered: boolean;
}

export interface CinemaConsoleRecognitionEvidence {
  assetId: string;
  versionId: string;
  conditionId: string;
  category: string;
  description: string;
  status: 'pending' | 'pass' | 'fail';
  reviewerId: string | null;
  evidenceIds: string[];
}

export interface CinemaConsoleEvidenceBoard {
  planningReceiptHash: CinemaSha256;
  evidenceLedgerHash: CinemaSha256 | null;
  preflightHash: CinemaSha256;
  blockers: string[];
  assumptions: Array<{ field: string; value: string; reason: string }>;
  characterSheets: Array<{
    characterVersionId: string;
    status: 'missing' | 'stored' | 'approved';
    sheetHash: CinemaSha256 | null;
    reviewerId: string | null;
    evidenceIds: string[];
  }>;
  recognition: CinemaConsoleRecognitionEvidence[];
  rights: Array<{
    assetId: string;
    status: 'pending' | 'cleared' | 'rejected';
    owner: string | null;
    permittedScope: string | null;
    evidenceIds: string[];
  }>;
  voices: Array<{
    characterId: string;
    speaking: boolean;
    voiceId: string | null;
    lockStatus: 'pending' | 'locked' | 'rejected' | 'not-required';
    releaseStatus: 'pending' | 'cleared' | 'rejected' | 'not-required';
    auditionEvidenceIds: string[];
    releaseEvidenceIds: string[];
  }>;
  productionContracts: {
    continuityHash: CinemaSha256 | null;
    continuityRecords: number;
    timedAudioHash: CinemaSha256 | null;
    timedAudioShots: number;
    boundToEveryManifest: boolean;
  };
}

export interface CinemaConsoleModel {
  schemaVersion: 1;
  projectSlug: string;
  title: string;
  generatedAt: string;
  mode: 'live' | 'static-read-only';
  scope: 'three-shot-proof' | 'proof-scene' | 'short-film' | 'feature';
  summary: {
    readiness: 'ready' | 'blocked' | 'awaiting-approval';
    blockers: string[];
    assumptions: string[];
    estimatedCost: number;
    actualCost: number;
    currency: string;
  };
  gates: CinemaConsoleGate[];
  queue: CinemaConsoleQueueRow[];
  assets: CinemaConsoleAsset[];
  shots: CinemaConsoleShot[];
  candidates: CinemaConsoleCandidate[];
  qc: CinemaConsoleQcFinding[];
  reviews: CinemaConsoleReviewDecision[];
  evidence: CinemaConsoleEvidenceBoard | null;
  qualification: {
    currentScope: 'three-shot-proof' | 'proof-scene' | 'short-film' | 'feature';
    proposedScope: 'three-shot-proof' | 'proof-scene' | 'short-film' | 'feature' | null;
    verdict: 'qualified' | 'blocked' | 'terminal-scope';
    passedChecks: string[];
    blockers: string[];
    evidenceIds: string[];
    contentHash: CinemaSha256;
  } | null;
  edit: {
    shotOrder: string[];
    totalDurationSeconds: number;
    missingCoverage: string[];
    audioLayers: string[];
    roughCutPath: string | null;
    storyCoverage: CinemaConsoleStoryCoverage[];
  };
  delivery: {
    status: 'not-started' | 'blocked' | 'ready';
    masterPath: string | null;
    captionsPath: string | null;
    archiveHash: CinemaSha256 | null;
    notes: string[];
  };
}