#!/bin/bash

# Script to create 4K compilation with 4 horizontal videos in a 2x2 grid
# Canvas: 3840x2160 (4K)
# Each horizontal video: 1920x1080
# Positioning (perfect fit):
#   Top-left:     X=0,    Y=0
#   Top-right:    X=1920, Y=0
#   Bottom-left:  X=0,    Y=1080
#   Bottom-right: X=1920, Y=1080
# Uses NVIDIA NVENC GPU acceleration for fast encoding

# Enable strict error handling
set -o pipefail  # Catch failures in piped commands

# Use environment variables if set (for Docker), otherwise use default paths
GIFS_DIR="${GIFS_PATH:-/media/bunker-admin/Internal/plex/xxx/media/local/gifs}"
OUTPUT_DIR="${INBOX_PATH:-/media/bunker-admin/Internal/plex/xxx/media/local/inbox}"

# Directory exclusion (colon-separated list of directory names to exclude)
EXCLUDED_DIRS="${EXCLUDED_DIRS:-}"

# Filter function for excluding directories (handles newline-terminated input)
filter_excluded() {
    if [[ -z "$EXCLUDED_DIRS" ]]; then
        cat  # Pass through unchanged
    else
        local pattern
        pattern=$(echo "$EXCLUDED_DIRS" | sed 's/:/|/g')
        grep -Ev "/($pattern)/"
    fi
}

cd "$GIFS_DIR" || exit 1

# Check if ffmpeg is available
if ! command -v ffmpeg &> /dev/null; then
    echo "Error: ffmpeg is not installed. Please install ffmpeg."
    exit 1
fi

# Check if ffprobe is available
if ! command -v ffprobe &> /dev/null; then
    echo "Error: ffprobe is not installed. Please install ffprobe."
    exit 1
fi

# Check if NVENC is available
if ! ffmpeg -hide_banner -encoders 2>/dev/null | grep -q h264_nvenc; then
    echo "Warning: NVENC encoder not available. Falling back to CPU encoding."
    ENCODER="libx264"
    ENCODER_OPTS="-preset medium -crf 23"
else
    # Check if NVENC encoder is currently in use (e.g., by Steam)
    enc_usage=$(nvidia-smi dmon -c 1 2>/dev/null | tail -1 | awk '{print $7}')
    if [[ "$enc_usage" -gt 50 ]]; then
        if [[ "${NONINTERACTIVE:-0}" == "1" ]]; then
            echo "GPU encoder in use (${enc_usage}%), proceeding anyway in non-interactive mode"
            ENCODER="h264_nvenc"
            ENCODER_OPTS="-preset p4 -cq 23 -rc vbr -gpu 0 -b_ref_mode 0"
        else
            echo ""
            echo "⚠️  WARNING: GPU encoder is currently in use (${enc_usage}% utilization)"
            echo "   This is likely Steam or another application using NVENC."
            echo ""
            echo "   Options:"
            echo "   1) Close Steam/other apps and press Enter to continue with GPU"
            echo "   2) Type 'cpu' to use CPU encoding instead (slower)"
            echo "   3) Press Ctrl+C to cancel"
            echo ""
            read -p "Choice: " enc_choice

            if [[ "$enc_choice" == "cpu" ]]; then
                echo "Using CPU encoding..."
                ENCODER="libx264"
                ENCODER_OPTS="-preset medium -crf 23"
            else
                # Re-check encoder usage
                enc_usage=$(nvidia-smi dmon -c 1 2>/dev/null | tail -1 | awk '{print $7}')
                if [[ "$enc_usage" -gt 50 ]]; then
                    echo "⚠️  Encoder still in use (${enc_usage}%). Will try GPU but may fall back to CPU."
                else
                    echo "✓ GPU encoder now available"
                fi
                ENCODER="h264_nvenc"
                ENCODER_OPTS="-preset p4 -cq 23 -rc vbr -gpu 0 -b_ref_mode 0"
            fi
        fi
    else
        echo "✓ NVENC GPU encoder detected and available"
        ENCODER="h264_nvenc"
        ENCODER_OPTS="-preset p4 -cq 23 -rc vbr -gpu 0 -b_ref_mode 0"
    fi
fi

# Get current date for filename
current_date=$(date +%d-%m-%Y)

echo ""
echo "========================================="
echo "  Quad Horizontal 4K Compilation (2x2)"
echo "  Encoder: $ENCODER"
echo "  Date: $current_date"
echo "========================================="
echo ""

# Non-interactive mode: use NUM_SETS from environment or default to 100
if [[ "${NONINTERACTIVE:-0}" == "1" ]]; then
    NUM_SETS="${NUM_SETS:-100}"
    echo "Non-interactive mode: Using $NUM_SETS sets"
else
    # Interactive menu to select number of clip sets
    echo "Select compilation size (sets of 4 videos):"
    echo "  1) 30 sets  (120 clips total)"
    echo "  2) 60 sets  (240 clips total)"
    echo "  3) 100 sets (400 clips total, default)"
    echo ""
    read -p "Enter choice [1-3] (default: 3): " size_choice
    echo ""

    case "$size_choice" in
        1)
            NUM_SETS=30
            ;;
        2)
            NUM_SETS=60
            ;;
        *)
            NUM_SETS=100
            ;;
    esac
fi

NUM_CLIPS=$((NUM_SETS * 4))
echo "Creating compilation with $NUM_SETS sets ($NUM_CLIPS clips total)"

# Log excluded directories if any
if [[ -n "$EXCLUDED_DIRS" ]]; then
    echo "Excluding directories: $EXCLUDED_DIRS"
fi
echo ""

start_time=$(date +%s)

# Function to get video duration in seconds
get_duration_seconds() {
    local file="$1"
    ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 "$file" 2>/dev/null | cut -d. -f1
}

# Function to format duration as H:MM
format_duration() {
    local seconds="$1"
    local hours=$((seconds / 3600))
    local minutes=$(((seconds % 3600) / 60))
    printf "%d:%02d" "$hours" "$minutes"
}

# Function to show progress bar
show_progress() {
    local current=$1
    local total=$2
    local width=40
    local percentage=$((current * 100 / total))
    local filled=$((width * current / total))
    local empty=$((width - filled))

    printf "\r   → Processing set %d/%d [" "$current" "$total"
    printf "%${filled}s" | tr ' ' '█'
    printf "%${empty}s" | tr ' ' '░'
    printf "] %3d%%" "$percentage"
}

# Function to check if video has audio stream
has_audio() {
    local file="$1"
    local audio_streams=$(ffprobe -v error -select_streams a -show_entries stream=index -of csv=p=0 "$file" 2>/dev/null)
    [[ -n "$audio_streams" ]]
}

# =========================================
# QUAD HORIZONTAL COMPILATION
# =========================================
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo "Creating Quad Horizontal 4K Compilation"
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo ""

# Find all horizontal MP4 files and shuffle
echo "   → Scanning for horizontal clips..."
mapfile -t h_files < <(find "$GIFS_DIR" -path "*/horizontal/*.mp4" -type f 2>/dev/null | filter_excluded | shuf)

h_total=${#h_files[@]}
echo "   → Found $h_total horizontal clips"

# We need clips in multiples of 4
clips_needed=$NUM_CLIPS
if [[ $h_total -lt $clips_needed ]]; then
    # Round down to nearest multiple of 4
    clips_needed=$((h_total / 4 * 4))
    NUM_SETS=$((clips_needed / 4))
    echo "   → Using $clips_needed clips ($NUM_SETS sets) - not enough for requested amount"
fi

if [[ $NUM_SETS -gt 0 ]]; then
    # Create temp directory for intermediate files
    temp_dir=$(mktemp -d)

    echo ""
    echo "   → Encoding sets of 4 videos..."

    for ((set=0; set<NUM_SETS; set++)); do
        show_progress "$((set + 1))" "$NUM_SETS"

        # Get indices for this set
        idx1=$((set * 4))
        idx2=$((set * 4 + 1))
        idx3=$((set * 4 + 2))
        idx4=$((set * 4 + 3))

        video1="${h_files[$idx1]}"
        video2="${h_files[$idx2]}"
        video3="${h_files[$idx3]}"
        video4="${h_files[$idx4]}"

        intermediate_file="$temp_dir/$(printf "%05d" $set).ts"

        # Get the shortest duration among the 4 videos to sync them
        dur1=$(get_duration_seconds "$video1")
        dur2=$(get_duration_seconds "$video2")
        dur3=$(get_duration_seconds "$video3")
        dur4=$(get_duration_seconds "$video4")

        # Find minimum duration
        min_dur=$dur1
        [[ $dur2 -lt $min_dur ]] && min_dur=$dur2
        [[ $dur3 -lt $min_dur ]] && min_dur=$dur3
        [[ $dur4 -lt $min_dur ]] && min_dur=$dur4

        # Check which videos have audio, generate silent audio for those that don't
        if has_audio "$video1"; then
            audio1_filter="[0:a]aresample=async=1,asetpts=PTS-STARTPTS[a0]"
        else
            audio1_filter="anullsrc=r=48000:cl=stereo,atrim=0:${min_dur}[a0]"
        fi

        if has_audio "$video2"; then
            audio2_filter="[1:a]aresample=async=1,asetpts=PTS-STARTPTS[a1]"
        else
            audio2_filter="anullsrc=r=48000:cl=stereo,atrim=0:${min_dur}[a1]"
        fi

        if has_audio "$video3"; then
            audio3_filter="[2:a]aresample=async=1,asetpts=PTS-STARTPTS[a2]"
        else
            audio3_filter="anullsrc=r=48000:cl=stereo,atrim=0:${min_dur}[a2]"
        fi

        if has_audio "$video4"; then
            audio4_filter="[3:a]aresample=async=1,asetpts=PTS-STARTPTS[a3]"
        else
            audio4_filter="anullsrc=r=48000:cl=stereo,atrim=0:${min_dur}[a3]"
        fi

        # FFmpeg complex filter to:
        # 1. Scale each video to 1920x1080
        # 2. Create black 4K canvas
        # 3. Overlay videos in 2x2 grid
        # Positions: Top-left (0,0), Top-right (1920,0), Bottom-left (0,1080), Bottom-right (1920,1080)

        filter_complex="
            [0:v]scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,fps=30,setpts=PTS-STARTPTS[v0];
            [1:v]scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,fps=30,setpts=PTS-STARTPTS[v1];
            [2:v]scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,fps=30,setpts=PTS-STARTPTS[v2];
            [3:v]scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2,fps=30,setpts=PTS-STARTPTS[v3];
            color=black:s=3840x2160:d=${min_dur}:r=30[base];
            [base][v0]overlay=0:0:shortest=1[tmp1];
            [tmp1][v1]overlay=1920:0:shortest=1[tmp2];
            [tmp2][v2]overlay=0:1080:shortest=1[tmp3];
            [tmp3][v3]overlay=1920:1080:shortest=1[vout];
            ${audio1_filter};
            ${audio2_filter};
            ${audio3_filter};
            ${audio4_filter};
            [a0][a1][a2][a3]amix=inputs=4:duration=shortest[aout]
        "

        # Try NVENC encoding
        nvenc_output=$(ffmpeg -nostdin \
            -i "$video1" -i "$video2" -i "$video3" -i "$video4" \
            -filter_complex "$filter_complex" \
            -map "[vout]" -map "[aout]" \
            -c:v $ENCODER $ENCODER_OPTS \
            -c:a aac -b:a 192k \
            -t "$min_dur" \
            -f mpegts \
            -y "$intermediate_file" 2>&1)
        nvenc_exit=$?

        # Check if NVENC failed
        if [[ $nvenc_exit -ne 0 ]] || [[ "$nvenc_output" == *"No capable devices"* ]] || [[ "$nvenc_output" == *"CUDA_ERROR"* ]]; then
            ffmpeg -nostdin \
                -i "$video1" -i "$video2" -i "$video3" -i "$video4" \
                -filter_complex "$filter_complex" \
                -map "[vout]" -map "[aout]" \
                -c:v libx264 -preset fast -crf 23 \
                -c:a aac -b:a 192k \
                -t "$min_dur" \
                -f mpegts \
                -loglevel error \
                -y "$intermediate_file" 2>&1
        fi

        # Small delay to let GPU resources release
        sleep 0.1
    done
    echo ""

    # Concatenate all segments
    echo "   → Merging all segments..."
    concat_list_file="$temp_dir/concat_list.txt"

    for ts_file in "$temp_dir"/*.ts; do
        echo "file '$(realpath "$ts_file")'" >> "$concat_list_file"
    done

    # Temporary output for metadata extraction
    temp_output="$temp_dir/output.mp4"

    ffmpeg -f concat -safe 0 -i "$concat_list_file" \
        -c copy \
        -movflags +faststart \
        -loglevel error \
        -y "$temp_output" 2>&1

    ffmpeg_exit=$?

    if [[ $ffmpeg_exit -eq 0 ]] && [[ -f "$temp_output" ]]; then
        # Get final video metadata
        total_duration=$(get_duration_seconds "$temp_output")
        duration_formatted=$(format_duration "$total_duration")

        # Create final filename with metadata (always 4K, always H for this format)
        final_filename="Quad Horizontal Comp [${current_date}] [${duration_formatted}] [4K] [E] [H].mp4"
        final_path="$OUTPUT_DIR/$final_filename"

        mv "$temp_output" "$final_path"

        file_size_human=$(du -h "$final_path" | cut -f1)
        echo "   ✓ Success! Created: $final_filename ($file_size_human)"
    else
        echo "   ✗ Failed to create compilation (exit code: $ffmpeg_exit)"
    fi

    # Cleanup
    rm -rf "$temp_dir"
else
    echo "   ⚠ Not enough horizontal clips found (need at least 4)"
fi

# Calculate elapsed time
end_time=$(date +%s)
elapsed=$((end_time - start_time))
hours=$((elapsed / 3600))
minutes=$(((elapsed % 3600) / 60))
seconds=$((elapsed % 60))

echo ""
echo ""
echo "========================================="
echo "  Quad Horizontal Compilation Complete!"
echo "========================================="
echo "  Time elapsed: ${hours}h ${minutes}m ${seconds}s"
echo "========================================="
echo ""