from __future__ import annotations

import json
from pathlib import Path
from typing import Any

import gradio as gr
import uvicorn

from api import api, job_manager, project_manager, settings
from renderer import RenderEngine
from renderer.core.models import AIReelsRequest
from renderer.scenes import Timeline
from renderer.studio import capability_catalog
from renderer.templates import apply_creative_style, apply_preset, list_creative_styles, list_platform_profiles, list_templates


def _mcp_description(summary: str, example: dict[str, Any]) -> str:
    """Build a concise MCP description with a machine-readable JSON example."""
    payload = json.dumps(example, indent=2, ensure_ascii=True)
    return f"{summary}\n\nExample JSON:\n```json\n{payload}\n```"


def create_dashboard() -> gr.Blocks:
    with gr.Blocks(title="Ava2lon Studio AI") as dashboard:
        gr.Markdown(
            "# Ava2lon Studio AI\n"
            "CPU-first CapCut-class video automation studio with REST API parity, async jobs, webhooks, and project JSON."
        )
        with gr.Tab("Projects"):
            project_name = gr.Textbox(label="Project name", value="Untitled Ava2lon Project")
            project_metadata = gr.Textbox(label="Metadata JSON", lines=5, value=json.dumps({"platform": "tiktok"}, indent=2))
            project_create = gr.Button("Create Project", variant="primary")
            project_list = gr.Button("Refresh Projects")
            project_output = gr.JSON(label="Projects")
            project_create.click(fn=create_project, inputs=[project_name, project_metadata], outputs=project_output, api_name="create_project", api_description=_mcp_description("Create a project from a name and JSON metadata object.", {"name": "Campaign 01", "metadata_json": '{"platform":"tiktok"}'}))
            project_list.click(fn=list_projects, outputs=project_output, api_name="list_projects", api_description=_mcp_description("List saved studio projects.", {}))

        with gr.Tab("Assets"):
            gr.Markdown("Use `/upload` or `/assets/upload` for multipart assets, then attach them to a project with `/project/assets/add`.")
            asset_project_id = gr.Textbox(label="Project ID")
            asset_json = gr.Textbox(label="Asset JSON", lines=6, value=json.dumps({"path": "clip.mp4", "kind": "video"}, indent=2))
            asset_button = gr.Button("Attach Asset", variant="primary")
            asset_output = gr.JSON(label="Project")
            asset_button.click(fn=add_project_asset, inputs=[asset_project_id, asset_json], outputs=asset_output, api_name="add_project_asset", api_description=_mcp_description("Attach a media asset JSON object to an existing project.", {"project_id": "project_123", "asset_json": '{"path":"clip.mp4","kind":"video"}'}))

        with gr.Tab("Timeline"):
            timeline_project_id = gr.Textbox(label="Project ID")
            timeline_track_type = gr.Dropdown(choices=["video", "audio", "text", "overlay", "sticker", "subtitle"], value="video", label="Track type")
            timeline_item = gr.Textbox(
                label="Timeline item JSON",
                lines=8,
                value=json.dumps({"media": "clip.mp4", "start": 0, "duration": 5, "caption": "Hook"}, indent=2),
            )
            timeline_add_button = gr.Button("Add To Timeline", variant="primary")
            timeline_output = gr.JSON(label="Project")
            timeline_add_button.click(fn=add_timeline_item, inputs=[timeline_project_id, timeline_track_type, timeline_item], outputs=timeline_output, api_name="add_timeline_item", api_description=_mcp_description("Add a typed item to a project timeline.", {"project_id": "project_123", "track_type": "video", "item_json": '{"media":"clip.mp4","start":0,"duration":5,"caption":"Hook"}'}))

            timeline_operation_json = gr.Textbox(
                label="Operation JSON",
                lines=8,
                value=json.dumps({"operation": "split", "item_id": "clip_123", "params": {"offset": 2.5}}, indent=2),
            )
            timeline_operation_button = gr.Button("Apply Operation")
            timeline_operation_button.click(fn=apply_timeline_operation, inputs=[timeline_project_id, timeline_operation_json], outputs=timeline_output, api_name="apply_timeline_operation", api_description=_mcp_description("Apply a timeline operation such as split, trim, insert, or ripple delete.", {"project_id": "project_123", "operation_json": '{"operation":"split","item_id":"clip_123","params":{"offset":2.5}}'}))

        with gr.Tab("Templates"):
            template_button = gr.Button("Load Template Catalog")
            template_output = gr.JSON(label="Templates")
            template_button.click(fn=load_template_catalog, outputs=template_output, api_name="load_template_catalog", api_description=_mcp_description("Load available render and caption templates.", {}))

        with gr.Tab("Effects"):
            effect_button = gr.Button("Load Effect Catalog")
            effect_output = gr.JSON(label="Effects")
            effect_button.click(fn=load_effect_catalog, outputs=effect_output, api_name="load_effect_catalog", api_description=_mcp_description("Load available video effects.", {}))

        with gr.Tab("Filters"):
            filter_button = gr.Button("Load Filter Catalog")
            filter_output = gr.JSON(label="Filters")
            filter_button.click(fn=load_filter_catalog, outputs=filter_output, api_name="load_filter_catalog", api_description=_mcp_description("Load available video filters.", {}))

        with gr.Tab("Captions"):
            caption_text = gr.Textbox(label="Caption source text", lines=6)
            caption_button = gr.Button("Submit Caption Job", variant="primary")
            caption_output = gr.JSON(label="Caption Job")
            caption_button.click(fn=submit_caption_job, inputs=caption_text, outputs=caption_output, api_name="submit_caption_job", api_description=_mcp_description("Submit a caption-generation job from source text.", {"text": "Launch faster with automated rendering."}))

        with gr.Tab("Audio"):
            audio_button = gr.Button("Load Audio Catalog")
            audio_output = gr.JSON(label="Audio")
            audio_button.click(fn=load_audio_catalog, outputs=audio_output, api_name="load_audio_catalog", api_description=_mcp_description("Load audio-processing and music-generation capabilities.", {}))

        with gr.Tab("AI Tools"):
            ai_tool = gr.Dropdown(choices=capability_catalog()["ai_editing"], value="auto_viral_score", label="AI tool")
            ai_payload = gr.Textbox(label="AI payload JSON", lines=8, value=json.dumps({"platform": "tiktok", "text": "A strong opening hook"}, indent=2))
            ai_button = gr.Button("Submit AI Tool", variant="primary")
            ai_output = gr.JSON(label="AI Job")
            ai_button.click(fn=submit_ai_tool, inputs=[ai_tool, ai_payload], outputs=ai_output, api_name="submit_ai_tool", api_description=_mcp_description("Submit a configured AI editing tool job.", {"tool": "auto_viral_score", "payload": '{"platform":"tiktok","text":"A strong opening hook"}'}))

        with gr.Tab("Rendering"):
            render_json = gr.Textbox(
                label="Render JSON",
                lines=14,
                value="",
                placeholder="Paste a production render request JSON object with absolute or uploaded asset paths.",
            )
            render_button = gr.Button("Submit Render", variant="primary")
            render_output = gr.JSON(label="Submission")
            render_button.click(fn=submit_render_job, inputs=render_json, outputs=render_output, api_name="submit_render_job", api_description=_mcp_description("Submit a validated JSON video render job.", {"payload": '{"scenes":[{"start":0,"duration":5,"media":"clip.mp4","caption":"Opening hook"}],"platform":"tiktok","output_name":"render.mp4"}'}))

        with gr.Tab("AI Reels"):
            script = gr.Textbox(label="Script", lines=6)
            voiceover = gr.File(label="Voiceover", file_types=["audio"], type="filepath")
            assets = gr.File(label="Assets", file_count="multiple", type="filepath")
            template = gr.Dropdown(choices=list_templates(), value="tiktok_classic", label="Caption Template")
            creative_style = gr.Dropdown(choices=list_creative_styles(), value="viral_shorts", label="Creative Style")
            platform = gr.Dropdown(choices=list_platform_profiles(), value="tiktok", label="Platform")
            music = gr.File(label="Background Music", file_types=["audio"], type="filepath")
            ai_button = gr.Button("Submit AI Reel", variant="primary")
            ai_output = gr.JSON(label="Submission")
            ai_button.click(fn=submit_ai_reel, inputs=[script, voiceover, assets, template, creative_style, platform, music], outputs=ai_output, api_name="submit_ai_reel", api_description=_mcp_description("Create an AI reel from a script, voiceover, and visual assets. Upload files first and use the returned paths.", {"script": "Three automation tips.", "voiceover": "/tmp/voice.wav", "assets": ["/tmp/a.jpg", "/tmp/b.mp4"], "template": "tiktok_classic", "creative_style": "viral_shorts", "platform": "tiktok", "music": None}))

        with gr.Tab("Batch Render"):
            batch_json = gr.Textbox(label="Batch JSON", lines=14, value=json.dumps({"jobs": []}, indent=2))
            batch_button = gr.Button("Submit Batch", variant="primary")
            batch_output = gr.JSON(label="Batch Submission")
            batch_button.click(fn=submit_batch_render, inputs=batch_json, outputs=batch_output, api_name="submit_batch_render", api_description=_mcp_description("Submit multiple render jobs from a JSON batch.", {"payload": '{"jobs":[{"scenes":[{"start":0,"duration":3,"media":"clip.mp4"}],"output_name":"clip-a.mp4"}]}'}))

        with gr.Tab("Job Status"):
            status_job_id = gr.Textbox(label="Job ID")
            status_button = gr.Button("Refresh")
            status_output = gr.JSON(label="Status")
            status_button.click(fn=get_job_status, inputs=status_job_id, outputs=status_output, api_name="get_job_status", api_description=_mcp_description("Retrieve the current state and metrics for a job.", {"job_id": "job_abc123"}))

        with gr.Tab("Logs"):
            logs_job_id = gr.Textbox(label="Job ID")
            logs_button = gr.Button("Load Logs")
            logs_output = gr.Textbox(label="Logs", lines=20)
            logs_button.click(fn=get_job_logs, inputs=logs_job_id, outputs=logs_output, api_name="get_job_logs", api_description=_mcp_description("Retrieve execution logs for a job.", {"job_id": "job_abc123"}))

        with gr.Tab("Downloads"):
            download_job_id = gr.Textbox(label="Job ID")
            download_button = gr.Button("Get Output")
            download_output = gr.File(label="Rendered Video")
            download_button.click(fn=get_download_path, inputs=download_job_id, outputs=download_output, api_name="get_download_path", api_description=_mcp_description("Return the completed artifact path for a job.", {"job_id": "job_abc123"}))

        with gr.Tab("Transcribe"):
            transcribe_audio = gr.File(label="Audio or Video", file_types=["audio", "video"], type="filepath")
            transcribe_model = gr.Dropdown(
                choices=["tiny", "base", "small", "medium", "large-v3"],
                value=settings.whisper_model_size,
                label="Whisper Model",
            )
            transcribe_language = gr.Textbox(label="Language", placeholder="Optional ISO code, e.g. en")
            transcribe_button = gr.Button("Transcribe", variant="primary")
            transcribe_output = gr.JSON(label="Transcript")
            transcribe_button.click(
                fn=transcribe_audio_file,
                inputs=[transcribe_audio, transcribe_model, transcribe_language],
                outputs=transcribe_output,
                api_name="transcribe_audio_file",
                api_description=_mcp_description("Transcribe an uploaded audio or video file with word timestamps. Upload the file first and use its returned path.", {"path": "/tmp/interview.mp3", "model_size": "tiny", "language": "en"}),
            )

        with gr.Tab("Asset Inspector"):
            asset_path = gr.Textbox(label="Asset path")
            inspect_button = gr.Button("Inspect")
            inspect_output = gr.JSON(label="Metadata")
            inspect_button.click(fn=inspect_media_asset, inputs=asset_path, outputs=inspect_output, api_name="inspect_media_asset", api_description=_mcp_description("Inspect media codecs, streams, duration, and dimensions.", {"path": "/app/storage/video.mp4"}))

        with gr.Tab("AI Analysis"):
            analysis_media = gr.Textbox(label="Media URL or path")
            analysis_transcript = gr.Textbox(label="Transcript", lines=5)
            analysis_platform = gr.Dropdown(choices=list_platform_profiles(), value="tiktok", label="Target Platform")
            analysis_button = gr.Button("Submit Analysis", variant="primary")
            analysis_output = gr.JSON(label="Analysis Job")
            analysis_button.click(
                fn=submit_media_analysis,
                inputs=[analysis_media, analysis_transcript, analysis_platform],
                outputs=analysis_output,
                api_name="submit_media_analysis",
                api_description=_mcp_description("Analyze media for highlights, pacing, platform fit, and engagement signals.", {"media": "https://example.com/video.mp4", "transcript": "A strong opening hook and useful explanation.", "platform": "tiktok"}),
            )

        with gr.Tab("Clip Generator"):
            clip_media = gr.Textbox(label="Media URL or path")
            clip_json = gr.Textbox(label="Clip JSON", lines=6, value=json.dumps([{"start": 0, "end": 8}], indent=2))
            clip_button = gr.Button("Generate Clips", variant="primary")
            clip_output = gr.JSON(label="Clip Job")
            clip_button.click(fn=submit_clip_job, inputs=[clip_media, clip_json], outputs=clip_output, api_name="submit_clip_job", api_description=_mcp_description("Generate one or more clips from media and timed clip JSON.", {"media": "https://example.com/video.mp4", "clips_json": '[{"start":0,"end":8},{"start":20,"end":32}]'}))

        with gr.Tab("Metadata"):
            metadata_topic = gr.Textbox(label="Topic or transcript", lines=5)
            metadata_platform = gr.Dropdown(choices=list_platform_profiles(), value="tiktok", label="Platform")
            metadata_button = gr.Button("Generate Metadata", variant="primary")
            metadata_output = gr.JSON(label="Metadata Job")
            metadata_button.click(fn=submit_metadata_job, inputs=[metadata_topic, metadata_platform], outputs=metadata_output, api_name="submit_metadata_job", api_description=_mcp_description("Generate platform-aware title, description, hashtags, and chapters.", {"topic": "Five n8n video automation mistakes", "platform": "youtube_shorts"}))

        with gr.Tab("Publishing"):
            publish_media = gr.Textbox(label="Media URL or rendered output path")
            publish_title = gr.Textbox(label="Title")
            publish_platforms = gr.Textbox(label="Platforms", value="youtube,tiktok,instagram")
            publish_button = gr.Button("Create Publish Draft", variant="primary")
            publish_output = gr.JSON(label="Publish Job")
            publish_button.click(fn=create_publish_draft, inputs=[publish_media, publish_title, publish_platforms], outputs=publish_output, api_name="create_publish_draft", api_description=_mcp_description("Create a publishing draft for one or more platforms.", {"media": "/app/exports/render.mp4", "title": "Automation Tips", "platforms": "youtube,tiktok,instagram"}))

        with gr.Tab("Settings"):
            settings_button = gr.Button("Load Settings")
            settings_output = gr.JSON(label="Settings")
            settings_button.click(fn=get_runtime_settings, outputs=settings_output, api_name="get_runtime_settings", api_description=_mcp_description("Return renderer configuration and runtime capability settings.", {}))

        with gr.Tab("Queue Monitor"):
            queue_button = gr.Button("Refresh Queue")
            queue_output = gr.JSON(label="Queue")
            queue_button.click(fn=get_queue_status, outputs=queue_output, api_name="get_queue_status", api_description=_mcp_description("Return queue counts and active render jobs.", {}))

    return dashboard


def submit_render_job(payload: str) -> dict[str, Any]:
    """Submit a validated JSON timeline for asynchronous video rendering."""
    data = apply_creative_style(apply_preset(json.loads(payload)))
    request = Timeline.request_from_payload(data)
    job_id = job_manager.submit_render(request)
    return {"job_id": job_id, "status": f"/status/{job_id}", "download": f"/download/{job_id}"}


def create_project(name: str, metadata_json: str) -> dict[str, Any]:
    """Create a persistent studio project with optional JSON metadata."""
    metadata = json.loads(metadata_json or "{}")
    return {"project": project_manager.create(name, metadata=metadata)}


def list_projects() -> dict[str, Any]:
    """List all persistent studio projects."""
    return {"projects": project_manager.list()}


def add_project_asset(project_id: str, asset_json: str) -> dict[str, Any]:
    """Attach a media asset JSON object to an existing project."""
    return {"project": project_manager.add_asset(project_id, json.loads(asset_json or "{}"))}


def add_timeline_item(project_id: str, track_type: str, item_json: str) -> dict[str, Any]:
    """Add a JSON item to a video, audio, text, overlay, sticker, or subtitle track."""
    return {"project": project_manager.add_to_timeline(project_id, json.loads(item_json or "{}"), track_type=track_type)}


def apply_timeline_operation(project_id: str, operation_json: str) -> dict[str, Any]:
    """Apply a JSON timeline operation such as split, trim, insert, or ripple delete."""
    data = json.loads(operation_json or "{}")
    return {
        "project": project_manager.timeline_operation(
            project_id,
            data.get("operation", "drag"),
            item_id=data.get("item_id"),
            params=data.get("params", {}),
        )
    }


def _catalog_section(section: str) -> dict[str, Any]:
    catalog = capability_catalog()
    return {section: catalog.get(section)}


def load_template_catalog() -> dict[str, Any]:
    """Return available render and caption template capabilities."""
    return _catalog_section("templates")


def load_effect_catalog() -> dict[str, Any]:
    """Return available video effect capabilities."""
    return _catalog_section("effects")


def load_filter_catalog() -> dict[str, Any]:
    """Return available video filter capabilities."""
    return _catalog_section("filters")


def load_audio_catalog() -> dict[str, Any]:
    """Return audio-processing and music-generation capabilities."""
    catalog = capability_catalog()
    return {"audio": catalog["audio"], "music": catalog["music_generator"]}


def submit_caption_job(text: str) -> dict[str, Any]:
    """Submit an asynchronous caption-generation job from source text."""
    from renderer.studio import StudioTaskProcessor

    job_id = job_manager.submit_task(lambda task_id, log: StudioTaskProcessor(settings, log=log).caption_generate({"text": text}, task_id))
    return {"job_id": job_id, "status": f"/status/{job_id}", "download": f"/download/{job_id}"}


def submit_ai_tool(tool: str, payload: str) -> dict[str, Any]:
    """Submit an AI editing tool using its name and a JSON payload."""
    from renderer.studio import StudioTaskProcessor

    data = json.loads(payload or "{}")
    job_id = job_manager.submit_task(lambda task_id, log: StudioTaskProcessor(settings, log=log).ai_tool(tool, data, task_id))
    return {"job_id": job_id, "status": f"/status/{job_id}", "download": f"/download/{job_id}"}


def submit_batch_render(payload: str) -> dict[str, Any]:
    """Submit multiple asynchronous render jobs from a JSON jobs array."""
    data = json.loads(payload)
    requests = [Timeline.request_from_payload(apply_creative_style(apply_preset(job))) for job in data.get("jobs", [])]
    return {"job_ids": job_manager.submit_batch(requests)}


def submit_ai_reel(
    script: str,
    voiceover: str,
    assets: list[str],
    template: str,
    creative_style: str,
    platform: str,
    music: str | None,
) -> dict[str, Any]:
    """Create an AI reel from a script, voiceover, visual assets, style, and music."""
    request = AIReelsRequest(
        script=script,
        voiceover=voiceover,
        assets=assets or [],
        template=template,
        creative_style=creative_style,
        platform=platform,
        background_music=music,
    )
    job_id = job_manager.submit_ai_reels(request)
    return {"job_id": job_id, "status": f"/status/{job_id}", "download": f"/download/{job_id}"}


def get_job_status(job_id: str) -> dict[str, Any]:
    """Return state, metrics, artifact metadata, and errors for a job ID."""
    return job_manager.get(job_id).__dict__


def get_job_logs(job_id: str) -> str:
    """Return execution log messages for a job ID."""
    return "\n\n".join(job_manager.get(job_id).logs)


def get_download_path(job_id: str) -> str | None:
    """Return the local artifact path when a job has completed."""
    record = job_manager.get(job_id)
    if record.state != "COMPLETED":
        return None
    return record.output_path


def inspect_media_asset(path: str) -> dict[str, Any]:
    """Inspect a local media asset for streams, codecs, duration, and dimensions."""
    return RenderEngine(settings).inspect_asset(path)


def transcribe_audio_file(path: str, model_size: str, language: str) -> dict[str, Any]:
    """Transcribe an uploaded audio or video file with optional language selection."""
    return RenderEngine(settings).transcribe(
        path,
        model_size=model_size,
        language=language.strip() or None,
        word_timestamps=True,
    )


def submit_media_analysis(media: str, transcript: str, platform: str) -> dict[str, Any]:
    """Analyze media for highlights, pacing, retention, engagement, and platform fit."""
    from renderer.platform import PlatformProcessor

    job_id = job_manager.submit_task(
        lambda task_id, log: PlatformProcessor(settings, log=log).analyze(media, task_id, transcript=transcript, platform=platform)
    )
    return {"job_id": job_id, "status": f"/status/{job_id}", "download": f"/download/{job_id}"}


def submit_clip_job(media: str, clips_json: str) -> dict[str, Any]:
    """Generate timed clips from a media path or URL and a JSON clip specification."""
    from renderer.platform import PlatformProcessor

    clips = json.loads(clips_json)
    job_id = job_manager.submit_task(lambda task_id, log: PlatformProcessor(settings, log=log).clips(media, task_id, clips))
    return {"job_id": job_id, "status": f"/status/{job_id}", "download": f"/download/{job_id}"}


def submit_metadata_job(topic: str, platform: str) -> dict[str, Any]:
    """Generate platform-aware title, description, hashtags, keywords, and chapters."""
    from renderer.platform import PlatformProcessor

    job_id = job_manager.submit_task(lambda task_id, log: PlatformProcessor(settings, log=log).metadata(task_id, topic=topic, platform=platform))
    return {"job_id": job_id, "status": f"/status/{job_id}", "download": f"/download/{job_id}"}


def create_publish_draft(media: str, title: str, platforms: str) -> dict[str, Any]:
    """Create an asynchronous publishing draft for comma-separated platforms."""
    from renderer.platform import PlatformProcessor

    payload = {"media": media, "title": title, "platforms": [item.strip() for item in platforms.split(",") if item.strip()], "draft": True}
    job_id = job_manager.submit_task(lambda task_id, log: PlatformProcessor(settings, log=log).publish(payload, task_id))
    return {"job_id": job_id, "status": f"/status/{job_id}", "download": f"/download/{job_id}"}


def get_queue_status() -> dict[str, Any]:
    """Return queue totals, state counts, worker limits, and active jobs."""
    return job_manager.summary()


def get_runtime_settings() -> dict[str, Any]:
    """Return renderer paths, worker settings, Whisper settings, and capabilities."""
    return {
        "product": "Ava2lon Studio AI",
        "base_dir": str(settings.base_dir),
        "temp_dir": str(settings.temp_dir),
        "exports_dir": str(settings.exports_dir),
        "storage_dir": str(settings.storage_dir),
        "max_workers": settings.max_workers,
        "whisper_model_size": settings.whisper_model_size,
        "whisper_device": settings.whisper_device,
        "capabilities": capability_catalog()["principles"],
    }


app = gr.mount_gradio_app(
    api,
    create_dashboard(),
    path="/dashboard",
    root_path="/dashboard",
    mcp_server=True,
)


if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=7860)