import type { StudioRecipe } from './types.js';

export const STUDIO_RECIPES: StudioRecipe[] = [
  {
    id: 'create-video',
    title: 'Create New Video',
    goal: 'Create an original video from a brief, references, or scratch concept.',
    useWhen: ['product ad', 'brand film', 'short film', 'explainer', 'new video'],
    requiredInputs: ['project', 'intent'],
    optionalInputs: ['title', 'durationSeconds', 'client', 'platform', 'aspectRatio', 'sourceMode', 'audioMode', 'executionIntent'],
    riskLevel: 'medium',
    executionPolicy: 'dry-run-first',
    commands: [
      {
        id: 'create-dry-run',
        title: 'Draft production plan',
        primary: 'vclaw video create <intent> --project <project> --production-mode director --platform <platform> --aspect-ratio <aspectRatio> --clip-duration <durationSeconds> --audio <audioEnabled> --dry-run',
        when: 'always',
        produces: ['brief.json', 'storyboard.json', 'execution profile preview'],
        outputArtifacts: [
          {
            stepId: 'create-dry-run',
            kind: 'brief',
            path: 'artifacts/brief.json',
            description: 'Creator brief preview.',
          },
          {
            stepId: 'create-dry-run',
            kind: 'storyboard',
            path: 'artifacts/storyboard.json',
            description: 'Creator storyboard preview.',
          },
        ],
      },
      {
        id: 'readiness',
        title: 'Check project readiness',
        primary: 'vclaw video readiness --project <project> --mode director',
        when: 'after brief and storyboard exist',
        produces: ['readiness.json'],
        outputArtifacts: [
          {
            stepId: 'readiness',
            kind: 'readiness',
            path: 'artifacts/readiness.json',
            description: 'Provider and project readiness report.',
          },
        ],
      },
      {
        id: 'cost-estimate',
        title: 'Estimate production cost',
        primary: 'vclaw video cost-estimate --project <project> --clip-duration <durationSeconds>',
        when: 'before any render or hosted audio step',
        produces: ['cost estimate'],
        outputArtifacts: [
          {
            stepId: 'cost-estimate',
            kind: 'cost-estimate',
            path: 'artifacts/cost-estimate.json',
            description: 'Anticipated creator production cost.',
          },
        ],
      },
      {
        id: 'review-ui',
        title: 'Open review surface',
        primary: 'vclaw video review-ui --project <project> --dry-run',
        when: 'before spend or approval decisions',
        produces: ['review-ui launch plan'],
        outputArtifacts: [
          {
            stepId: 'review-ui',
            kind: 'review-surface',
            path: 'artifacts/review-ui.json',
            description: 'Local review surface launch plan.',
          },
        ],
      },
      {
        id: 'execute-dry-run',
        title: 'Preview provider render',
        primary: 'vclaw video produce --project <project> --mode director --dry-run',
        when: 'after readiness and explicit storyboard approval',
        produces: ['execution-report.json'],
        credentialRequirements: [
          {
            id: 'provider-render-credentials',
            requiredForStepId: 'execute-dry-run',
            envVars: ['USEAPI_API_TOKEN', 'MAGNIFIC_API_KEY', 'APIZ_API_KEY', 'XSKILL_API_KEY'],
            requiredWhen: ['render'],
            description: 'At least one configured provider route is required for a real render; dry-run planning does not require provider credentials.',
          },
        ],
        spendRequirement: {
          stepId: 'execute-dry-run',
          category: 'provider-render',
          anticipated: true,
          requiresConfirmation: true,
          estimatedUsd: null,
          description: 'Provider rendering may spend credits and stays dry unless --confirm-spend is supplied.',
        },
        approvalRequirement: {
          type: 'storyboard',
          requiredBeforeStepId: 'execute-dry-run',
          status: 'pending',
          description: 'Storyboard approval remains a separate human gate before real render.',
        },
        outputArtifacts: [
          {
            stepId: 'execute-dry-run',
            kind: 'execution-report',
            path: 'artifacts/execution-report.json',
            description: 'Dry or confirmed render execution report.',
          },
        ],
      },
      {
        id: 'assemble-dry-run',
        title: 'Plan final assembly',
        primary: 'vclaw video assemble --project <project> --from-clips --dry-run',
        when: 'after accepted scene clips exist',
        produces: ['assemble-report.json'],
        spendRequirement: {
          stepId: 'assemble-dry-run',
          category: 'local-assembly',
          anticipated: false,
          requiresConfirmation: false,
          estimatedUsd: 0,
          description: 'Local assembly is dry-run by default in Studio and does not submit to providers.',
        },
        outputArtifacts: [
          {
            stepId: 'assemble-dry-run',
            kind: 'assemble-report',
            path: 'artifacts/assemble-report.json',
            description: 'Final assembly plan or report.',
          },
        ],
      },
      {
        id: 'qc',
        title: 'Run final quality review',
        primary: 'vclaw video motion-qc --project <project>',
        when: 'after assembled or rendered clips exist',
        produces: ['review-report.json'],
        credentialRequirements: [
          {
            id: 'hosted-qc-credentials',
            requiredForStepId: 'qc',
            envVars: ['GEMINI_API_KEYS', 'GOOGLE_API_KEYS', 'GOOGLE_API_KEY'],
            requiredWhen: ['render', 'publish-package'],
            description: 'Hosted visual QC needs a Gemini vision key; this step is not run by a plan-only request.',
          },
        ],
        spendRequirement: {
          stepId: 'qc',
          category: 'hosted-qc',
          anticipated: true,
          requiresConfirmation: true,
          estimatedUsd: null,
          description: 'Hosted visual QC can call Gemini and remains gated by Studio execution policy.',
        },
        approvalRequirement: {
          type: 'review',
          requiredBeforeStepId: 'qc',
          status: 'pending',
          description: 'Generated clips must be reviewed before publish handoff.',
        },
        outputArtifacts: [
          {
            stepId: 'qc',
            kind: 'review-report',
            path: 'artifacts/review-report.json',
            description: 'Review verdict and publish readiness evidence.',
          },
        ],
      },
      {
        id: 'publish-package-handoff',
        title: 'Prepare publish package handoff',
        primary: 'vclaw video publish --project <project> --status ready',
        when: 'after review-report verdict is pass and publishReady is true',
        produces: ['publish-report.json'],
        approvalRequirement: {
          type: 'publish',
          requiredBeforeStepId: 'publish-package-handoff',
          status: 'pending',
          description: 'Publish/package handoff requires a passing review report.',
        },
        outputArtifacts: [
          {
            stepId: 'publish-package-handoff',
            kind: 'publish-report',
            path: 'artifacts/publish-report.json',
            description: 'Reviewed publish lifecycle handoff report.',
          },
        ],
      },
    ],
  },
  {
    id: 'creator-demo',
    title: 'Zero-Key Creator Demo',
    goal: 'Create a local-first demo project with deterministic placeholders, readiness, cost estimate, and an openable preview portal.',
    useWhen: ['demo', 'zero key', 'first run', 'offline onboarding', 'local preview'],
    requiredInputs: ['project', 'intent'],
    optionalInputs: ['title', 'durationSeconds', 'client', 'platform', 'aspectRatio', 'sourceMode', 'audioMode'],
    riskLevel: 'low',
    executionPolicy: 'dry-run-first',
    commands: [
      {
        id: 'creator-demo',
        title: 'Create complete local demo workspace',
        primary: 'vclaw video creator-demo --project <project> --intent <intent> --platform <platform> --aspect-ratio <aspectRatio> --duration <durationSeconds>',
        when: 'always',
        produces: ['project.json', 'brief.json', 'storyboard.json', 'asset-manifest.json', 'readiness.json', 'cost-estimate.json', 'preview.html', 'review.html', 'run.html'],
        spendRequirement: {
          stepId: 'creator-demo',
          category: 'local-assembly',
          anticipated: false,
          requiresConfirmation: false,
          estimatedUsd: 0,
          description: 'The complete demo is generated locally without provider or network calls.',
        },
        outputArtifacts: [
          {
            stepId: 'creator-demo',
            kind: 'brief',
            path: 'artifacts/brief.json',
            description: 'Offline creator brief.',
          },
          {
            stepId: 'creator-demo',
            kind: 'storyboard',
            path: 'artifacts/storyboard.json',
            description: 'Offline storyboard with placeholder scene prompts.',
          },
          {
            stepId: 'creator-demo',
            kind: 'asset-manifest',
            path: 'artifacts/asset-manifest.json',
            description: 'Local placeholder media manifest.',
          },
          {
            stepId: 'creator-demo',
            kind: 'readiness',
            path: 'artifacts/readiness.json',
            description: 'Local readiness result; no provider route is called.',
          },
          {
            stepId: 'creator-demo',
            kind: 'cost-estimate',
            path: 'artifacts/cost-estimate.json',
            description: 'Local low-cost estimate based on storyboard duration.',
          },
          {
            stepId: 'creator-demo',
            kind: 'preview-portal',
            path: 'preview.html',
            description: 'Openable local preview. It is not a rendered final MP4.',
          },
        ],
      },
    ],
  },
  {
    id: 'copy-reference',
    title: 'Copy Or Adapt Reference',
    goal: 'Analyze a reference video or ad and adapt it for a new subject.',
    useWhen: ['copy ad', 'clone reel', 'reference video', 'replicate'],
    requiredInputs: ['project', 'input', 'intent'],
    optionalInputs: ['client'],
    riskLevel: 'medium',
    executionPolicy: 'plan-first',
    commands: [
      {
        id: 'analyze-reference',
        title: 'Analyze source reference',
        primary: 'vclaw video analyze --project <project> --source <input> --auto',
        when: 'reference source is available',
        produces: ['analyze-output.json'],
      },
      {
        id: 'clone-plan',
        title: 'Build clone plan',
        primary: 'vclaw video clone-plan --template <template> --project <project> --intent <intent>',
        when: 'analysis has produced or selected a template',
        produces: ['clone-plan.json'],
      },
    ],
  },
  {
    id: 'presenter-video',
    title: 'Presenter Video',
    goal: 'Create a Bunty, Nex, Davendra, or generic presenter episode from a deck or brief.',
    useWhen: ['Bunty', 'Nex', 'Davendra', 'presenter', 'slides', 'deck'],
    requiredInputs: ['project', 'input'],
    optionalInputs: ['client', 'title', 'intent'],
    riskLevel: 'medium',
    executionPolicy: 'approval-gated',
    commands: [
      {
        id: 'assemble-dry-run',
        title: 'Plan presenter assembly',
        primary: 'vclaw video assemble --project <project> --dry-run',
        when: 'slides or project assets exist',
        produces: ['assemble-report.json'],
      },
      {
        id: 'portal',
        title: 'Create review portal',
        primary: 'vclaw video portal --project <project> --client <client> --surface review',
        when: 'reviewable media exists',
        produces: ['preview portal HTML'],
      },
    ],
  },
  {
    id: 'music-video',
    title: 'Music Video And Multi-Shot',
    goal: 'Plan a music-video or cinematic sequence using prompt packets, storyboard grids, and multi-shot prompts.',
    useWhen: ['music video', 'multi-shot', 'cinematic sequence', 'Seedance'],
    requiredInputs: ['project'],
    optionalInputs: ['durationSeconds', 'intent', 'input'],
    riskLevel: 'high',
    executionPolicy: 'approval-gated',
    commands: [
      {
        id: 'filmmaking-prompts',
        title: 'Generate filmmaking prompt packet',
        primary: 'vclaw video filmmaking-prompts --project <project> --duration <durationSeconds> --storyboard-grid artifacts/storyboard-grid.png --write',
        when: 'storyboard exists or a project concept exists',
        produces: ['filmmaking-prompts.json', 'storyboard-grid.png'],
      },
      {
        id: 'multi-shot',
        title: 'Create multi-shot prompt',
        primary: 'vclaw video multi-shot --from-storyboard --project <project> --scene 0 --preset cinematic-15s',
        when: 'storyboard scene exists',
        produces: ['multi-shot-prompt.json'],
      },
      {
        id: 'readiness',
        title: 'Check project readiness',
        primary: 'vclaw video readiness --project <project>',
        when: 'after prompt packet and storyboard assets exist',
        produces: ['readiness.json'],
      },
      {
        id: 'execute-dry-run',
        title: 'Preview provider execution',
        primary: 'vclaw video execute --project <project> --dry-run',
        when: 'readiness is green or warnings are accepted',
        produces: ['execution-report.json'],
      },
      {
        id: 'review-portal',
        title: 'Create review surface',
        primary: 'vclaw video portal --project <project> --surface review',
        when: 'after clips or storyboard media exist',
        produces: ['review portal HTML'],
      },
    ],
  },
  {
    id: 'ugc-campaign',
    title: 'UGC Campaign',
    goal: 'Plan a belief-driven campaign with hooks, scripts, variants, and assembly.',
    useWhen: ['UGC', 'testimonial', 'campaign', 'creator ad'],
    requiredInputs: ['project', 'intent'],
    optionalInputs: ['input', 'client'],
    riskLevel: 'medium',
    executionPolicy: 'plan-first',
    commands: [
      {
        id: 'ugc-brief',
        title: 'Create UGC brief',
        primary: 'vclaw video create <intent> --project <project> --production-mode director --platform tiktok --dry-run',
        when: 'campaign idea is known',
        produces: ['brief.json', 'storyboard.md'],
      },
      {
        id: 'review-ui',
        title: 'Plan UGC review surface',
        primary: 'vclaw video review-ui --project <project> --dry-run',
        when: 'draft scenes or candidates exist',
        produces: ['review-ui plan'],
      },
    ],
  },
  {
    id: 'existing-project',
    title: 'Continue Existing Project',
    goal: 'Inspect a project and recommend the next action based on artifacts and readiness.',
    useWhen: ['continue', 'status', 'what next', 'existing project'],
    requiredInputs: ['project'],
    optionalInputs: ['client'],
    riskLevel: 'low',
    executionPolicy: 'dry-run-first',
    commands: [
      {
        id: 'status',
        title: 'Read project status',
        primary: 'vclaw video status --project <project>',
        when: 'project exists',
        produces: ['status report'],
      },
      {
        id: 'readiness',
        title: 'Check readiness',
        primary: 'vclaw video readiness --project <project>',
        when: 'project exists',
        produces: ['readiness.json'],
      },
      {
        id: 'next-actions',
        title: 'Recommend next actions',
        primary: 'vclaw video next-actions',
        when: 'project exists',
        produces: ['portfolio next actions'],
      },
    ],
  },
  {
    id: 'review-regenerate',
    title: 'Review Or Regenerate',
    goal: 'Review generated scenes, select candidates, reroll weak scenes, and prepare approval.',
    useWhen: ['review', 'regenerate', 'reroll', 'fix scene', 'approve'],
    requiredInputs: ['project'],
    optionalInputs: ['client'],
    riskLevel: 'medium',
    executionPolicy: 'approval-gated',
    commands: [
      {
        id: 'review-ui',
        title: 'Open review UI',
        primary: 'vclaw video review-ui --project <project> --dry-run',
        when: 'project has reviewable artifacts',
        produces: ['review-ui plan'],
      },
      {
        id: 'candidates-list',
        title: 'List scene candidates',
        primary: 'vclaw video candidates-list --project <project>',
        when: 'scene candidates exist',
        produces: ['candidate summary'],
      },
    ],
  },
  {
    id: 'publish-deliver',
    title: 'Publish And Deliver',
    goal: 'Package final media and publish a client review or delivery portal.',
    useWhen: ['publish', 'client portal', 'deliver', 'share'],
    requiredInputs: ['project', 'client'],
    optionalInputs: ['input'],
    riskLevel: 'medium',
    executionPolicy: 'approval-gated',
    commands: [
      {
        id: 'portal',
        title: 'Build portal',
        primary: 'vclaw video portal --project <project> --client <client> --surface client-review',
        when: 'reviewable project exists',
        produces: ['client review portal'],
      },
      {
        id: 'publish-preview-dry-run',
        title: 'Plan portal publishing',
        primary: 'vclaw video publish-preview --project <project> --client <client> --bucket <bucket> --dry-run',
        when: 'bucket is known',
        produces: ['publish plan'],
      },
    ],
  },
  {
    id: 'brand-campaign',
    title: 'Brand Campaign From Website',
    goal: 'Extract brand DNA from a client website, seed the brief from it, and plan an on-brand campaign.',
    useWhen: ['brand campaign', 'from website', 'brand dna', 'client site', 'on-brand'],
    requiredInputs: ['project', 'input'],
    optionalInputs: ['title', 'client'],
    riskLevel: 'medium',
    executionPolicy: 'plan-first',
    commands: [
      {
        id: 'brand-extract',
        title: 'Extract brand DNA from the website',
        primary: 'vclaw video brand-extract --project <project> --url <input>',
        when: 'a brand/website URL is available',
        produces: ['brand-dna.json'],
      },
      {
        id: 'brand-brief',
        title: 'Seed the brief from brand DNA',
        primary: 'vclaw video brief --project <project> --from-brand-dna',
        when: 'brand-dna.json exists',
        produces: ['brief.json'],
      },
      {
        id: 'storyboard',
        title: 'Draft the storyboard',
        primary: 'vclaw video storyboard --project <project> --template <template>',
        when: 'brief exists',
        produces: ['storyboard.json'],
      },
      {
        id: 'readiness',
        title: 'Check project readiness',
        primary: 'vclaw video readiness --project <project>',
        when: 'after brief and storyboard exist',
        produces: ['readiness.json'],
      },
    ],
  },
  {
    id: 'character-video',
    title: 'Identity-Locked Character Video',
    goal:
      'Drive a one-command, identity-locked character video pipeline: lock a reference sheet, compose the multi-shot prompt packet, preview provider execution, and prepare a review surface. PREREQUISITE: register your character images as Seedance Asset Library avatars out-of-band first (vclaw video seedance-register-assets ... — it is a credit-spending step with no dry-run, so it is intentionally NOT a step here); buildExecutionPayload then resolves each scene Asset:// reference from artifacts/seedance-assets.json.',
    useWhen: ['character video', 'avatar', 'identity-locked', 'consistent character', 'locked face'],
    requiredInputs: ['project', 'intent'],
    optionalInputs: ['client', 'durationSeconds', 'title'],
    riskLevel: 'high',
    executionPolicy: 'approval-gated',
    commands: [
      {
        id: 'reference-sheet-add',
        title: 'Lock the character reference sheet',
        primary: 'vclaw video reference-sheet-add --project <project> --type identity --name <project>-cast',
        when: 'character images and an Asset Library registration exist',
        produces: ['reference-sheet artifact'],
      },
      {
        id: 'filmmaking-prompts',
        title: 'Compose the filmmaking prompt packet',
        primary: 'vclaw video filmmaking-prompts --project <project> --duration <durationSeconds> --write',
        when: 'storyboard exists or a project concept exists',
        produces: ['filmmaking-prompts.json'],
      },
      {
        id: 'multi-shot',
        title: 'Create the multi-shot prompt',
        primary: 'vclaw video multi-shot --from-storyboard --project <project> --scene 0',
        when: 'storyboard scene exists',
        produces: ['multi-shot-prompt.json'],
      },
      {
        id: 'readiness',
        title: 'Check project readiness',
        primary: 'vclaw video readiness --project <project>',
        when: 'after prompt packet and reference sheet exist',
        produces: ['readiness.json'],
      },
      {
        id: 'execute-dry-run',
        title: 'Preview provider execution',
        primary: 'vclaw video execute --project <project> --dry-run',
        when: 'readiness is green or warnings are accepted',
        produces: ['execution-report.json'],
      },
      {
        id: 'portal',
        title: 'Create review surface',
        primary: 'vclaw video portal --project <project> --surface review',
        when: 'after clips or storyboard media exist',
        produces: ['review portal HTML'],
      },
      {
        id: 'publish-preview-dry-run',
        title: 'Plan portal delivery',
        primary: 'vclaw video publish-preview --project <project> --client <client> --bucket <bucket> --dry-run',
        when: 'bucket is known and a client is delivering',
        produces: ['publish plan'],
      },
    ],
  },
];

export function findStudioRecipe(id: string): StudioRecipe | undefined {
  return STUDIO_RECIPES.find((recipe) => recipe.id === id);
}