"""Import Studio media/plans into OpenMontage; no generation or approval calls."""
from __future__ import annotations

import argparse
import hashlib
import json
import os
from pathlib import Path
import re
import shutil
import sys

STUDIO = Path(__file__).resolve().parents[2]
UPSTREAM = STUDIO / 'tools' / 'OpenMontage'
sys.path.insert(0, str(UPSTREAM))


def read(path):
    return json.loads(path.read_text(encoding='utf-8-sig'))


def write(path, value):
    path.parent.mkdir(parents=True, exist_ok=True)
    temporary = path.with_suffix(path.suffix + '.tmp')
    temporary.write_text(json.dumps(value, ensure_ascii=False, indent=2) + '\n', encoding='utf-8')
    temporary.replace(path)


def contained(root, relative):
    path = (root / relative).resolve()
    if not path.is_relative_to(root.resolve()) or not path.is_file():
        raise ValueError('Missing file or path outside authorized episode: ' + str(relative))
    return path


def digest(path):
    return hashlib.sha256(path.read_bytes()).hexdigest()


def preflight():
    from tools.tool_registry import registry
    registry.discover()
    summary = registry.provider_menu_summary()
    # Public capability status only; never print environment/credential values.
    summary['studio_flow_browser'] = dict(native_provider=False, api_keys_added=False,
        generation_automated=False, route='existing Studio CDP UI controller + verified file import')
    write(Path(__file__).parent / 'preflight.json', summary)
    print(json.dumps({k: summary.get(k) for k in ('composition_runtimes', 'runtime_warnings',
        'capabilities', 'studio_flow_browser')}, ensure_ascii=False))


def sync(episode_name):
    if not re.fullmatch(r'[a-zA-Z0-9_-]+', episode_name):
        raise ValueError('Invalid episode folder name')
    episode = (STUDIO / 'episodes' / episode_name).resolve()
    if not episode.is_relative_to((STUDIO / 'episodes').resolve()) or not episode.is_dir():
        raise ValueError('Episode not found')
    from lib.checkpoint import init_project
    from schemas.artifacts import validate_artifact
    from PIL import Image

    inventory = read(episode / 'visual-assets.json')
    storyboard = read(episode / 'storyboard.json')
    project_id = episode_name
    # Validate every input before writing the destination project.
    prepared = []
    for asset in inventory['assets']:
        source = contained(episode, asset['path'])
        if digest(source) != asset['sha256']:
            raise ValueError('Source hash changed: ' + asset['id'])
        with Image.open(source) as im:
            im.verify()
        prompt = contained(episode, asset['prompt'])
        prepared.append((asset, source, prompt))

    destination = UPSTREAM / 'projects' / project_id
    if destination.exists() and destination.is_symlink():
        raise ValueError('Project destination must not be a symlink')
    # Refuse to overwrite an unrelated or subsequently edited project file.
    for asset, source, _ in prepared:
        target = destination / 'assets' / 'images' / source.name
        if target.exists() and digest(target) != digest(source):
            raise ValueError('Destination image differs; use a new version: ' + target.name)

    project = init_project(project_id, title=inventory['title'], pipeline_type='cinematic',
        series='Studio Flow trials')
    assets, provenance = [], []
    selected = set(inventory['selected_ids'])
    for asset, source, prompt in prepared:
        relative = 'assets/images/' + source.name
        shutil.copy2(source, project / relative)
        scene = asset['id'][0] if asset['id'][0] in 'ABCD' else 'reference'
        assets.append(dict(id=asset['id'], type='image', path=relative,
            source_tool='studio_flow_browser_import', scene_id=scene, model=asset['model'],
            provider='google_flow_web', prompt=prompt.read_text(encoding='utf-8'),
            resolution=f"{asset['width']}x{asset['height']}", format='jpeg',
            generation_summary=asset['review_note']))
        provenance.append(dict(id=asset['id'], source=asset['path'], path=relative,
            sha256=asset['sha256'], selected=asset['id'] in selected,
            review_status=asset['status'], references=asset['references']))
    metadata = dict(imported_draft=True, source_episode=episode_name,
        pipeline_stages_approved=False, video_continuity_verified=False,
        flow_credit_record=inventory['credits'], monetary_cost_usd=None,
        selected_ids=inventory['selected_ids'])
    manifest = dict(version='1.0', assets=assets, metadata=metadata)
    scenes = []
    for shot in storyboard['shots']:
        scenes.append(dict(id=shot['id'], type='generated' if shot['source'] else 'text_card',
            description=shot['action'], start_seconds=shot['start'], end_seconds=shot['end'],
            framing=shot['framing'], movement=shot['action'], shot_intent=shot['handoff'],
            shot_language=dict(camera_movement='static', lighting_key='tungsten_warm'),
            overlay_notes='Title only in local edit' if not shot['source'] else 'No burned-in text'))
    scene_plan = dict(version='1.0', scenes=scenes, metadata=dict(metadata,
        authoritative_shot_design='studio-inputs/shot-design.md',
        timing_source='storyboard.json draft; shot-design.md corrections take priority'))
    script = dict(version='1.0', title=inventory['title'], total_duration_seconds=30,
        sections=[dict(id=s['id'], label=s['action'], text=s['audio'],
            start_seconds=s['start'], end_seconds=s['end']) for s in storyboard['shots']])
    for name, artifact in [('asset_manifest', manifest), ('scene_plan', scene_plan), ('script', script)]:
        validate_artifact(name, artifact)
        target = project / 'artifacts' / (name + '.json')
        if target.exists():
            prior = read(target)
            if prior != artifact:
                raise ValueError('Artifact changed; review before replacing: ' + name)
        write(target, artifact)
    input_dir = project / 'studio-inputs'
    input_dir.mkdir(exist_ok=True)
    for name in ['script.md', 'visual-bible.md', 'shot-design.md', 'VISUAL_REVIEW.md',
                 'continuity-test-plan.md', 'flow-prompts.md', 'storyboard.json', 'visual-assets.json']:
        source = contained(episode, name)
        target = input_dir / name
        if target.exists() and digest(target) != digest(source):
            raise ValueError('Imported input changed; review before replacing: ' + name)
        shutil.copy2(source, target)
    write(project / 'studio-flow-provenance.json', dict(version='1.0', files=provenance,
        source_episode=str(episode), approvals_transferred=False, native_flow_provider=False))
    write(project / 'flow-handoff.json', dict(version='1.0', mode='browser-ui',
        controller=str(episode / 'src' / 'flow-visual-control.mjs'),
        video_generation_authorized=False, credit_budget=None,
        canonical_selected_ids=inventory['selected_ids'],
        current_operation='import complete; no new generation',
        note='Browser generation is agent-operated. This bridge does not click Generate or retry jobs.'))
    print(json.dumps(dict(project_id=project_id, images=len(assets), schema_validated=3,
        board_url=f'http://127.0.0.1:4750/p/{project_id}', new_generations=0), ensure_ascii=False))


if __name__ == '__main__':
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('action', choices=['preflight', 'sync'])
    parser.add_argument('--episode', default='2026-11-09_ghost-helper')
    args = parser.parse_args()
    os.chdir(UPSTREAM)
    if args.action == 'preflight':
        preflight()
    else:
        sync(args.episode)
