muninn/app/Support/VideoWorkflow/StepHandlers/VideoGenerationHandler.php

<?php

namespace App\Support\VideoWorkflow\StepHandlers;

use App\Models\AiProvider;
use App\Models\WorkflowStep;
use App\Support\AiProviders\AiGenerationException;
use App\Support\AiProviders\AiProviderManager;
use App\Support\AssetStorage\AssetStorage;
use App\Support\VideoWorkflow\WorkflowEngine;

/**
 * Generates the scene visuals for a project's storyboard, one still image
 * per scene, via a StabilityAI-backed AiProvider. This produces the visual
 * assets VideoEditingHandler later assembles into an actual video file —
 * it does not itself produce a video (no motion/text-to-video model is
 * integrated).
 */
class VideoGenerationHandler implements StepHandler
{
    public function __construct(
        private readonly AiProviderManager $aiProviders,
        private readonly AssetStorage $assets,
    ) {}

    public function type(): string
    {
        return 'video_generation';
    }

    public function handle(WorkflowStep $step, WorkflowEngine $engine): void
    {
        $provider = AiProvider::query()->where('provider', 'stability_ai')->where('is_active', true)->first();

        if (! $provider) {
            $engine->failStep($step, 'No active StabilityAI provider configured.');

            return;
        }

        $scenes = $this->resolveScenes($step);

        if (! $scenes) {
            $engine->failStep($step, 'No storyboard available — complete a storyboard step first.');

            return;
        }

        $style = ($step->input ?? [])['style'] ?? null;
        $assetIds = [];

        foreach ($scenes as $scene) {
            $prompt = $scene['visual_prompt'] ?? $scene['description'] ?? null;

            if (! $prompt) {
                continue;
            }

            if ($style) {
                $prompt .= ", {$style}";
            }

            try {
                $result = $this->aiProviders->generate($provider, $prompt);
            } catch (AiGenerationException $e) {
                $engine->failStep($step, "scene {$scene['scene_number']}: {$e->getMessage()}");

                return;
            }

            $extension = str($result->contentType)->after('image/')->toString() ?: 'png';

            $asset = $this->assets->store(
                $step->videoProject,
                'image',
                $result->content,
                $extension,
                step: $step,
                mimeType: $result->contentType,
                metadata: ['scene_number' => $scene['scene_number'] ?? null, 'prompt' => $prompt],
            );

            $assetIds[] = $asset->id;
        }

        if (empty($assetIds)) {
            $engine->failStep($step, 'No scenes had a usable visual_prompt.');

            return;
        }

        $engine->completeStep($step, [
            'asset_ids' => $assetIds,
            'scene_count' => count($assetIds),
        ]);
    }

    /**
     * @return array<int, array<string, mixed>>|null
     */
    private function resolveScenes(WorkflowStep $step): ?array
    {
        $input = $step->input ?? [];

        if (! empty($input['scenes'])) {
            return $input['scenes'];
        }

        $storyboardAsset = $step->videoProject->assets()
            ->where('type', 'other')
            ->whereJsonContains('metadata->kind', 'storyboard')
            ->orderByDesc('version')
            ->first();

        if (! $storyboardAsset) {
            return null;
        }

        $decoded = json_decode($this->assets->contents($storyboardAsset), true);

        return $decoded['scenes'] ?? null;
    }
}