app.py

"""povsync — painel para assistir vários POVs sincronizados."""
import os
import json
import glob
import uuid
import time
import shutil
import threading
from datetime import datetime

from flask import Flask, render_template, request, jsonify, send_file, abort
from flask_socketio import SocketIO
import yt_dlp

import sync

BASE = os.path.dirname(os.path.abspath(__file__))
DOWNLOADS = os.path.join(BASE, 'downloads')
DATA = os.path.join(BASE, 'data')
SESSIONS_FILE = os.path.join(DATA, 'sessions.json')
os.makedirs(DOWNLOADS, exist_ok=True)
os.makedirs(DATA, exist_ok=True)

app = Flask(__name__)
app.config['SECRET_KEY'] = 'povsync'
socketio = SocketIO(app, cors_allowed_origins='*', async_mode='threading')

_lock = threading.Lock()


# --------------------------------------------------------------------------
# persistência
# --------------------------------------------------------------------------
def load_sessions():
    if os.path.exists(SESSIONS_FILE):
        with open(SESSIONS_FILE, encoding='utf-8') as f:
            return json.load(f)
    return {}


def save_sessions(data):
    with open(SESSIONS_FILE, 'w', encoding='utf-8') as f:
        json.dump(data, f, ensure_ascii=False, indent=2)


def get_session(sid):
    return load_sessions().get(sid)


def update_session(sid, mutate):
    """Aplica `mutate(sessao)` de forma atômica e avisa os clientes via socket."""
    with _lock:
        data = load_sessions()
        if sid not in data:
            return None
        mutate(data[sid])
        save_sessions(data)
        sess = data[sid]
    socketio.emit('session_update', sess)
    return sess


def _set_video(sess, vid, **kw):
    for v in sess['videos']:
        if v['id'] == vid:
            v.update(kw)
            return


def session_dir(sid):
    d = os.path.join(DOWNLOADS, sid)
    os.makedirs(d, exist_ok=True)
    return d


# --------------------------------------------------------------------------
# mapa de offsets
# --------------------------------------------------------------------------
def offset_at(omap, t, fallback=0.0):
    """Offset aplicável no instante `t` (segundos da referência)."""
    if not omap:
        return fallback
    off = omap[0]['offset']
    for bp in omap:
        if bp['at'] <= t:
            off = bp['offset']
        else:
            break
    return off


def insert_breakpoint(omap, at, offset, conf, merge=15.0):
    """Insere/atualiza um ponto de quebra no mapa, mesclando os bem próximos."""
    out = [b for b in (omap or []) if b['at'] == 0.0 or abs(b['at'] - at) > merge]
    if at <= 0:
        out = [b for b in out if b['at'] > 0]
        out.insert(0, {'at': 0.0, 'offset': round(offset, 3), 'conf': round(conf, 1)})
    else:
        out.append({'at': round(at, 1), 'offset': round(offset, 3), 'conf': round(conf, 1)})
    out.sort(key=lambda b: b['at'])
    if not out or out[0]['at'] > 0:
        out.insert(0, {'at': 0.0, 'offset': out[0]['offset'] if out else 0.0, 'conf': 0.0})
    return out


def correlate_session(sid):
    """Escolhe a referência mais contínua e constrói o mapa de offsets de cada vídeo."""
    sess = get_session(sid)
    d = session_dir(sid)
    ok = [v for v in sess['videos'] if v.get('status') == 'downloaded' and v.get('filename')]

    envs = {}
    for v in ok:
        ep = os.path.join(d, v['id'] + '.env.npy')
        if not os.path.exists(ep):
            sync.extract_envelope(os.path.join(d, v['filename']), ep)
        envs[v['id']] = sync.load_env(ep)
    if not envs:
        return

    ref = sync.pick_reference(envs)
    maps = {}
    for vid_, env in envs.items():
        if vid_ == ref:
            maps[vid_] = [{'at': 0.0, 'offset': 0.0, 'conf': 999.0}]
        else:
            maps[vid_] = sync.build_offset_map(envs[ref], env)

    def mut(s):
        s['reference'] = ref
        for v in s['videos']:
            if v['id'] in maps:
                m = maps[v['id']]
                v['offset_map'] = m
                v['offset'] = m[0]['offset']
                v['confidence'] = m[0]['conf']
                v['segments'] = len(m)

    update_session(sid, mut)


# --------------------------------------------------------------------------
# download + correlação (roda em background)
# --------------------------------------------------------------------------
def download_one(sid, video):
    vid = video['id']
    d = session_dir(sid)
    last = [0.0]

    def hook(prog):
        if prog['status'] == 'downloading':
            now = time.time()
            if now - last[0] < 0.7:
                return
            last[0] = now
            total = prog.get('total_bytes') or prog.get('total_bytes_estimate') or 0
            done = prog.get('downloaded_bytes', 0)
            pct = round(done / total * 100, 1) if total else 0.0
            update_session(sid, lambda s: _set_video(s, vid, status='downloading', percent=pct))
        elif prog['status'] == 'finished':
            update_session(sid, lambda s: _set_video(s, vid, status='processing', percent=100))

    opts = {
        'outtmpl': os.path.join(d, f'{vid}.%(ext)s'),
        'format': ('bestvideo[height<=720][ext=mp4]+bestaudio[ext=m4a]/'
                   'best[height<=720][ext=mp4]/best[height<=720]/best'),
        'merge_output_format': 'mp4',
        'noplaylist': True,
        'progress_hooks': [hook],
        'quiet': True,
        'no_warnings': True,
    }
    with yt_dlp.YoutubeDL(opts) as ydl:
        info = ydl.extract_info(video['url'], download=True)

    files = [f for f in glob.glob(os.path.join(d, f'{vid}.*')) if not f.endswith('.npy')]
    mp4 = [f for f in files if f.endswith('.mp4')]
    path = mp4[0] if mp4 else files[0]
    return info, os.path.basename(path)


def run_session(sid):
    """Baixa todos os vídeos, extrai envelopes e correlaciona contra a referência."""
    try:
        sess = get_session(sid)
        for v in sess['videos']:
            try:
                info, fname = download_one(sid, v)
                update_session(sid, lambda s, v=v, info=info, fname=fname: _set_video(
                    s, v['id'], status='downloaded', percent=100,
                    title=info.get('title', '?'), filename=fname,
                    duration=info.get('duration', 0) or 0,
                    thumbnail=info.get('thumbnail', ''),
                    channel=info.get('channel') or info.get('uploader', '?')))
            except Exception as e:
                update_session(sid, lambda s, v=v, e=e: _set_video(
                    s, v['id'], status='error', error=str(e)[:300]))

        update_session(sid, lambda s: s.update(status='correlating'))
        correlate_session(sid)
        update_session(sid, lambda s: s.update(status='ready'))
    except Exception as e:
        update_session(sid, lambda s, e=e: s.update(status='error', error=str(e)[:300]))


# --------------------------------------------------------------------------
# rotas
# --------------------------------------------------------------------------
@app.route('/')
def index():
    return render_template('index.html')


@app.route('/player/<sid>')
def player(sid):
    if not get_session(sid):
        abort(404)
    return render_template('player.html', session_id=sid)


@app.route('/api/sessions', methods=['GET'])
def list_sessions():
    data = load_sessions()
    return jsonify(sorted(data.values(), key=lambda s: s['created_at'], reverse=True))


@app.route('/api/sessions', methods=['POST'])
def create_session():
    data = request.json or {}
    urls = [u.strip() for u in data.get('urls', []) if u.strip()]
    if len(urls) < 2:
        return jsonify({'error': 'Informe pelo menos 2 URLs.'}), 400

    sid = uuid.uuid4().hex[:8]
    sess = {
        'id': sid,
        'name': data.get('name') or f'Sessão {datetime.now():%d/%m %H:%M}',
        'created_at': datetime.now().isoformat(),
        'status': 'downloading',
        'reference': None,
        'videos': [
            {'id': f'v{i + 1}', 'url': u, 'status': 'queued', 'percent': 0,
             'offset': 0.0, 'confidence': 0.0, 'title': u}
            for i, u in enumerate(urls)
        ],
    }
    with _lock:
        all_s = load_sessions()
        all_s[sid] = sess
        save_sessions(all_s)

    socketio.start_background_task(run_session, sid)
    return jsonify(sess)


@app.route('/api/sessions/<sid>')
def session_detail(sid):
    sess = get_session(sid)
    if not sess:
        abort(404)
    return jsonify(sess)


@app.route('/api/sessions/<sid>', methods=['DELETE'])
def delete_session(sid):
    with _lock:
        data = load_sessions()
        data.pop(sid, None)
        save_sessions(data)
    shutil.rmtree(os.path.join(DOWNLOADS, sid), ignore_errors=True)
    return jsonify({'ok': True})


@app.route('/api/sessions/<sid>/offset', methods=['POST'])
def set_offset(sid):
    data = request.json or {}
    vid = data.get('video_id')
    off = float(data.get('offset', 0))
    update_session(sid, lambda s: _set_video(s, vid, offset=round(off, 3)))
    return jsonify({'ok': True})


@app.route('/api/sessions/<sid>/rebuild', methods=['POST'])
def rebuild(sid):
    """Recalcula referência + mapas de offset de uma sessão já baixada."""
    if not get_session(sid):
        abort(404)
    update_session(sid, lambda s: s.update(status='correlating'))

    def work():
        try:
            correlate_session(sid)
            update_session(sid, lambda s: s.update(status='ready'))
        except Exception as e:
            update_session(sid, lambda s, e=e: s.update(status='error', error=str(e)[:300]))

    socketio.start_background_task(work)
    return jsonify({'status': 'started'})


@app.route('/api/sessions/<sid>/probe', methods=['POST'])
def probe(sid):
    """Mede o offset real no instante dado (usado pelo auto-resync ao vivo)."""
    sess = get_session(sid)
    if not sess:
        abort(404)
    data = request.json or {}
    ref_t = float(data.get('ref_time', 0))
    window = float(data.get('window', 60))
    only = data.get('video_ids')
    d = session_dir(sid)
    ref = sess['reference']
    ref_env = sync.load_env(os.path.join(d, ref + '.env.npy'))

    out = {}
    for v in sess['videos']:
        if v['id'] == ref or v.get('status') != 'downloaded':
            continue
        if only and v['id'] not in only:
            continue
        te = sync.load_env(os.path.join(d, v['id'] + '.env.npy'))
        cur = offset_at(v.get('offset_map'), ref_t, v.get('offset', 0.0))
        off, score = sync.correlate_window(ref_env, te, ref_t, cur, window)
        out[v['id']] = {'offset': round(off, 3), 'confidence': round(score, 1),
                        'applied': round(cur, 3)}
    return jsonify(out)


@app.route('/api/sessions/<sid>/resync', methods=['POST'])
def resync(sid):
    """Mede o offset no ponto atual e insere um ponto de quebra no mapa."""
    sess = get_session(sid)
    if not sess:
        abort(404)
    data = request.json or {}
    ref_t = float(data.get('ref_time', 0))
    window = float(data.get('window', 90))
    only = data.get('video_ids')
    d = session_dir(sid)
    ref = sess['reference']
    if not ref:
        return jsonify({'error': 'Sessão sem referência'}), 400

    ref_env = sync.load_env(os.path.join(d, ref + '.env.npy'))
    updates = {}
    for v in sess['videos']:
        if v['id'] == ref or v.get('status') != 'downloaded':
            continue
        if only and v['id'] not in only:
            continue
        te = sync.load_env(os.path.join(d, v['id'] + '.env.npy'))
        cur = offset_at(v.get('offset_map'), ref_t, v.get('offset', 0.0))
        off, score = sync.correlate_window(ref_env, te, ref_t, cur, window)
        updates[v['id']] = insert_breakpoint(v.get('offset_map'), ref_t, off, score)

    def mut(s):
        for v in s['videos']:
            if v['id'] in updates:
                v['offset_map'] = updates[v['id']]
                v['offset'] = updates[v['id']][0]['offset']
                v['segments'] = len(updates[v['id']])

    update_session(sid, mut)
    return jsonify(get_session(sid))


@app.route('/api/sessions/<sid>/map', methods=['POST'])
def set_map(sid):
    """Salva o mapa de offsets completo de um vídeo (usado pelo editor de mapa)."""
    if not get_session(sid):
        abort(404)
    data = request.json or {}
    vid_ = data.get('video_id')
    omap = data.get('offset_map')
    if not vid_ or not isinstance(omap, list) or not omap:
        return jsonify({'error': 'dados inválidos'}), 400

    clean = sorted(
        [{'at': max(0.0, float(b['at'])), 'offset': float(b['offset']),
          'conf': float(b.get('conf', 0))} for b in omap],
        key=lambda b: b['at'])
    if clean[0]['at'] > 0:
        clean.insert(0, {'at': 0.0, 'offset': clean[0]['offset'], 'conf': 0.0})

    def mut(s):
        for v in s['videos']:
            if v['id'] == vid_:
                v['offset_map'] = clean
                v['offset'] = clean[0]['offset']
                v['segments'] = len(clean)

    update_session(sid, mut)
    return jsonify({'ok': True})


@app.route('/media/<sid>/<vid>')
def media(sid, vid):
    sess = get_session(sid)
    if not sess:
        abort(404)
    v = next((x for x in sess['videos'] if x['id'] == vid), None)
    if not v or not v.get('filename'):
        abort(404)
    path = os.path.join(DOWNLOADS, sid, v['filename'])
    if not os.path.exists(path):
        abort(404)
    return send_file(path, conditional=True, mimetype='video/mp4')


if __name__ == '__main__':
    print('povsync  ->  http://localhost:8500')
    socketio.run(app, host='0.0.0.0', port=8500, debug=True, allow_unsafe_werkzeug=True)