intercept/routes/recordings.py

"""Session recording API endpoints."""

from __future__ import annotations

import json
from pathlib import Path

from flask import Blueprint, request, send_file

from utils.recording import RECORDING_ROOT, get_recording_manager
from utils.responses import api_error, api_success

recordings_bp = Blueprint('recordings', __name__, url_prefix='/recordings')


@recordings_bp.route('/start', methods=['POST'])
def start_recording():
    data = request.get_json() or {}
    mode = (data.get('mode') or '').strip()
    if not mode:
        return api_error('mode is required', 400)

    label = data.get('label')
    metadata = data.get('metadata') if isinstance(data.get('metadata'), dict) else {}

    manager = get_recording_manager()
    session = manager.start_recording(mode=mode, label=label, metadata=metadata)

    return api_success(data={'session': {
        'id': session.id,
        'mode': session.mode,
        'label': session.label,
        'started_at': session.started_at.isoformat(),
        'file_path': str(session.file_path),
    }})


@recordings_bp.route('/stop', methods=['POST'])
def stop_recording():
    data = request.get_json() or {}
    mode = data.get('mode')
    session_id = data.get('id')

    manager = get_recording_manager()
    session = manager.stop_recording(mode=mode, session_id=session_id)
    if not session:
        return api_error('No active recording found', 404)

    return api_success(data={'session': {
        'id': session.id,
        'mode': session.mode,
        'label': session.label,
        'started_at': session.started_at.isoformat(),
        'stopped_at': session.stopped_at.isoformat() if session.stopped_at else None,
        'event_count': session.event_count,
        'size_bytes': session.size_bytes,
        'file_path': str(session.file_path),
    }})


@recordings_bp.route('', methods=['GET'])
def list_recordings():
    manager = get_recording_manager()
    limit = request.args.get('limit', default=50, type=int)
    return api_success(data={
        'recordings': manager.list_recordings(limit=limit),
        'active': manager.get_active(),
    })


@recordings_bp.route('/<session_id>', methods=['GET'])
def get_recording(session_id: str):
    manager = get_recording_manager()
    rec = manager.get_recording(session_id)
    if not rec:
        return api_error('Recording not found', 404)
    return api_success(data={'recording': rec})


@recordings_bp.route('/<session_id>/download', methods=['GET'])
def download_recording(session_id: str):
    manager = get_recording_manager()
    rec = manager.get_recording(session_id)
    if not rec:
        return api_error('Recording not found', 404)

    file_path = Path(rec['file_path'])
    try:
        resolved_root = RECORDING_ROOT.resolve()
        resolved_file = file_path.resolve()
        if resolved_root not in resolved_file.parents:
            return api_error('Invalid recording path', 400)
    except Exception:
        return api_error('Invalid recording path', 400)

    if not file_path.exists():
        return api_error('Recording file missing', 404)

    return send_file(
        file_path,
        mimetype='application/x-ndjson',
        as_attachment=True,
        download_name=file_path.name,
    )


@recordings_bp.route('/<session_id>/events', methods=['GET'])
def get_recording_events(session_id: str):
    """Return parsed events from a recording for in-app replay."""
    manager = get_recording_manager()
    rec = manager.get_recording(session_id)
    if not rec:
        return api_error('Recording not found', 404)

    file_path = Path(rec['file_path'])
    try:
        resolved_root = RECORDING_ROOT.resolve()
        resolved_file = file_path.resolve()
        if resolved_root not in resolved_file.parents:
            return api_error('Invalid recording path', 400)
    except Exception:
        return api_error('Invalid recording path', 400)

    if not file_path.exists():
        return api_error('Recording file missing', 404)

    limit = max(1, min(5000, request.args.get('limit', default=500, type=int)))
    offset = max(0, request.args.get('offset', default=0, type=int))

    events: list[dict] = []
    seen = 0
    with file_path.open('r', encoding='utf-8', errors='replace') as fh:
        for idx, line in enumerate(fh):
            if idx < offset:
                continue
            if seen >= limit:
                break
            line = line.strip()
            if not line:
                continue
            try:
                events.append(json.loads(line))
                seen += 1
            except json.JSONDecodeError:
                continue

    return api_success(data={
        'recording': {
            'id': rec['id'],
            'mode': rec['mode'],
            'started_at': rec['started_at'],
            'stopped_at': rec['stopped_at'],
            'event_count': rec['event_count'],
        },
        'offset': offset,
        'limit': limit,
        'returned': len(events),
        'events': events,
    })