import subprocess
import json
import os
import tempfile
import shutil

from video_funcs import get_video_info, get_target_bitrate, get_target_resolution, get_fps

TEMP_DIR = ".temp"
CONCATED_DIR = "concated"

# --- helpers --------------------------------------------------------------- #

def get_signature(fp: str) -> tuple:
    """
    A ‘signature’ is everything that has to match for a bit-perfect concat:
        – video: codec, width, height, fps (as a float), pix_fmt, color_range
        – audio: codec, sample_rate, channels, channel_layout
    """
    def ffprobe_json(fp: str) -> dict:
        """Return the full ffprobe-JSON for a media file."""
        cmd = [
            "ffprobe", "-v", "quiet", "-print_format", "json",
            "-show_streams", "-show_format", fp
        ]
        return json.loads(subprocess.check_output(cmd, text=True))
    
    info = ffprobe_json(fp)
    v_stream = next(s for s in info["streams"] if s["codec_type"] == "video")
    a_stream = next((s for s in info["streams"] if s["codec_type"] == "audio"), None)

    def fps(stream):
        fr = stream.get("r_frame_rate", "0/0")
        num, den = map(int, fr.split("/"))
        return round(num / den, 3) if den else 0.0

    sig = (
        v_stream["codec_name"],
        int(v_stream["width"]), int(v_stream["height"]),
        fps(v_stream),
        v_stream.get("pix_fmt"),
        v_stream.get("color_range"),
        a_stream["codec_name"] if a_stream else None,
        int(a_stream["sample_rate"]) if a_stream else None,
        a_stream.get("channels") if a_stream else None,
        a_stream.get("channel_layout") if a_stream else None,
    )
    return sig

def all_signatures_equal(videos):
    ref = get_signature(videos[0]["filepath"])
    return all(get_signature(v["filepath"]) == ref for v in videos[1:])


# --- concat functions --------------------------------------------------------------- #

def concat_copy(videos, out_path):
    """Lossless concat with the *concat demuxer* (-c copy)."""
    with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False) as f:
        for v in videos:
            f.write(f"file '{os.path.abspath(v['filepath']).replace('\'', '\\\'')}'\n")
        list_file = f.name

    cmd = [
        "ffmpeg", "-y",
        "-f", "concat", "-safe", "0",
        "-i", list_file,
        "-c", "copy",
        out_path,
    ]

    result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)

    os.unlink(list_file)

    # Look for specific error patterns in FFmpeg's stderr
    ffmpeg_errors = [
        "corrupt input packet",
        "Invalid OBU",
        "Failed to parse temporal unit",
        "Packet corrupt",
        "partial file",
        "Non-monotonic DTS"
    ]

    if result.returncode != 0 or any(err in result.stderr for err in ffmpeg_errors):
        print("❌ FFmpeg concat failed or produced corrupted output.")
        print("FFmpeg stderr:")
        print(result.stderr)
        # Remove broken file if it exists
        if os.path.exists(out_path):
            os.remove(out_path)
            print(f"🗑️ Removed corrupt output: {out_path}")
        return False

    print("✅ FFmpeg concat completed successfully.")
    return True

def concatenate_videos(videos_list, reencode_concate = False):
    """
    Concatenate pre-grouped videos, then re-encode them using AV1 (NVENC)
    while forcing a unified resolution and frame rate on each input
    before final concatenation in one ffmpeg command.
    """
    
    if len(videos_list) <= 1:
        return False

    copy_concat = copy_concatenate_videos(videos_list)
    
    if copy_concat:
        return copy_concat

    if not reencode_concate:
        return False
    
    print("Falling back to re-encoding due to concat failure.")
    return encode_concatenate_videos(videos_list)

def copy_concatenate_videos(videos_list):
    from concat_helper import all_signatures_equal, concat_copy
    
    if not (len(videos_list) > 1 and all_signatures_equal(videos_list)):
        print("Streams are not compatible for lossless concat.")
        return False

        
    print("All streams are compatible – attempting lossless concat …")
    main_video = videos_list[0]
    video_path = main_video["filepath"]
    output_path = os.path.join(TEMP_DIR, os.path.basename(video_path))

    os.makedirs(CONCATED_DIR, exist_ok=True)
    success = concat_copy(videos_list, output_path)

    if not success:
        return False

    # Remove originals
    for v in videos_list:
        os.remove(v["filepath"])

    # move temp to concated folder
    os.rename(output_path, os.path.join(CONCATED_DIR, os.path.basename(video_path)))

    return main_video

def encode_concatenate_videos(videos_list):
    """Encode and concatenate videos without ffmpeg spam in console."""
    main_video = videos_list[0]
    video_path = main_video["filepath"]

    os.makedirs(TEMP_DIR, exist_ok=True)
    os.makedirs(CONCATED_DIR, exist_ok=True)
    
    temp_path = os.path.join(TEMP_DIR, os.path.basename(video_path))
    output_path = os.path.join(CONCATED_DIR, os.path.basename(video_path))

    video_info = get_video_info(videos_list[0]['filepath'])
    current_bitrate = int(video_info.get('bitrate') or 0)

    target_width, target_height = get_target_resolution(videos_list)
    target_bitrate_kbps = get_target_bitrate(target_width, target_height)

    if current_bitrate > 0:
        target_bitrate_kbps = min(target_bitrate_kbps, current_bitrate)
        max_bitrate_kbps = min(int(1.5 * target_bitrate_kbps), current_bitrate)
    else:
        max_bitrate_kbps = int(1.5 * target_bitrate_kbps)

    fps_float = get_fps(video_path) or video_info.get('fps') or 30.0
    if fps_float <= 0:
        fps_float = 30.0
    keyframe_interval = int(fps_float)

    print(f"Concatenating {len(videos_list)} videos into {temp_path}")
    print(f"  Mode Resolution: {target_width}x{target_height}")
    print(f"  Target Bitrate: {target_bitrate_kbps}k (max ~{max_bitrate_kbps}k)")
    print(f"  Keyframe Interval: {keyframe_interval}")

    cmd = ["ffmpeg", "-y"]
    for v in videos_list:
        cmd.extend(["-i", v["filepath"]])

    filter_statements = []
    concat_streams = []
    n = len(videos_list)
    unified_fps = 30

    for i in range(n):
        filter_statements.append(
            f"[{i}:v]fps={unified_fps},scale={target_width}:{target_height}[v{i}]"
        )
        concat_streams.append(f"[v{i}][{i}:a]")

    concat_line = "".join(concat_streams) + f"concat=n={n}:v=1:a=1[outv][outa]"
    filter_statements.append(concat_line)
    filter_complex = ";".join(filter_statements)

    cmd.extend([
        "-filter_complex", filter_complex,
        "-map", "[outv]",
        "-map", "[outa]",
        "-c:v", "av1_nvenc",
        "-b:v", f"{target_bitrate_kbps}k",
        "-maxrate", f"{max_bitrate_kbps}k",
        "-bufsize", f"{max_bitrate_kbps}k",
        "-preset", "p5",
        "-g", str(keyframe_interval),
        "-c:a", "aac",
        "-b:a", "192k",
        temp_path
    ])

    try:
        subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
    except subprocess.CalledProcessError:
        return False

    for video in videos_list:
        os.remove(video["filepath"])

    shutil.move(temp_path, output_path)
    return main_video