#!/usr/bin/env bash
# render_batch_v2.sh - Lote v2 com cortes estrategicos revisados
#
# CORTES NOVOS (corrigidos pos-feedback Renato):
# - viral_01..05: trechos com fecho em fim de frase/ideia (30-70s)
# - explicativo_01: introducao completa energia telúrica (5.3min)
# - explicativo_02: apartamento vs casa + plantas/animais (3.3min) [tema diferente dos virais]
# - explicativo_03: mapeamento Hartmann + tipos de pontos (5.37min) [extensao do fim anterior]
#
# Pipeline:
# 1. -ss <start> -t <dur> antes do -i (seek preciso)
# 2. Crop 405:720:437:0 -> scale 1080:1920 -> setpts=PTS-STARTPTS + asetpts=PTS-STARTPTS
# 3. Queima ASS karaoke
# 4. Mede loudnorm passe 1
# 5. Aplica loudnorm passe unico linear com params medidos
# 6. ffprobe: start_time=0 nos 2 streams

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="${EDIT_DIR}/prenorm"

mkdir -p "$OUT_DIR" "$PRENORM_DIR"

# Crop identico ao piloto aprovado
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"

    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 + reset pts
    log "  Renderizando com 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 | grep -E "(frame=|Error|error)" | tail -3 || true

    [[ -f "$PRENORM" ]] || die "prenorm nao gerado: $PRENORM"

    # 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)

    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 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 | grep -E "(Output|Error|error|LUFS)" | tail -5 || true

    [[ -f "$OUT" ]] || die "output nao gerado: $OUT"

    # VALIDACAO
    log "  Validando com ffprobe..."
    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)

    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})"

    DUR_OK="PASS"
    python3 -c "exit(0 if abs(float('${V_DUR}')-float('${A_DUR}'))<0.15 else 1)" || DUR_OK="FAIL(diff=$(python3 -c "print(abs(float('${V_DUR}')-float('${A_DUR}')))"))"

    log "  VIDEO: start=${V_START} dur=${V_DUR}"
    log "  AUDIO: start=${A_START} dur=${A_DUR}"
    log "  Tamanho: ${FSIZE}"
    log "  RESULTADO: video_start=${V_OK} audio_start=${A_OK} dur_sync=${DUR_OK}"
    log "  ---"

    if [[ "$V_OK" != "PASS" || "$A_OK" != "PASS" || "$DUR_OK" != "PASS" ]]; then
        echo "ATENCAO: ${NAME} falhou validacao"
        return 1
    fi

    log "  ${NAME} OK -> $OUT"
}

# Tabela: nome start_s duracao_s
# Duracao = end - start (calculada com precisao decimal)
declare -a CUTS=(
    "viral_01    677.52   68.46"
    "viral_02   1076.24   55.28"
    "viral_03   1413.50   56.70"
    "viral_04    782.76   54.48"
    "viral_05   1145.00   48.60"
    "explicativo_01  120.00  317.96"
    "explicativo_02 2285.00  200.22"
    "explicativo_03 1555.00  321.26"
)

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 v2 concluido ==="
ls -lh "$OUT_DIR/"