#!/usr/bin/env bash
# render_batch.sh - Render em lote de todos os cortes Borrello
# Replica exatamente o padrao tecnico do piloto_01.mp4 aprovado.
#
# Pipeline por corte:
# 1. ffmpeg -ss <start> -t <dur> -i <fonte>  (seek antes do -i = preciso e rapido)
# 2. Crop 405:720 centrado no eixo X (x_offset=437 = mesmo do piloto)
# 3. Scale para 1080x1920 + setpts=PTS-STARTPTS / asetpts=PTS-STARTPTS
# 4. Queima ASS de karaoke
# 5. Audio: loudnorm -14 LUFS / -1 dBTP / LRA 11 em PASSE UNICO com params medidos
# 6. H.264 CRF 23 / 30fps / stereo 192k
# 7. Valida com ffprobe (start_time=0, duracoes iguais)

set -euo pipefail

SOURCE="/opt/mia/workspace/videos/borrello_lives/ENERGIAS DO SOBSOLO - CASAS QUE MATAM _ Francisco Borrello.mp4"
EDIT_DIR="/opt/mia/workspace/videos/borrello_lives/edit"
OUT_DIR="/opt/mia/workspace/videos/borrello_lives/cortes"
PRENORM_DIR="/opt/mia/workspace/videos/borrello_lives/edit/prenorm"

mkdir -p "$OUT_DIR" "$PRENORM_DIR"

# crop X offset: 437 mantém Borrello centralizado (testado no piloto)
CROP_X=437
CROP_W=405
CROP_H=720

log() { echo "[$(date +%H:%M:%S)] $*"; }
die() { echo "ERRO: $*" >&2; exit 1; }

render_cut() {
    local NAME="$1"
    local START="$2"
    local DUR="$3"
    local ASS="${EDIT_DIR}/karaoke_${NAME}.ass"
    local PRENORM="${PRENORM_DIR}/${NAME}_prenorm.mp4"
    local OUT="${OUT_DIR}/${NAME}.mp4"

    # explicativos usam CRF 26 para cabir em tamanho razoavel; virais ficam em 23
    local CRF=23
    [[ "$NAME" == explicativo_* ]] && CRF=26

    [[ -f "$ASS" ]] || die "ASS nao encontrado: $ASS"

    log "=== $NAME | start=${START}s dur=${DUR}s ==="

    # PASSO 1: corte + crop + scale + karaoke queimado (sem loudnorm ainda)
    log "  Cortando e renderizando karaoke..."
    ffmpeg -y \
        -ss "$START" -t "$DUR" \
        -i "$SOURCE" \
        -filter_complex \
            "[0:v]crop=${CROP_W}:${CROP_H}:${CROP_X}:0,scale=1080:1920:flags=lanczos,setpts=PTS-STARTPTS,ass='${ASS}'[vout];
             [0:a]asetpts=PTS-STARTPTS[aout]" \
        -map "[vout]" -map "[aout]" \
        -c:v libx264 -preset fast -crf "$CRF" -r 30 \
        -c:a aac -b:a 192k -ac 2 \
        -movflags +faststart \
        "$PRENORM" 2>&1 | tail -3

    # PASSO 2: medir loudnorm
    log "  Medindo loudnorm..."
    LOUDNORM_JSON=$(ffmpeg -i "$PRENORM" \
        -af "loudnorm=I=-14:TP=-1:LRA=11:print_format=json" \
        -f null - 2>&1 | grep -A 20 '^\{' | head -20 || true)

    # extrair parametros medidos
    IN_I=$(echo "$LOUDNORM_JSON"    | python3 -c "import json,sys; d=json.load(sys.stdin); print(d['input_i'])" 2>/dev/null || echo "-14")
    IN_TP=$(echo "$LOUDNORM_JSON"   | python3 -c "import json,sys; d=json.load(sys.stdin); print(d['input_tp'])" 2>/dev/null || echo "-1")
    IN_LRA=$(echo "$LOUDNORM_JSON"  | python3 -c "import json,sys; d=json.load(sys.stdin); print(d['input_lra'])" 2>/dev/null || echo "11")
    IN_THR=$(echo "$LOUDNORM_JSON"  | python3 -c "import json,sys; d=json.load(sys.stdin); print(d['input_thresh'])" 2>/dev/null || echo "-24")

    log "  Loudnorm medido: I=${IN_I} TP=${IN_TP} LRA=${IN_LRA} THR=${IN_THR}"

    # PASSO 3: aplicar loudnorm com params medidos (passe unico linear)
    log "  Aplicando loudnorm e exportando final..."
    ffmpeg -y \
        -i "$PRENORM" \
        -af "loudnorm=I=-14:TP=-1:LRA=11:measured_I=${IN_I}:measured_TP=${IN_TP}:measured_LRA=${IN_LRA}:measured_thresh=${IN_THR}:offset=0:linear=true:print_format=summary" \
        -c:v copy \
        -c:a aac -b:a 192k -ac 2 \
        -movflags +faststart \
        "$OUT" 2>&1 | tail -4

    # VALIDACAO com ffprobe
    log "  Validando $OUT..."
    PROBE=$(ffprobe -v quiet -print_format json \
        -show_entries stream=index,codec_type,start_time,duration \
        "$OUT" 2>/dev/null)

    V_START=$(echo "$PROBE" | python3 -c "import json,sys; d=json.load(sys.stdin); v=[s for s in d['streams'] if s['codec_type']=='video'][0]; print(v['start_time'])")
    A_START=$(echo "$PROBE" | python3 -c "import json,sys; d=json.load(sys.stdin); a=[s for s in d['streams'] if s['codec_type']=='audio'][0]; print(a['start_time'])")
    V_DUR=$(echo "$PROBE"   | python3 -c "import json,sys; d=json.load(sys.stdin); v=[s for s in d['streams'] if s['codec_type']=='video'][0]; print(v['duration'])")
    A_DUR=$(echo "$PROBE"   | python3 -c "import json,sys; d=json.load(sys.stdin); a=[s for s in d['streams'] if s['codec_type']=='audio'][0]; print(a['duration'])")
    FSIZE=$(du -sh "$OUT" | cut -f1)

    log "  VIDEO: start=${V_START} dur=${V_DUR}"
    log "  AUDIO: start=${A_START} dur=${A_DUR}"
    log "  Tamanho: ${FSIZE}"

    # checar se start_time = 0 nos dois streams
    V_OK="PASS"
    A_OK="PASS"
    [[ "$V_START" == "0.000000" ]] || V_OK="FAIL(start=${V_START})"
    [[ "$A_START" == "0.000000" ]] || A_OK="FAIL(start=${A_START})"

    # verificar diferenca de duracao < 0.1s
    DUR_DIFF=$(python3 -c "print(abs(float('${V_DUR}') - float('${A_DUR}')))")
    DUR_OK="PASS"
    python3 -c "exit(0 if abs(float('${V_DUR}')-float('${A_DUR}'))<0.15 else 1)" || DUR_OK="FAIL(diff=${DUR_DIFF})"

    echo "  RESULTADO: video_start=${V_OK} audio_start=${A_OK} dur_sync=${DUR_OK}"
    echo "  ---"

    if [[ "$V_OK" != "PASS" || "$A_OK" != "PASS" || "$DUR_OK" != "PASS" ]]; then
        echo "ATENCAO: $NAME falhou validacao - verificar antes de entregar"
        return 1
    fi

    log "  $NAME OK -> $OUT"
}

# Tabela de cortes: nome start_s duracao_s
# Os durations sao calculados como (end - start)
declare -a CUTS=(
    "viral_01    677.5   67.9"
    "viral_02    903.0   72.0"
    "viral_03   1076.0   55.0"
    "viral_04   1439.0   36.0"
    "viral_05   4220.0   55.0"
    "explicativo_01  148.0  207.0"
    "explicativo_02  517.0  360.0"
    "explicativo_03 1555.0  300.0"
)

FILTER="${1:-}"

for cut in "${CUTS[@]}"; do
    read -r NAME START DUR <<< "$cut"
    if [[ -n "$FILTER" && "$NAME" != "$FILTER" ]]; then
        continue
    fi
    render_cut "$NAME" "$START" "$DUR"
done

log "=== Batch concluido ==="
ls -lh "$OUT_DIR/"