main.py

# AI Movie Intelligence + Script + Video Production System (Level 7)
# Architecture:
#   Layer 1 — Core Engine       : deterministic subtitle/scene processing
#   Layer 2 — AI Brain          : observation, analysis, suggestions
#   Layer 3 — Control Center    : governance and temporary overrides
#   Level 4 — AI Router         : OpenAI key pool with auto-failover
#   Level 5 — Pipeline Engine   : scene_parser + live FFmpeg video generation
#   Level 6 — AI Director       : hybrid scene selection (AI Auto / Hybrid / Timestamp)
#   Level 7 — Viral Engine      : retention scoring, engagement filtering, hook generation

import os
import uuid
import json

from flask import (
    Flask, request, render_template, redirect,
    url_for, send_file, abort, jsonify
)

from core_engine    import CoreEngine
from ai_brain       import AIBrain
from control_center import ControlCenter
import ai_hub
import ai_router
from ai_engine      import analyze_scenes_ai, generate_story_script
from video_pipeline import VideoPipeline
import pipeline_engine
import ai_director
import viral_engine
from modules.exporter import export_files

app = Flask(__name__)
app.secret_key = os.environ.get('SESSION_SECRET', 'dev-secret-key')

UPLOAD_FOLDER = 'uploads'
os.makedirs(UPLOAD_FOLDER, exist_ok=True)

ai_router.get_pool()   # pre-load key pool on startup


# ── Session helpers ────────────────────────────────────────────────────────

def load_session(session_id):
    path = os.path.join(UPLOAD_FOLDER, session_id, 'data.json')
    if not os.path.exists(path):
        return None
    with open(path) as f:
        return json.load(f)


def save_session(session_id, data):
    d = os.path.join(UPLOAD_FOLDER, session_id)
    os.makedirs(d, exist_ok=True)
    with open(os.path.join(d, 'data.json'), 'w') as f:
        json.dump(data, f)


# ── Upload & process ────────────────────────────────────────────────────────

@app.route('/')
def index():
    return render_template('upload.html')


@app.route('/process', methods=['POST'])
def process():
    """
    Stages 1–8: Core Engine → AI Brain → Control Center →
                AI Enrichment → Script → Video Pipeline → Export
    """
    session_id  = str(uuid.uuid4())
    session_dir = os.path.join(UPLOAD_FOLDER, session_id)
    os.makedirs(session_dir, exist_ok=True)

    movie_title    = request.form.get('movie_title', '').strip() or 'Unknown Movie'
    movie_filename = 'movie.mp4'
    subtitle_text  = ''

    movie_file = request.files.get('movie_file')
    if movie_file and movie_file.filename:
        movie_filename = movie_file.filename
        movie_file.save(os.path.join(session_dir, movie_filename))

    sub_file = request.files.get('subtitle_file')
    if sub_file and sub_file.filename:
        subtitle_text = sub_file.read().decode('utf-8', errors='replace')
    else:
        subtitle_text = request.form.get('subtitle_text', '').strip()

    if not subtitle_text:
        return render_template('upload.html',
                               error='Please upload a subtitle file or paste subtitle text.')

    # Log router state
    pool_status = ai_router.get_pool_status()
    ai_hub.log_router_event(
        session_id, 'pool_status',
        f"Key pool: {pool_status['total_keys']} key(s), {pool_status['active_keys']} active",
    )

    # Stage 1 — Subtitle Parsing
    ai_hub.log_step(session_id, 1, "Subtitle Parsing", "running")
    core      = CoreEngine()
    subtitles = core.parse(subtitle_text)
    ai_hub.log_step(session_id, 1, "Subtitle Parsing", "complete", {"lines": len(subtitles)})

    # Stage 2 — Scene Building
    ai_hub.log_step(session_id, 2, "Scene Building", "running")
    scenes = core.build_scenes(subtitles)
    if not scenes:
        return render_template('upload.html',
                               error='No scenes detected. Please check your subtitle text.')
    ai_hub.log_step(session_id, 2, "Scene Building", "complete", {"scenes": len(scenes)})

    # Stage 3 — AI Brain
    ai_hub.log_step(session_id, 3, "AI Brain Analysis", "running")
    brain        = AIBrain(session_id)
    observations = brain.observe(subtitles, scenes)
    suggestions  = brain.suggest(scenes, observations)
    ai_hub.log_step(session_id, 3, "AI Brain Analysis", "complete",
                    {"suggestions": len(suggestions)})

    # Stage 4 — Control Center
    ai_hub.log_step(session_id, 4, "Control Center Validation", "running")
    cc       = ControlCenter(session_id)
    approved = cc.process_suggestions(suggestions)
    scenes   = cc.apply_temporary_override(scenes, approved)
    cc_stats = cc.get_stats()
    ai_hub.log_step(session_id, 4, "Control Center Validation", "complete",
                    {"approved": cc_stats['approved'], "rejected": cc_stats['rejected']})

    # Stage 5 — AI Scene Enrichment
    ai_hub.log_step(session_id, 5, "AI Scene Enrichment", "running")
    enriched_scenes, ai_mode = analyze_scenes_ai(scenes, session_id=session_id)
    ai_hub.log_step(session_id, 5, "AI Scene Enrichment", "complete", {"ai_mode": ai_mode})

    # Stage 6 — Script Generation
    ai_hub.log_step(session_id, 6, "Script Generation", "running")
    script = generate_story_script(enriched_scenes, movie_title, ai_mode, session_id=session_id)
    ai_hub.log_step(session_id, 6, "Script Generation", "complete", {"sections": len(script)})

    # Stage 7 — Video Pipeline (shell script)
    ai_hub.log_step(session_id, 7, "Video Pipeline Script", "running")
    vp            = VideoPipeline(movie_filename)
    full_pipeline = vp.generate_complete_pipeline(enriched_scenes, movie_title)
    simple_cmds   = vp.generate_simple_commands(enriched_scenes)
    output_dir    = os.path.join(session_dir, 'output')
    os.makedirs(output_dir, exist_ok=True)
    with open(os.path.join(output_dir, 'video_pipeline.sh'), 'w') as f:
        f.write(full_pipeline)
    with open(os.path.join(output_dir, 'ffmpeg_commands.txt'), 'w') as f:
        f.write(simple_cmds)
    ai_hub.log_step(session_id, 7, "Video Pipeline Script", "complete",
                    {"clips": len(vp.selected_scenes(enriched_scenes))})

    # Stage 8 — Export Package
    ai_hub.log_step(session_id, 8, "Export Package", "running")
    export = export_files(session_dir, subtitles, enriched_scenes, script, simple_cmds, movie_title)
    import zipfile
    with zipfile.ZipFile(export['zip_path'], 'a', zipfile.ZIP_DEFLATED) as zf:
        sh_path = os.path.join(output_dir, 'video_pipeline.sh')
        if os.path.exists(sh_path):
            zf.write(sh_path, 'video_pipeline.sh')
    ai_hub.log_step(session_id, 8, "Export Package", "complete", {"zip": export['zip_filename']})

    save_session(session_id, {
        'movie_title':    movie_title,
        'movie_filename': movie_filename,
        'subtitle_text':  subtitle_text,          # saved for AI Director
        'subtitle_count': len(subtitles),
        'scene_count':    len(enriched_scenes),
        'ai_mode':        ai_mode,
        'scenes':         enriched_scenes,
        'script':         script,
        'observations':   observations,
        'suggestions':    suggestions,
        'cc_stats':       cc_stats,
        'zip_filename':   export['zip_filename'],
    })

    return redirect(url_for('dashboard_view', session_id=session_id))


# ── Viewer routes ───────────────────────────────────────────────────────────

@app.route('/dashboard/<session_id>')
def dashboard_view(session_id):
    data = load_session(session_id)
    if not data:
        return redirect(url_for('index'))
    return render_template('dashboard.html',
                           data=data, session_id=session_id,
                           pipeline_status=ai_hub.get_pipeline_status(session_id),
                           all_logs=ai_hub.get_all_logs(session_id),
                           suggestions=ai_hub.get_suggestions(session_id),
                           ai_requests=ai_hub.get_ai_requests(session_id),
                           router_status=ai_router.get_pool_status(),
                           router_logs=ai_hub.get_router_logs(session_id))


@app.route('/scenes/<session_id>')
def scenes_view(session_id):
    data = load_session(session_id)
    if not data:
        return redirect(url_for('index'))
    return render_template('scenes.html', data=data, session_id=session_id)


@app.route('/script/<session_id>')
def script_view(session_id):
    data = load_session(session_id)
    if not data:
        return redirect(url_for('index'))
    return render_template('script_view.html', data=data, session_id=session_id)


@app.route('/download/<session_id>')
def download_page(session_id):
    data = load_session(session_id)
    if not data:
        return redirect(url_for('index'))
    return render_template('download.html', data=data, session_id=session_id)


# ── Level 6: AI Director routes ─────────────────────────────────────────────

@app.route('/director/<session_id>')
def director_view(session_id):
    data = load_session(session_id)
    if not data:
        return redirect(url_for('index'))
    # Compute accepted indices for template (which scene cards to pre-check)
    ai_scenes = data.get('director_ai_scenes', [])
    accepted_ai = data.get('director_accepted_ai', [])
    accepted_indices = []
    for i, scene in enumerate(ai_scenes):
        if any(
            abs(a.get('start', -1) - scene.get('start', -2)) < 0.1
            for a in accepted_ai
        ):
            accepted_indices.append(i)
    data['director_accepted_indices'] = accepted_indices
    return render_template('director.html',
                           data=data, session_id=session_id,
                           director_logs=ai_hub.get_director_logs(session_id))


@app.route('/director/<session_id>/analyze', methods=['POST'])
def director_analyze(session_id):
    """Run AI Director analysis and store scene suggestions."""
    data = load_session(session_id)
    if not data:
        abort(404)

    result = ai_director.analyze_movie(
        enriched_scenes=data['scenes'],
        movie_title=data['movie_title'],
        session_id=session_id,
    )

    data['director_ai_scenes'] = result['scenes']
    data['director_analysis']  = {
        'method':        result['method'],
        'fallback_used': result['fallback_used'],
        'scene_count':   len(result['scenes']),
    }
    save_session(session_id, data)
    return redirect(url_for('director_view', session_id=session_id))


@app.route('/director/<session_id>/update', methods=['POST'])
def director_update(session_id):
    """Save user director decisions and send to video pipeline."""
    data = load_session(session_id)
    if not data:
        abort(404)

    mode = request.form.get('mode', ai_director.DEFAULT_MODE)

    # Parse accepted AI scene indices from checkboxes
    ai_scenes       = data.get('director_ai_scenes', [])
    accepted_indices = request.form.getlist('accepted_ai')
    accepted_ai = []
    for idx_str in accepted_indices:
        try:
            idx = int(idx_str)
            if 0 <= idx < len(ai_scenes):
                accepted_ai.append(ai_scenes[idx])
        except ValueError:
            pass

    # Parse manual scene rows
    manual_starts  = request.form.getlist('manual_start')
    manual_ends    = request.form.getlist('manual_end')
    manual_reasons = request.form.getlist('manual_reason')
    user_scenes = []
    for i, (s_str, e_str) in enumerate(zip(manual_starts, manual_ends)):
        try:
            start = float(s_str)
            end   = float(e_str)
            if end > start:
                user_scenes.append({
                    'start':      start,
                    'end':        end,
                    'confidence': 1.0,
                    'reason':     manual_reasons[i] if i < len(manual_reasons) else 'manual',
                    'source':     'user',
                })
        except (ValueError, TypeError):
            pass

    # Resolve final scene list (never empty — falls back to rule-based)
    final_scenes = ai_director.resolve_final_scenes(
        mode=mode,
        ai_scenes=accepted_ai,
        user_scenes=user_scenes,
        enriched_scenes=data['scenes'],
        session_id=session_id,
    )

    ai_hub.log_director(session_id, 'user_override',
                        f'Mode={mode} | AI accepted={len(accepted_ai)} '
                        f'| manual={len(user_scenes)} | final={len(final_scenes)}')

    data['director_mode']          = mode
    data['director_final_scenes']  = final_scenes
    data['director_user_manual']   = user_scenes
    data['director_accepted_ai']   = accepted_ai
    save_session(session_id, data)

    return redirect(url_for('video_view', session_id=session_id))


# ── Level 7: Viral Engine routes ────────────────────────────────────────────

@app.route('/viral/<session_id>')
def viral_view(session_id):
    data = load_session(session_id)
    if not data:
        return redirect(url_for('index'))
    return render_template('viral.html',
                           data=data, session_id=session_id,
                           vr=data.get('viral_result'),
                           viral_logs=ai_hub.get_viral_logs(session_id))


@app.route('/viral/<session_id>/optimize', methods=['POST'])
def viral_optimize(session_id):
    """
    Run the Level 7 Viral Engine.
    Uses director_final_scenes if available, otherwise enriched scenes.
    Saves result to session as 'viral_result' and 'viral_optimized_scenes'.
    """
    data = load_session(session_id)
    if not data:
        abort(404)

    # Use best available scene source (director > enriched)
    source_scenes = data.get('director_final_scenes') or data.get('scenes') or []

    vr = viral_engine.run_viral_pipeline(
        scenes      = source_scenes,
        movie_title = data['movie_title'],
        session_id  = session_id,
    )

    data['viral_result']           = vr
    data['viral_optimized_scenes'] = vr['optimized_scenes']
    save_session(session_id, data)

    return redirect(url_for('viral_view', session_id=session_id))


# ── Level 5: Video Pipeline routes ─────────────────────────────────────────

@app.route('/video/<session_id>')
def video_view(session_id):
    data = load_session(session_id)
    if not data:
        return redirect(url_for('index'))

    output_dir  = os.path.join(UPLOAD_FOLDER, session_id, 'output')
    movie_path  = os.path.join(UPLOAD_FOLDER, session_id, data.get('movie_filename', 'movie.mp4'))
    video_path  = os.path.join(output_dir, 'final_video.mp4')
    ts_path     = os.path.join(output_dir, 'timestamped_script.txt')

    timestamped_script = ''
    if os.path.exists(ts_path):
        with open(ts_path) as f:
            timestamped_script = f.read()

    return render_template('video_pipeline.html',
                           data=data,
                           session_id=session_id,
                           ffmpeg_ok=pipeline_engine.ffmpeg_available(),
                           has_movie=os.path.exists(movie_path),
                           movie_filename=data.get('movie_filename', ''),
                           video_exists=os.path.exists(video_path),
                           timestamped_script=timestamped_script,
                           video_pipeline_result=data.get('video_pipeline_result'))


@app.route('/video/<session_id>/generate', methods=['POST'])
def video_generate(session_id):
    """
    Trigger the full Level 5 video pipeline.
    Stages 9–12: Timestamped Script → Scene Parse → Cut Clips → Merge
    """
    data = load_session(session_id)
    if not data:
        abort(404)

    session_dir = os.path.join(UPLOAD_FOLDER, session_id)
    movie_path  = os.path.join(session_dir, data.get('movie_filename', 'movie.mp4'))
    output_dir  = os.path.join(session_dir, 'output')

    # Priority: Level 7 viral scenes > Level 6 director scenes > Level 5 auto
    director_scenes = (data.get('viral_optimized_scenes') or
                       data.get('director_final_scenes') or None)

    result = pipeline_engine.run_pipeline(
        session_id      = session_id,
        movie_path      = movie_path,
        enriched_scenes = data['scenes'],
        movie_title     = data['movie_title'],
        output_dir      = output_dir,
        existing_script = data.get('script'),
        director_scenes = director_scenes,
    )

    # Store a serialisable subset (no large paths)
    data['video_pipeline_result'] = {
        'timestamped_script': result['timestamped_script'],
        'video_scenes':       result['video_scenes'],
        'clip_results':       [
            {k: v for k, v in r.items() if k != 'clip_path'}
            for r in result['clip_results']
        ],
        'status':             result['status'],
        'error':              result.get('error'),
        'ffmpeg_available':   result['ffmpeg_available'],
        'movie_found':        result['movie_found'],
    }
    save_session(session_id, data)

    return redirect(url_for('video_view', session_id=session_id))


@app.route('/video/<session_id>/download')
def video_download(session_id):
    data = load_session(session_id)
    if not data:
        abort(404)
    video_path = os.path.join(UPLOAD_FOLDER, session_id, 'output', 'final_video.mp4')
    if not os.path.exists(video_path):
        abort(404)
    title = data.get('movie_title', 'video').replace(' ', '_')
    return send_file(video_path, as_attachment=True,
                     download_name=f"{title}_final_video.mp4",
                     mimetype='video/mp4')


# ── Download routes ─────────────────────────────────────────────────────────

@app.route('/download/<session_id>/zip')
def download_zip(session_id):
    data = load_session(session_id)
    if not data:
        abort(404)
    zip_path = os.path.join(UPLOAD_FOLDER, session_id, data['zip_filename'])
    if not os.path.exists(zip_path):
        abort(404)
    return send_file(zip_path, as_attachment=True, download_name=data['zip_filename'])


@app.route('/download/<session_id>/file/<filename>')
def download_file(session_id, filename):
    allowed = {'scenes.json', 'script.json', 'script.txt',
               'ffmpeg_commands.txt', 'subtitles.json',
               'video_pipeline.sh', 'timestamped_script.txt'}
    if filename not in allowed:
        abort(403)
    path = os.path.join(UPLOAD_FOLDER, session_id, 'output', filename)
    if not os.path.exists(path):
        abort(404)
    return send_file(path, as_attachment=True, download_name=filename)


# ── API routes ──────────────────────────────────────────────────────────────

@app.route('/api/router/status')
def router_status_api():
    return jsonify(ai_router.get_pool_status())


@app.route('/api/router/reload', methods=['POST'])
def router_reload():
    pool = ai_router.reload_pool()
    return jsonify({'reloaded': True, 'total_keys': len(pool)})


if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8080, debug=True)