Ai Video Production Master

#!/usr/bin/env python3
"""
Cloud I2V Batch Processor

Uploads keyframe images to a cloud GPU (Vast.ai),
runs Wan 2.1 I2V generation, and downloads results.

This is 10-50x faster than local M4 Max for video generation.

Requires: pip install vastai httpx
"""

import argparse
import asyncio
import json
import os
import re
import subprocess
import sys
import time
from dataclasses import dataclass
from pathlib import Path
from typing import Optional

import httpx


@dataclass
class CloudInstance:
    id: str
    ip: str
    port: int
    ssh_port: int
    hourly_cost: float
    gpu: str


def run_vastai(args: list[str], capture_json: bool = False) -> dict | str:
    """Run a vastai CLI command."""
    cmd = ["vastai"] + args
    if capture_json:
        cmd.append("--raw")

    result = subprocess.run(cmd, capture_output=True, text=True)

    if result.returncode != 0:
        raise RuntimeError(f"vastai command failed: {result.stderr}")

    if capture_json:
        return json.loads(result.stdout)
    return result.stdout


def search_offers(max_price: float = 0.50, min_gpu_ram: int = 24) -> list[dict]:
    """Search for available GPU instances using vastai CLI."""
    query = f"gpu_ram >= {min_gpu_ram} num_gpus = 1 rentable = true dph < {max_price} reliability > 0.95"

    offers = run_vastai(["search", "offers", query, "-o", "dph+"], capture_json=True)

    # Filter for good GPUs (both underscore and space formats)
    good_gpus = ["RTX 4090", "RTX 5090", "RTX A6000", "A100", "H100", "A40",
                 "RTX_4090", "RTX_5090", "RTX_A6000"]
    filtered = [o for o in offers if any(g in o.get("gpu_name", "") for g in good_gpus)]

    if not filtered:
        # If no exact matches, return all offers with 24GB+ VRAM
        return offers[:10]

    return filtered[:10]  # Top 10 cheapest suitable options


def create_instance(offer_id: int, image: str = "runpod/pytorch:2.1.0-py3.10-cuda11.8.0-devel-ubuntu22.04") -> int:
    """Create a new instance from an offer."""
    # Use onstart script to install ComfyUI
    onstart = """#!/bin/bash
set -e
cd /root

# Ensure pip is available
apt-get update && apt-get install -y python3-pip || true
pip3 install comfy-cli httpx || pip install comfy-cli httpx
comfy --skip-prompt install
comfy node install ComfyUI-GGUF ComfyUI-VideoHelperSuite

# Download models
mkdir -p /root/comfy/ComfyUI/models/diffusion_models
mkdir -p /root/comfy/ComfyUI/models/text_encoders
mkdir -p /root/comfy/ComfyUI/models/vae

# Wan I2V model (only if not exists)
if [ ! -f /root/comfy/ComfyUI/models/diffusion_models/wan2.1-i2v-14b-480p-Q5_K_M.gguf ]; then
    wget -q -O /root/comfy/ComfyUI/models/diffusion_models/wan2.1-i2v-14b-480p-Q5_K_M.gguf \
        "https://huggingface.co/city96/Wan2.1-I2V-14B-480P-GGUF/resolve/main/wan2.1-i2v-14b-480p-Q5_K_M.gguf"
fi

# Text encoder
if [ ! -f /root/comfy/ComfyUI/models/text_encoders/umt5_xxl_fp8_e4m3fn_scaled.safetensors ]; then
    wget -q -O /root/comfy/ComfyUI/models/text_encoders/umt5_xxl_fp8_e4m3fn_scaled.safetensors \
        "https://huggingface.co/Comfy-Org/Wan_2.1_ComfyUI_repackaged/resolve/main/split_files/text_encoders/umt5_xxl_fp8_e4m3fn_scaled.safetensors"
fi

# VAE
if [ ! -f /root/comfy/ComfyUI/models/vae/wan_2.1_vae.safetensors ]; then
    wget -q -O /root/comfy/ComfyUI/models/vae/wan_2.1_vae.safetensors \
        "https://huggingface.co/Comfy-Org/Wan_2.1_ComfyUI_repackaged/resolve/main/split_files/vae/wan_2.1_vae.safetensors"
fi

# Start ComfyUI
cd /root/comfy/ComfyUI
python main.py --listen 0.0.0.0 --port 8188 &
"""

    # Write onstart script to temp file
    onstart_file = Path("/tmp/vastai_onstart.sh")
    onstart_file.write_text(onstart)

    result = run_vastai([
        "create", "instance", str(offer_id),
        "--image", image,
        "--disk", "80",
        "--onstart-cmd", onstart,
        "--direct",
    ], capture_json=False)  # CLI doesn't return JSON for create

    # Parse instance ID from success message like "Started. {'new_contract': 12345, ...}"
    # or "success: created instance 12345"
    match = re.search(r"new_contract['\"]?\s*:\s*(\d+)", result)
    if match:
        return int(match.group(1))

    match = re.search(r"instance\s+(\d+)", result, re.IGNORECASE)
    if match:
        return int(match.group(1))

    # Try to find any number that looks like an instance ID
    match = re.search(r"(\d{7,})", result)
    if match:
        return int(match.group(1))

    raise RuntimeError(f"Failed to parse instance ID from: {result}")


def get_instance_info(instance_id: int) -> Optional[dict]:
    """Get instance connection info."""
    instances = run_vastai(["show", "instances"], capture_json=True)

    for inst in instances:
        if inst.get("id") == instance_id:
            return inst
    return None


def wait_for_instance(instance_id: int, timeout: int = 900) -> dict:
    """Wait for instance to be ready."""
    print(f"Waiting for instance {instance_id} to be ready...")
    start = time.time()
    last_status = None

    while time.time() - start < timeout:
        info = get_instance_info(instance_id)
        if info:
            status = info.get("actual_status", "")
            if status != last_status:
                print(f"  Status: {status}")
                last_status = status

            if status == "running":
                return info  # Don't wait here - we'll check ComfyUI separately

        time.sleep(10)

    raise TimeoutError(f"Instance {instance_id} did not become ready in {timeout}s")


def destroy_instance(instance_id: int):
    """Destroy an instance."""
    try:
        run_vastai(["destroy", "instance", str(instance_id)])
        print(f"Destroyed instance {instance_id}")
    except Exception as e:
        print(f"Warning: Failed to destroy instance: {e}")


def build_i2v_workflow(image_name: str, motion_prompt: str, num_frames: int = 33, steps: int = 6) -> dict:
    """Build ComfyUI workflow for Wan I2V."""
    import random
    seed = random.randint(0, 2**32 - 1)

    return {
        "1": {"class_type": "LoadImage", "inputs": {"image": image_name}},
        "2": {"class_type": "ImageScale", "inputs": {
            "image": ["1", 0], "width": 832, "height": 480,
            "upscale_method": "lanczos", "crop": "center"
        }},
        "3": {"class_type": "UnetLoaderGGUF", "inputs": {
            "unet_name": "wan2.1-i2v-14b-480p-Q5_K_M.gguf"
        }},
        "4": {"class_type": "CLIPLoader", "inputs": {
            "clip_name": "umt5_xxl_fp8_e4m3fn_scaled.safetensors", "type": "wan"
        }},
        "5": {"class_type": "VAELoader", "inputs": {
            "vae_name": "wan_2.1_vae.safetensors"
        }},
        "6": {"class_type": "CLIPTextEncode", "inputs": {
            "text": motion_prompt, "clip": ["4", 0]
        }},
        "7": {"class_type": "CLIPTextEncode", "inputs": {
            "text": "blurry, distorted, watermark, static", "clip": ["4", 0]
        }},
        "8": {"class_type": "WanImageToVideo", "inputs": {
            "positive": ["6", 0], "negative": ["7", 0], "vae": ["5", 0],
            "width": 832, "height": 480, "length": num_frames,
            "batch_size": 1, "start_image": ["2", 0],
        }},
        "9": {"class_type": "ModelSamplingSD3", "inputs": {
            "model": ["3", 0], "shift": 8.0
        }},
        "10": {"class_type": "KSampler", "inputs": {
            "model": ["9", 0], "positive": ["8", 0], "negative": ["8", 1],
            "latent_image": ["8", 2], "seed": seed, "steps": steps,
            "cfg": 5.0, "sampler_name": "uni_pc", "scheduler": "normal",
            "denoise": 1.0,
        }},
        "11": {"class_type": "VAEDecode", "inputs": {
            "samples": ["10", 0], "vae": ["5", 0]
        }},
        "12": {"class_type": "VHS_VideoCombine", "inputs": {
            "frame_rate": 16, "loop_count": 0,
            "filename_prefix": f"i2v_{Path(image_name).stem}",
            "format": "video/h264-mp4", "pingpong": False,
            "save_output": True, "images": ["11", 0],
        }},
    }


async def submit_workflow(base_url: str, workflow: dict) -> str:
    """Submit workflow to ComfyUI and return prompt_id."""
    async with httpx.AsyncClient(timeout=60) as client:
        resp = await client.post(f"{base_url}/prompt", json={"prompt": workflow})
        resp.raise_for_status()
        return resp.json()["prompt_id"]


async def wait_for_completion(base_url: str, prompt_id: str, timeout: int = 600) -> Optional[str]:
    """Wait for workflow to complete."""
    async with httpx.AsyncClient(timeout=30) as client:
        start = time.time()
        while time.time() - start < timeout:
            await asyncio.sleep(10)

            resp = await client.get(f"{base_url}/history/{prompt_id}")
            if resp.status_code == 200:
                history = resp.json()
                if prompt_id in history:
                    entry = history[prompt_id]
                    status = entry.get("status", {}).get("status_str", "")

                    if status == "success":
                        outputs = entry.get("outputs", {})
                        for node_id, output in outputs.items():
                            if "gifs" in output:
                                return output["gifs"][0]["filename"]
                            if "videos" in output:
                                return output["videos"][0]["filename"]
                    elif "error" in status.lower():
                        print(f"  Workflow error: {entry}")
                        return None

        print(f"  Timeout waiting for {prompt_id}")
        return None


async def run_batch(
    instance_info: dict,
    images_dir: Path,
    output_dir: Path,
    motion_prompt: str,
    steps: int = 6,
    frames: int = 33,
) -> list[Path]:
    """Run batch I2V on cloud instance."""

    # Get connection info
    ssh_host = instance_info.get("ssh_host", "").split(":")[0]
    ssh_port = int(instance_info.get("ssh_port", 22))
    public_ip = instance_info.get("public_ipaddr", ssh_host)

    # ComfyUI port (usually 8188, mapped to a high port)
    ports = instance_info.get("ports", {})
    comfy_port = None
    for port_map in ports.values() if isinstance(ports, dict) else []:
        if "8188" in str(port_map):
            comfy_port = port_map.get("HostPort", 8188)
            break

    if not comfy_port:
        comfy_port = 8188  # Default

    base_url = f"http://{public_ip}:{comfy_port}"
    print(f"ComfyUI URL: {base_url}")

    # Find images
    images = list(images_dir.glob("*.png")) + list(images_dir.glob("*.jpg"))
    print(f"Found {len(images)} images to process")

    # Upload images via SSH
    print("Uploading images...")

    # Find SSH key for Vast.ai (check for dedicated key first, then default)
    ssh_key = Path.home() / ".ssh" / "id_ed25519_vastai"
    if not ssh_key.exists():
        ssh_key = Path.home() / ".ssh" / "id_ed25519"
    if not ssh_key.exists():
        ssh_key = Path.home() / ".ssh" / "id_rsa"

    ssh_opts = f"-o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -i {ssh_key}"
    scp_port = f"-P {ssh_port}"  # SCP uses capital P for port

    for img in images:
        result = subprocess.run(
            f"scp {ssh_opts} {scp_port} {img} root@{ssh_host}:/root/comfy/ComfyUI/input/",
            shell=True, capture_output=True, text=True
        )
        if result.returncode != 0:
            print(f"  Warning: Failed to upload {img.name}: {result.stderr}")
            raise RuntimeError(f"SCP failed: {result.stderr}")

    # Process each image
    output_videos = []
    for i, img in enumerate(images):
        print(f"Processing {i+1}/{len(images)}: {img.name}")

        workflow = build_i2v_workflow(img.name, motion_prompt, frames, steps)

        try:
            prompt_id = await submit_workflow(base_url, workflow)
            print(f"  Submitted: {prompt_id}")

            video_file = await wait_for_completion(base_url, prompt_id, timeout=600)
            if video_file:
                output_videos.append(video_file)
                print(f"  Complete: {video_file}")
            else:
                print(f"  Failed or timed out")
        except Exception as e:
            print(f"  Error: {e}")

    # Download results
    output_dir.mkdir(parents=True, exist_ok=True)
    print(f"\nDownloading {len(output_videos)} videos...")

    for video in output_videos:
        result = subprocess.run(
            f"scp {ssh_opts} {scp_port} root@{ssh_host}:/root/comfy/ComfyUI/output/{video} {output_dir}/",
            shell=True, capture_output=True, text=True
        )
        if result.returncode != 0:
            print(f"  Warning: Failed to download {video}: {result.stderr}")

    return list(output_dir.glob("*.mp4"))


async def main():
    parser = argparse.ArgumentParser(description="Cloud I2V Batch Processor")
    parser.add_argument("--images", type=Path, required=True, help="Input images directory")
    parser.add_argument("--output", type=Path, default=Path("i2v_output"), help="Output directory")
    parser.add_argument("--motion", default="subtle organic motion, gentle breathing, cinematic")
    parser.add_argument("--steps", type=int, default=6, help="Sampling steps (4-12)")
    parser.add_argument("--frames", type=int, default=33, help="Output frames (33=~2s at 16fps)")
    parser.add_argument("--max-price", type=float, default=0.50, help="Max $/hr")
    parser.add_argument("--dry-run", action="store_true", help="Show offers only")
    parser.add_argument("--yes", "-y", action="store_true", help="Skip confirmations")
    parser.add_argument("--instance", type=int, help="Use existing instance ID")

    args = parser.parse_args()

    # Count images
    images = list(args.images.glob("*.png")) + list(args.images.glob("*.jpg"))
    if not images:
        print(f"No images found in {args.images}")
        sys.exit(1)

    print(f"Found {len(images)} images to process")

    # Search for offers
    print(f"\nSearching for GPU instances under ${args.max_price}/hr...")
    offers = search_offers(args.max_price)

    if not offers:
        print("No suitable GPU instances found. Try increasing --max-price")
        sys.exit(1)

    print(f"\nTop offers:")
    print(f"{'ID':<12} {'GPU':<20} {'RAM':<8} {'$/hr':<10} {'Location':<20}")
    print("-" * 75)
    for o in offers[:5]:
        print(f"{o['id']:<12} {o.get('gpu_name', 'N/A'):<20} {o.get('gpu_ram', 0):<8.0f} ${o.get('dph_total', 0):<9.4f} {o.get('geolocation', 'N/A'):<20}")

    # Cost estimate
    best = offers[0]
    est_time_min = len(images) * 3  # ~3 min per clip on fast GPU
    est_cost = (est_time_min / 60 + 0.5) * best['dph_total']  # +30 min for setup

    print(f"\nEstimated: {est_time_min} min processing + 30 min setup = ${est_cost:.2f}")

    if args.dry_run:
        print("\n(Dry run - no instance created)")
        return

    # Confirm
    if not args.yes:
        response = input("\nProceed with cheapest option? [y/N] ")
        if response.lower() != "y":
            print("Cancelled")
            return
    else:
        print("\n--yes flag: proceeding automatically")

    instance_id = args.instance
    instance_info = None

    try:
        if not instance_id:
            # Create instance
            print(f"\nCreating instance from offer {best['id']}...")
            instance_id = create_instance(best['id'])
            print(f"Created instance: {instance_id}")

            # Wait for ready
            instance_info = wait_for_instance(instance_id)
        else:
            instance_info = get_instance_info(instance_id)
            if not instance_info:
                print(f"Instance {instance_id} not found")
                sys.exit(1)

        ssh_host = instance_info.get("ssh_host", "").split(":")[0]
        ssh_port = int(instance_info.get("ssh_port", 22))
        public_ip = instance_info.get("public_ipaddr", ssh_host)

        print(f"\nInstance ready!")
        print(f"  SSH: ssh -p {ssh_port} root@{ssh_host}")

        # Find SSH key
        ssh_key = Path.home() / ".ssh" / "id_ed25519_vastai"
        if not ssh_key.exists():
            ssh_key = Path.home() / ".ssh" / "id_ed25519"
        if not ssh_key.exists():
            ssh_key = Path.home() / ".ssh" / "id_rsa"
        ssh_opts = f"-o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o ConnectTimeout=10 -i {ssh_key}"

        # Get ComfyUI port from port mappings
        ports = instance_info.get("ports", {})
        comfy_port = 8188
        for port_key, port_info in (ports.items() if isinstance(ports, dict) else []):
            if "8188" in str(port_key):
                if isinstance(port_info, list) and port_info:
                    comfy_port = port_info[0].get("HostPort", 8188)
                break

        comfy_url = f"http://{public_ip}:{comfy_port}"

        # Wait for ComfyUI setup to complete (downloads ~18GB of models)
        # Check both SSH connectivity AND ComfyUI input directory exists
        print(f"  Waiting for setup to complete (this can take 5-10 minutes for model downloads)...")

        comfy_ready = False
        for attempt in range(90):  # Wait up to 15 minutes
            elapsed = attempt * 10

            # First check if SSH works and input directory exists
            try:
                ssh_check = subprocess.run(
                    f"ssh {ssh_opts} -p {ssh_port} root@{ssh_host} 'test -d /root/comfy/ComfyUI/input && echo OK'",
                    shell=True, capture_output=True, text=True, timeout=20
                )
            except subprocess.TimeoutExpired:
                if attempt % 6 == 0:
                    print(f"    SSH connection timed out, retrying... ({elapsed}s)")
                await asyncio.sleep(10)
                continue

            if ssh_check.returncode == 0 and "OK" in ssh_check.stdout:
                # SSH works and directory exists, now check ComfyUI API
                try:
                    async with httpx.AsyncClient(timeout=10) as client:
                        resp = await client.get(f"{comfy_url}/system_stats")
                        if resp.status_code == 200:
                            print(f"  ComfyUI ready! (took {elapsed}s)")
                            comfy_ready = True
                            break
                except Exception:
                    pass

                if attempt % 3 == 0:
                    print(f"    ComfyUI directory exists, waiting for API... ({elapsed}s)")
            else:
                if attempt % 6 == 0:
                    print(f"    Setup in progress... ({elapsed}s)")

            await asyncio.sleep(10)

        if not comfy_ready:
            print("  Warning: ComfyUI setup may not be complete, but proceeding...")

        # Run batch
        downloaded = await run_batch(
            instance_info,
            args.images,
            args.output,
            args.motion,
            args.steps,
            args.frames,
        )

        print(f"\nComplete! Downloaded {len(downloaded)} videos to {args.output}")

    finally:
        if instance_id and not args.instance:
            if not args.yes:
                response = input("\nDestroy instance? [Y/n] ")
                if response.lower() != "n":
                    destroy_instance(instance_id)
            else:
                # Auto-destroy with --yes flag
                destroy_instance(instance_id)


if __name__ == "__main__":
    asyncio.run(main())

#!/usr/bin/env python3
"""
AI Video Production Cost Calculator

Compares costs across different approaches:
- Full local (M4 Max)
- Hybrid (local images + cloud I2V)
- Cloud-only (Vast.ai, RunPod)
- SaaS platforms (InVideo, Runway)
"""

import argparse
from dataclasses import dataclass
from enum import Enum
from typing import Optional


class Provider(Enum):
    LOCAL_M4_MAX = "local_m4_max"
    VASTAI_H100 = "vastai_h100"
    RUNPOD_H100 = "runpod_h100"
    RUNPOD_A100 = "runpod_a100"
    LAMBDA_H100 = "lambda_h100"
    INVIDEO_PLUS = "invideo_plus"
    INVIDEO_MAX = "invideo_max"
    RUNWAY_GEN4 = "runway_gen4"


@dataclass
class ProviderConfig:
    name: str
    hourly_cost: float  # $/hr for cloud, monthly for SaaS
    i2v_time_per_clip: float  # minutes
    image_time: float  # seconds per image
    monthly_minutes: Optional[int] = None  # For SaaS platforms
    is_saas: bool = False
    is_local: bool = False


PROVIDERS = {
    Provider.LOCAL_M4_MAX: ProviderConfig(
        name="Local M4 Max (128GB)",
        hourly_cost=0.0,  # Just electricity
        i2v_time_per_clip=90,  # 15 min/step × 6 steps
        image_time=45,  # seconds
        is_local=True,
    ),
    Provider.VASTAI_H100: ProviderConfig(
        name="Vast.ai H100 80GB",
        hourly_cost=1.87,
        i2v_time_per_clip=2,  # minutes
        image_time=5,  # seconds
    ),
    Provider.RUNPOD_H100: ProviderConfig(
        name="RunPod H100 80GB",
        hourly_cost=1.99,
        i2v_time_per_clip=2,
        image_time=5,
    ),
    Provider.RUNPOD_A100: ProviderConfig(
        name="RunPod A100 80GB",
        hourly_cost=1.74,
        i2v_time_per_clip=3,
        image_time=7,
    ),
    Provider.LAMBDA_H100: ProviderConfig(
        name="Lambda Labs H100",
        hourly_cost=2.99,
        i2v_time_per_clip=2,
        image_time=5,
    ),
    Provider.INVIDEO_PLUS: ProviderConfig(
        name="InVideo Plus",
        hourly_cost=20.0,  # monthly
        i2v_time_per_clip=0.5,  # Their pipeline
        image_time=0,  # Included
        monthly_minutes=50,
        is_saas=True,
    ),
    Provider.INVIDEO_MAX: ProviderConfig(
        name="InVideo Max",
        hourly_cost=48.0,  # monthly
        i2v_time_per_clip=0.5,
        image_time=0,
        monthly_minutes=200,
        is_saas=True,
    ),
    Provider.RUNWAY_GEN4: ProviderConfig(
        name="Runway Gen-4",
        hourly_cost=0.05,  # per second of video
        i2v_time_per_clip=0.5,
        image_time=0,
        is_saas=True,
    ),
}


def calculate_project_cost(
    num_shots: int,
    clip_duration: float,  # seconds
    provider: Provider,
    include_images: bool = True,
) -> dict:
    """Calculate total cost for a video project."""
    config = PROVIDERS[provider]

    result = {
        "provider": config.name,
        "num_shots": num_shots,
        "clip_duration": clip_duration,
        "total_video_seconds": num_shots * clip_duration,
    }

    if config.is_local:
        # Local processing - just time cost
        image_time = (num_shots * config.image_time) / 60  # minutes
        i2v_time = num_shots * config.i2v_time_per_clip  # minutes
        total_time = image_time + i2v_time

        result["image_generation_min"] = round(image_time, 1)
        result["i2v_generation_min"] = round(i2v_time, 1)
        result["total_time_hours"] = round(total_time / 60, 2)
        result["cost"] = 0.0
        result["cost_note"] = "Free (electricity ~$0.50)"

    elif config.is_saas:
        if provider == Provider.RUNWAY_GEN4:
            # Runway charges per second
            total_seconds = num_shots * clip_duration
            result["cost"] = round(total_seconds * config.hourly_cost, 2)
            result["cost_note"] = f"${config.hourly_cost}/sec of video"
        else:
            # InVideo-style - monthly subscription
            total_minutes = (num_shots * clip_duration) / 60
            if config.monthly_minutes and total_minutes <= config.monthly_minutes:
                result["cost"] = config.hourly_cost
                result["cost_note"] = f"Monthly subscription (includes {config.monthly_minutes} min)"
                result["minutes_used"] = round(total_minutes, 1)
                result["minutes_remaining"] = round(config.monthly_minutes - total_minutes, 1)
            else:
                result["cost"] = config.hourly_cost * 2  # Need higher tier
                result["cost_note"] = "Exceeds plan limits"

    else:
        # Cloud GPU
        image_time = (num_shots * config.image_time) / 60 if include_images else 0
        i2v_time = num_shots * config.i2v_time_per_clip
        total_minutes = image_time + i2v_time
        total_hours = total_minutes / 60

        # Add 15 min startup overhead
        total_hours += 0.25

        result["image_generation_min"] = round(image_time, 1)
        result["i2v_generation_min"] = round(i2v_time, 1)
        result["total_gpu_hours"] = round(total_hours, 2)
        result["cost"] = round(total_hours * config.hourly_cost, 2)
        result["cost_note"] = f"${config.hourly_cost}/hr"

    return result


def calculate_hybrid_cost(
    num_shots: int,
    clip_duration: float,
    cloud_provider: Provider = Provider.VASTAI_H100,
) -> dict:
    """Calculate cost for hybrid approach (local images + cloud I2V)."""
    local_config = PROVIDERS[Provider.LOCAL_M4_MAX]
    cloud_config = PROVIDERS[cloud_provider]

    # Images locally
    image_time = (num_shots * local_config.image_time) / 60  # minutes

    # I2V on cloud
    i2v_time = num_shots * cloud_config.i2v_time_per_clip  # minutes
    i2v_hours = (i2v_time + 15) / 60  # Add startup overhead

    cloud_cost = i2v_hours * cloud_config.hourly_cost

    return {
        "approach": "Hybrid (Local images + Cloud I2V)",
        "num_shots": num_shots,
        "clip_duration": clip_duration,
        "local_image_time_min": round(image_time, 1),
        "cloud_provider": cloud_config.name,
        "cloud_i2v_time_min": round(i2v_time, 1),
        "cloud_hours": round(i2v_hours, 2),
        "cloud_cost": round(cloud_cost, 2),
        "total_cost": round(cloud_cost, 2),
        "total_time_hours": round((image_time + i2v_time) / 60, 2),
    }


def compare_all(num_shots: int, clip_duration: float) -> None:
    """Compare all providers for a given project."""
    print(f"\n{'='*70}")
    print(f"Cost Comparison: {num_shots} shots × {clip_duration}s = {num_shots * clip_duration}s total video")
    print(f"{'='*70}\n")

    results = []

    # Cloud/Local providers
    for provider in [
        Provider.LOCAL_M4_MAX,
        Provider.VASTAI_H100,
        Provider.RUNPOD_H100,
        Provider.RUNPOD_A100,
    ]:
        r = calculate_project_cost(num_shots, clip_duration, provider)
        results.append(r)

    # Hybrid
    hybrid = calculate_hybrid_cost(num_shots, clip_duration)
    results.append({
        "provider": hybrid["approach"],
        "cost": hybrid["total_cost"],
        "total_time_hours": hybrid["total_time_hours"],
        "cost_note": f"via {hybrid['cloud_provider']}",
    })

    # SaaS
    for provider in [Provider.INVIDEO_MAX, Provider.RUNWAY_GEN4]:
        r = calculate_project_cost(num_shots, clip_duration, provider)
        results.append(r)

    # Sort by cost
    results.sort(key=lambda x: x.get("cost", 0))

    # Display
    print(f"{'Provider':<35} {'Cost':>10} {'Time':>12} {'Notes':<25}")
    print("-" * 85)

    for r in results:
        cost_str = f"${r['cost']:.2f}" if r['cost'] > 0 else "FREE"
        time_str = f"{r.get('total_time_hours', 'N/A')} hrs" if 'total_time_hours' in r else "Quick"
        notes = r.get('cost_note', '')[:25]
        print(f"{r['provider']:<35} {cost_str:>10} {time_str:>12} {notes:<25}")

    print("\n" + "="*70)
    print("RECOMMENDATION:")

    # Find best value
    cheapest = min([r for r in results if r['cost'] > 0], key=lambda x: x['cost'])
    print(f"  Best Value: {cheapest['provider']} at ${cheapest['cost']:.2f}")

    local = next(r for r in results if 'Local' in r['provider'])
    if local['total_time_hours'] < 4:
        print(f"  Best for Quick Projects: Local M4 Max ({local['total_time_hours']} hrs, free)")
    else:
        print(f"  Local Too Slow: {local['total_time_hours']} hrs - use cloud")

    print("="*70)


def monthly_comparison(videos_per_month: int, shots_per_video: int, clip_duration: float) -> None:
    """Compare monthly costs for regular production."""
    print(f"\n{'='*70}")
    print(f"Monthly Cost: {videos_per_month} videos × {shots_per_video} shots × {clip_duration}s")
    print(f"{'='*70}\n")

    total_shots = videos_per_month * shots_per_video
    total_seconds = total_shots * clip_duration
    total_minutes = total_seconds / 60

    print(f"Total monthly: {total_shots} shots, {total_minutes:.1f} minutes of video\n")

    comparisons = [
        ("InVideo Plus ($20/mo)", 20 if total_minutes <= 50 else "Exceeds limit"),
        ("InVideo Max ($48/mo)", 48 if total_minutes <= 200 else "Exceeds limit"),
        ("Runway Gen-4", round(total_seconds * 0.05, 2)),
        ("Hybrid (Vast.ai)", round(calculate_hybrid_cost(total_shots, clip_duration)["total_cost"], 2)),
        ("Full Cloud (Vast.ai)", round(calculate_project_cost(total_shots, clip_duration, Provider.VASTAI_H100)["cost"], 2)),
        ("Full Local (M4 Max)", "FREE (but slow)"),
    ]

    print(f"{'Approach':<30} {'Monthly Cost':>15}")
    print("-" * 50)
    for name, cost in comparisons:
        cost_str = f"${cost}" if isinstance(cost, (int, float)) else cost
        print(f"{name:<30} {cost_str:>15}")


def main():
    parser = argparse.ArgumentParser(description="AI Video Production Cost Calculator")
    parser.add_argument("--shots", type=int, default=10, help="Number of shots/clips")
    parser.add_argument("--duration", type=float, default=5.0, help="Duration per clip (seconds)")
    parser.add_argument("--monthly", type=int, help="Videos per month (for monthly comparison)")
    parser.add_argument("--provider", type=str, help="Specific provider to calculate")

    args = parser.parse_args()

    if args.monthly:
        monthly_comparison(args.monthly, args.shots, args.duration)
    elif args.provider:
        try:
            provider = Provider[args.provider.upper()]
            result = calculate_project_cost(args.shots, args.duration, provider)
            print(f"\n{result['provider']}:")
            for k, v in result.items():
                if k != 'provider':
                    print(f"  {k}: {v}")
        except KeyError:
            print(f"Unknown provider: {args.provider}")
            print(f"Available: {[p.name for p in Provider]}")
    else:
        compare_all(args.shots, args.duration)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Motion Graphics Generator

Programmatically generate title cards, lower thirds, data visualizations,
and other synthetic video elements with modern 2025 aesthetics.

Styles:
- neo_brutalist: Raw, glitchy, utilitarian
- deep_glow: Intense light blooms, layered neons
- liquid_motion: Fluid, morphing typography
- retro_revival: 80s/90s grain and neon
- glass_morphism: Frosted glass, depth layers
"""

import argparse
import json
import math
import os
import subprocess
import tempfile
from dataclasses import dataclass
from enum import Enum
from pathlib import Path
from typing import Optional


class Style(Enum):
    NEO_BRUTALIST = "neo_brutalist"
    DEEP_GLOW = "deep_glow"
    LIQUID_MOTION = "liquid_motion"
    RETRO_REVIVAL = "retro_revival"
    GLASS_MORPHISM = "glass_morphism"


@dataclass
class ColorPalette:
    background: str
    primary: str
    secondary: str
    accent: str
    text: str
    glow: Optional[str] = None


PALETTES = {
    Style.NEO_BRUTALIST: ColorPalette(
        background="#0a0a0a",
        primary="#ff3366",
        secondary="#00ff88",
        accent="#ffff00",
        text="#ffffff",
    ),
    Style.DEEP_GLOW: ColorPalette(
        background="#0d0d1a",
        primary="#7c3aed",
        secondary="#06b6d4",
        accent="#f472b6",
        text="#ffffff",
        glow="#7c3aed",
    ),
    Style.LIQUID_MOTION: ColorPalette(
        background="#1a1a2e",
        primary="#4361ee",
        secondary="#3a0ca3",
        accent="#f72585",
        text="#ffffff",
        glow="#4361ee",
    ),
    Style.RETRO_REVIVAL: ColorPalette(
        background="#1a0a2e",
        primary="#ff006e",
        secondary="#8338ec",
        accent="#ffbe0b",
        text="#ffffff",
        glow="#ff006e",
    ),
    Style.GLASS_MORPHISM: ColorPalette(
        background="#0f172a",
        primary="#38bdf8",
        secondary="#818cf8",
        accent="#f472b6",
        text="#f8fafc",
        glow="#38bdf8",
    ),
}


def generate_svg_title_card(
    title: str,
    subtitle: Optional[str] = None,
    style: Style = Style.DEEP_GLOW,
    width: int = 1920,
    height: int = 1080,
) -> str:
    """Generate an SVG title card."""
    palette = PALETTES[style]

    # Base SVG
    svg_parts = [
        f'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 {width} {height}">',
        '<defs>',
    ]

    # Add glow filter for styles that use it
    if palette.glow:
        svg_parts.append(f'''
        <filter id="glow" x="-50%" y="-50%" width="200%" height="200%">
            <feGaussianBlur stdDeviation="20" result="coloredBlur"/>
            <feMerge>
                <feMergeNode in="coloredBlur"/>
                <feMergeNode in="coloredBlur"/>
                <feMergeNode in="SourceGraphic"/>
            </feMerge>
        </filter>
        ''')

    # Gradient for text
    svg_parts.append(f'''
        <linearGradient id="textGradient" x1="0%" y1="0%" x2="100%" y2="100%">
            <stop offset="0%" style="stop-color:{palette.primary}"/>
            <stop offset="100%" style="stop-color:{palette.secondary}"/>
        </linearGradient>
    </defs>
    ''')

    # Background
    svg_parts.append(f'<rect width="{width}" height="{height}" fill="{palette.background}"/>')

    # Style-specific decorations
    if style == Style.NEO_BRUTALIST:
        # Grid lines
        for i in range(0, width, 100):
            opacity = 0.1 if i % 200 == 0 else 0.05
            svg_parts.append(f'<line x1="{i}" y1="0" x2="{i}" y2="{height}" stroke="{palette.text}" stroke-opacity="{opacity}"/>')
        for i in range(0, height, 100):
            opacity = 0.1 if i % 200 == 0 else 0.05
            svg_parts.append(f'<line x1="0" y1="{i}" x2="{width}" y2="{i}" stroke="{palette.text}" stroke-opacity="{opacity}"/>')
        # Accent block
        svg_parts.append(f'<rect x="60" y="{height//2 - 80}" width="20" height="160" fill="{palette.accent}"/>')

    elif style == Style.DEEP_GLOW:
        # Ambient glow circles
        svg_parts.append(f'<circle cx="{width//4}" cy="{height//3}" r="300" fill="{palette.primary}" opacity="0.1"/>')
        svg_parts.append(f'<circle cx="{3*width//4}" cy="{2*height//3}" r="250" fill="{palette.secondary}" opacity="0.1"/>')

    elif style == Style.GLASS_MORPHISM:
        # Frosted glass panel
        svg_parts.append(f'''
        <rect x="{width//4}" y="{height//4}" width="{width//2}" height="{height//2}"
              rx="20" fill="{palette.background}" fill-opacity="0.5"
              stroke="{palette.primary}" stroke-opacity="0.3"/>
        ''')

    # Title text
    title_y = height // 2 - (50 if subtitle else 0)
    font_size = min(120, width // (len(title) * 0.7))

    filter_attr = 'filter="url(#glow)"' if palette.glow else ''
    svg_parts.append(f'''
    <text x="{width//2}" y="{title_y}"
          font-family="SF Pro Display, -apple-system, sans-serif"
          font-size="{font_size}" font-weight="700"
          fill="url(#textGradient)" text-anchor="middle" {filter_attr}>
        {title}
    </text>
    ''')

    # Subtitle
    if subtitle:
        svg_parts.append(f'''
        <text x="{width//2}" y="{title_y + 80}"
              font-family="SF Pro Display, -apple-system, sans-serif"
              font-size="36" font-weight="400"
              fill="{palette.text}" fill-opacity="0.8" text-anchor="middle">
            {subtitle}
        </text>
        ''')

    svg_parts.append('</svg>')
    return '\n'.join(svg_parts)


def generate_svg_lower_third(
    name: str,
    title: str,
    style: Style = Style.DEEP_GLOW,
    width: int = 1920,
    height: int = 1080,
    position: str = "left",  # left, right, center
) -> str:
    """Generate an SVG lower third overlay."""
    palette = PALETTES[style]

    # Calculate position
    if position == "left":
        x_offset = 80
        text_anchor = "start"
    elif position == "right":
        x_offset = width - 80
        text_anchor = "end"
    else:
        x_offset = width // 2
        text_anchor = "middle"

    y_base = height - 150

    svg = f'''<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 {width} {height}">
    <defs>
        <linearGradient id="barGradient" x1="0%" y1="0%" x2="100%" y2="0%">
            <stop offset="0%" style="stop-color:{palette.primary}"/>
            <stop offset="100%" style="stop-color:{palette.secondary}"/>
        </linearGradient>
        <filter id="shadow" x="-20%" y="-20%" width="140%" height="140%">
            <feDropShadow dx="0" dy="4" stdDeviation="8" flood-color="#000" flood-opacity="0.5"/>
        </filter>
    </defs>

    <!-- Background bar -->
    <rect x="{x_offset - 20 if position == 'left' else 0}" y="{y_base - 20}"
          width="500" height="100" rx="4"
          fill="{palette.background}" fill-opacity="0.85" filter="url(#shadow)"/>

    <!-- Accent line -->
    <rect x="{x_offset - 20 if position == 'left' else x_offset - 480}" y="{y_base - 20}"
          width="4" height="100" fill="url(#barGradient)"/>

    <!-- Name -->
    <text x="{x_offset}" y="{y_base + 25}"
          font-family="SF Pro Display, -apple-system, sans-serif"
          font-size="32" font-weight="600"
          fill="{palette.text}" text-anchor="{text_anchor}">
        {name}
    </text>

    <!-- Title -->
    <text x="{x_offset}" y="{y_base + 60}"
          font-family="SF Pro Display, -apple-system, sans-serif"
          font-size="22" font-weight="400"
          fill="{palette.text}" fill-opacity="0.7" text-anchor="{text_anchor}">
        {title}
    </text>
</svg>'''
    return svg


def generate_svg_data_chart(
    data: list[dict],  # [{"label": "A", "value": 75}, ...]
    chart_type: str = "bar",  # bar, horizontal_bar, radial
    title: Optional[str] = None,
    style: Style = Style.DEEP_GLOW,
    width: int = 1920,
    height: int = 1080,
) -> str:
    """Generate an SVG data visualization."""
    palette = PALETTES[style]
    max_value = max(d["value"] for d in data)

    svg_parts = [
        f'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 {width} {height}">',
        '<defs>',
        f'''<linearGradient id="barFill" x1="0%" y1="100%" x2="0%" y2="0%">
            <stop offset="0%" style="stop-color:{palette.primary}"/>
            <stop offset="100%" style="stop-color:{palette.secondary}"/>
        </linearGradient>''',
    ]

    if palette.glow:
        svg_parts.append(f'''
        <filter id="barGlow" x="-50%" y="-50%" width="200%" height="200%">
            <feGaussianBlur stdDeviation="8" result="coloredBlur"/>
            <feMerge>
                <feMergeNode in="coloredBlur"/>
                <feMergeNode in="SourceGraphic"/>
            </feMerge>
        </filter>
        ''')

    svg_parts.append('</defs>')
    svg_parts.append(f'<rect width="{width}" height="{height}" fill="{palette.background}"/>')

    # Title
    if title:
        svg_parts.append(f'''
        <text x="{width//2}" y="80"
              font-family="SF Pro Display, -apple-system, sans-serif"
              font-size="48" font-weight="600"
              fill="{palette.text}" text-anchor="middle">
            {title}
        </text>
        ''')

    chart_area_top = 150 if title else 80
    chart_area_height = height - chart_area_top - 120
    chart_area_width = width - 200

    if chart_type == "bar":
        bar_width = min(80, chart_area_width // len(data) - 20)
        bar_spacing = chart_area_width // len(data)

        for i, d in enumerate(data):
            bar_height = (d["value"] / max_value) * chart_area_height
            x = 100 + i * bar_spacing + (bar_spacing - bar_width) // 2
            y = chart_area_top + chart_area_height - bar_height

            filter_attr = 'filter="url(#barGlow)"' if palette.glow else ''
            svg_parts.append(f'''
            <rect x="{x}" y="{y}" width="{bar_width}" height="{bar_height}"
                  rx="4" fill="url(#barFill)" {filter_attr}/>
            <text x="{x + bar_width//2}" y="{chart_area_top + chart_area_height + 40}"
                  font-family="SF Pro Display, -apple-system, sans-serif"
                  font-size="20" fill="{palette.text}" fill-opacity="0.7" text-anchor="middle">
                {d["label"]}
            </text>
            <text x="{x + bar_width//2}" y="{y - 15}"
                  font-family="SF Pro Display, -apple-system, sans-serif"
                  font-size="24" font-weight="600" fill="{palette.text}" text-anchor="middle">
                {d["value"]}
            </text>
            ''')

    elif chart_type == "radial":
        cx, cy = width // 2, height // 2 + 30
        radius = min(chart_area_width, chart_area_height) // 3

        for i, d in enumerate(data):
            angle = (i / len(data)) * 2 * math.pi - math.pi / 2
            bar_length = (d["value"] / max_value) * radius

            x1 = cx + math.cos(angle) * 50
            y1 = cy + math.sin(angle) * 50
            x2 = cx + math.cos(angle) * (50 + bar_length)
            y2 = cy + math.sin(angle) * (50 + bar_length)

            svg_parts.append(f'''
            <line x1="{x1}" y1="{y1}" x2="{x2}" y2="{y2}"
                  stroke="url(#barFill)" stroke-width="20" stroke-linecap="round"/>
            ''')

            # Label
            label_x = cx + math.cos(angle) * (radius + 80)
            label_y = cy + math.sin(angle) * (radius + 80)
            svg_parts.append(f'''
            <text x="{label_x}" y="{label_y}"
                  font-family="SF Pro Display, -apple-system, sans-serif"
                  font-size="18" fill="{palette.text}" text-anchor="middle" dominant-baseline="middle">
                {d["label"]}
            </text>
            ''')

    svg_parts.append('</svg>')
    return '\n'.join(svg_parts)


def svg_to_png(svg_content: str, output_path: Path, width: int = 1920, height: int = 1080) -> Path:
    """Convert SVG to PNG using system tools."""
    with tempfile.NamedTemporaryFile(mode='w', suffix='.svg', delete=False) as f:
        f.write(svg_content)
        svg_path = f.name

    try:
        # Try rsvg-convert first (best quality)
        result = subprocess.run(
            ['rsvg-convert', '-w', str(width), '-h', str(height), '-o', str(output_path), svg_path],
            capture_output=True
        )
        if result.returncode == 0:
            return output_path
    except FileNotFoundError:
        pass

    try:
        # Fall back to ImageMagick
        subprocess.run(
            ['convert', '-background', 'none', '-density', '150', svg_path, str(output_path)],
            check=True, capture_output=True
        )
        return output_path
    except (FileNotFoundError, subprocess.CalledProcessError):
        pass

    # Last resort: save as SVG
    svg_output = output_path.with_suffix('.svg')
    with open(svg_output, 'w') as f:
        f.write(svg_content)
    print(f"Warning: Could not convert to PNG, saved as SVG: {svg_output}")
    return svg_output


def generate_animated_title(
    title: str,
    subtitle: Optional[str] = None,
    style: Style = Style.DEEP_GLOW,
    duration: float = 3.0,
    fps: int = 30,
    output_path: Path = Path("title_animated.mp4"),
) -> Path:
    """Generate an animated title card video using FFmpeg."""
    palette = PALETTES[style]
    width, height = 1920, 1080

    with tempfile.TemporaryDirectory() as tmpdir:
        tmpdir = Path(tmpdir)

        # Generate frames
        total_frames = int(duration * fps)

        for frame in range(total_frames):
            progress = frame / total_frames

            # Animation: fade in (0-30%), hold (30-70%), fade out (70-100%)
            if progress < 0.3:
                opacity = progress / 0.3
                scale = 0.9 + 0.1 * (progress / 0.3)
            elif progress > 0.7:
                opacity = 1 - (progress - 0.7) / 0.3
                scale = 1.0
            else:
                opacity = 1.0
                scale = 1.0

            # Generate SVG with animation state
            svg = generate_svg_title_card(title, subtitle, style, width, height)

            # Apply opacity via group wrapper
            svg = svg.replace(
                '</defs>',
                f'</defs><g opacity="{opacity}" transform="translate({width/2}, {height/2}) scale({scale}) translate({-width/2}, {-height/2})">'
            ).replace('</svg>', '</g></svg>')

            frame_path = tmpdir / f"frame_{frame:04d}.png"
            svg_to_png(svg, frame_path, width, height)

        # Combine frames with FFmpeg
        subprocess.run([
            'ffmpeg', '-y', '-framerate', str(fps),
            '-i', str(tmpdir / 'frame_%04d.png'),
            '-c:v', 'libx264', '-pix_fmt', 'yuv420p',
            '-preset', 'medium', '-crf', '18',
            str(output_path)
        ], check=True, capture_output=True)

    return output_path


def main():
    parser = argparse.ArgumentParser(description="Motion Graphics Generator")
    parser.add_argument("--type", choices=["title", "lower_third", "chart"], default="title")
    parser.add_argument("--style", choices=[s.value for s in Style], default="deep_glow")
    parser.add_argument("--title", type=str, default="Your Title Here")
    parser.add_argument("--subtitle", type=str, default=None)
    parser.add_argument("--output", type=Path, default=Path("output.png"))
    parser.add_argument("--animated", action="store_true", help="Generate animated video")
    parser.add_argument("--duration", type=float, default=3.0, help="Animation duration (seconds)")
    parser.add_argument("--data", type=str, help="JSON data for charts")
    parser.add_argument("--chart-type", choices=["bar", "horizontal_bar", "radial"], default="bar")
    parser.add_argument("--width", type=int, default=1920)
    parser.add_argument("--height", type=int, default=1080)
    parser.add_argument("--list-styles", action="store_true", help="List available styles")

    args = parser.parse_args()

    if args.list_styles:
        print("Available Styles:")
        for style in Style:
            palette = PALETTES[style]
            print(f"\n  {style.value}:")
            print(f"    Background: {palette.background}")
            print(f"    Primary: {palette.primary}")
            print(f"    Secondary: {palette.secondary}")
            print(f"    Accent: {palette.accent}")
        return

    style = Style(args.style)

    if args.type == "title":
        if args.animated:
            output = generate_animated_title(
                args.title,
                args.subtitle,
                style,
                args.duration,
                output_path=args.output.with_suffix('.mp4'),
            )
            print(f"Generated animated title: {output}")
        else:
            svg = generate_svg_title_card(
                args.title,
                args.subtitle,
                style,
                args.width,
                args.height,
            )
            output = svg_to_png(svg, args.output, args.width, args.height)
            print(f"Generated title card: {output}")

    elif args.type == "lower_third":
        svg = generate_svg_lower_third(
            args.title,
            args.subtitle or "Title",
            style,
            args.width,
            args.height,
        )
        output = svg_to_png(svg, args.output, args.width, args.height)
        print(f"Generated lower third: {output}")

    elif args.type == "chart":
        if args.data:
            data = json.loads(args.data)
        else:
            # Sample data
            data = [
                {"label": "Jan", "value": 65},
                {"label": "Feb", "value": 78},
                {"label": "Mar", "value": 90},
                {"label": "Apr", "value": 81},
                {"label": "May", "value": 95},
            ]

        svg = generate_svg_data_chart(
            data,
            args.chart_type,
            args.title,
            style,
            args.width,
            args.height,
        )
        output = svg_to_png(svg, args.output, args.width, args.height)
        print(f"Generated chart: {output}")


if __name__ == "__main__":
    main()