#!/usr/bin/env python3
"""
YouTube Tab → PDF 캡처 파이프라인
YouTube 기타 TAB 영상에서 Tab 프레임을 추출하여 깔끔한 A4 PDF 악보로 만듭니다.

사용법:
    python youtube_tab_to_pdf.py "https://youtu.be/VIDEO_ID"
    python youtube_tab_to_pdf.py "https://youtu.be/VIDEO_ID" -o output.pdf --debug
"""

import argparse
import os
import sys
import subprocess
import shutil
import re
from pathlib import Path
from typing import List, Tuple, Optional

import cv2
from video_cv_tracker import TemporalTracker
import numpy as np
import img2pdf
from PIL import Image

_ocr_reader = None

def _get_ocr_reader():
    global _ocr_reader
    if _ocr_reader is None:
        print("  → EasyOCR 모델 로딩 중 (초회 1번)...")
        try:
            import easyocr
            _ocr_reader = easyocr.Reader(['en'])
        except ImportError:
            print("  [경고] easyocr 라이브러리가 없습니다. OCR 중복 검증을 건너뜁니다.")
            return None
    return _ocr_reader

def _dedup_by_measure_number(frames: List[np.ndarray]) -> List[np.ndarray]:
    """OCR을 이용해 Tab 좌측 상단의 마디 번호를 읽고,
       연속으로 동일한 번호가 검출되면 중복으로 간주하고 제거합니다."""
    reader = _get_ocr_reader()
    if not reader:
        return frames

    print(f"  → 마디번호 기반 3차 중복 검증 시작 ({len(frames)} 프레임)")
    unique = []
    last_measure_num = None

    for i, frame in enumerate(frames):
        h, w = frame.shape[:2]
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) if len(frame.shape) == 3 else frame
        
        # 동적 투영(Projection)을 통해 첫 번째 오선지(Staff line)의 Y좌표 스캔
        _, thresh = cv2.threshold(gray, 200, 255, cv2.THRESH_BINARY_INV)
        row_sums = np.sum(thresh, axis=1) / 255
        
        # 폭의 50% 이상을 차지하는 검은 가로선을 오선지로 간주
        staff_lines = np.where(row_sums > w * 0.5)[0]
        
        if len(staff_lines) > 0:
            first_line_y = staff_lines[0]
            # 오선지 바로 위 영역 45px ~ 오선지 까지 (여유공간 2px) + 좌측 8% 너비만 추출 (기타 코드 다이어그램 제외)
            crop_y_start = max(0, first_line_y - 45)
            crop_y_end = max(10, first_line_y - 2)
            crop = gray[crop_y_start:crop_y_end, :int(w * 0.08)]
        else:
            # 안전 장치: 오선지를 못 찾았을 경우 기존 하드코딩 비율 사용
            crop = gray[:int(h * 0.25), :int(w * 0.08)]
            
        # 작은 마디번호의 인식률 극대화를 위해 3배 업스케일링 및 이진화 처리
        upscaled = cv2.resize(crop, (0, 0), fx=3.0, fy=3.0, interpolation=cv2.INTER_CUBIC)
        _, upscaled_thresh = cv2.threshold(upscaled, 150, 255, cv2.THRESH_BINARY_INV)
        
        results = reader.readtext(upscaled_thresh, allowlist='0123456789')
        
        measure_num = None
        if results:
            # conf > 0.4 이면서 1~3자리의 숫자로만 이루어진 텍스트를 마디 번호로 간주
            valid_results = [res[1] for res in results if res[2] > 0.4 and res[1].isdigit() and len(res[1]) <= 3]
            if valid_results:
                measure_num = valid_results[0]
        
        if measure_num is not None:
            if measure_num == last_measure_num:
                print(f"    - 프레임 {i+1}: 마디번호 [{measure_num}] 중복 감지 (삭제)")
                continue
            last_measure_num = measure_num
            print(f"    - 프레임 {i+1}: 마디번호 [{measure_num}] (유지)")
        else:
            print(f"    - 프레임 {i+1}: 마디번호 미검출 (유지)")
        
        unique.append(frame)

    print(f"  → OCR 3차: {len(unique)}개 고유 Tab 프레임")
    return unique

# Windows 콘솔 인코딩
if sys.platform == "win32":
    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
    sys.stderr.reconfigure(encoding="utf-8", errors="replace")


# ─── 설정 ─────────────────────────────────────────────────────────────────

DEFAULT_FPS = 2
SIMILARITY_THRESHOLD = 0.95
OVERLAY_SIMILARITY_THRESHOLD = 0.55

OVERLAY_MIN_AREA_RATIO = 0.05
OVERLAY_MAX_AREA_RATIO = 0.6
MIN_TAB_LINES = 4

# 프레임 추출 시 최대 폭 (1080p→1280p 다운스케일로 메모리 세이브)
MAX_FRAME_WIDTH = 1280
# 검출용 업스케일 폭 (360p→960px, 1.5x → Tab 라인 두꺼워짐)
DETECT_WIDTH = 960

PDF_DPI = 150
PDF_PAGE_WIDTH_MM = 210
PDF_PAGE_HEIGHT_MM = 297
PDF_MARGIN_MM = 10
TAB_GAP_MM = 3


# ─── Step 1: 다운로드 ─────────────────────────────────────────────────────

def _find_yt_dlp() -> str:
    yt_dlp = shutil.which("yt-dlp")
    if yt_dlp:
        return yt_dlp
    for pyver in ["Python312", "Python311", "Python310"]:
        p = Path(os.environ.get("APPDATA", "")) / "Python" / pyver / "Scripts" / "yt-dlp.exe"
        if p.exists():
            return str(p)
    p = Path(sys.executable).parent / "Scripts" / "yt-dlp.exe"
    if p.exists():
        return str(p)
    raise RuntimeError("yt-dlp를 찾을 수 없습니다. pip install yt-dlp")


def download_video(url: str, output_dir: Path) -> Tuple[Path, str]:
    """영상 다운로드 (1080p 우선)"""
    print("[1/5] 영상 다운로드 중...")
    yt_dlp = _find_yt_dlp()

    result = subprocess.run(
        [yt_dlp, "--get-title", "--encoding", "utf-8", url],
        capture_output=True, encoding="utf-8", errors="replace"
    )
    title = (result.stdout or "").strip() or "untitled"
    safe_title = re.sub(r'[\\/:*?"<>|\x00-\x1f]', '_', title)[:80]
    video_path = output_dir / f"{safe_title}.mp4"

    if video_path.exists():
        print(f"  → 이미 다운로드됨: {video_path.name}")
        return video_path, safe_title

    # 영상 추출 처리(CV)만 필요하므로, ffmpeg 병합이 불필요한 video-only 고화질 포맷(720p)을 직접 요청하여 360p 강등을 방지
    subprocess.run(
        [yt_dlp,
         "-f", "bestvideo[ext=mp4]",
         "-S", "res:720",
         "-o", str(video_path), url],
        encoding="utf-8", errors="replace", check=True
    )
    print(f"  → 다운로드 완료: {video_path.name}")
    return video_path, safe_title


# ─── Step 2: 프레임 추출 ──────────────────────────────────────────────────

def extract_frames(video_path: Path, fps: float = DEFAULT_FPS) -> List[np.ndarray]:
    print(f"[2/5] 프레임 추출 중 (fps={fps})...")
    cap = cv2.VideoCapture(str(video_path))
    if not cap.isOpened():
        raise RuntimeError(f"영상을 열 수 없습니다: {video_path}")

    video_fps = cap.get(cv2.CAP_PROP_FPS)
    total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
    interval = max(1, int(video_fps / fps))
    w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

    # 4K 이상 → 1080p 다운스케일 (OOM 방지)
    need_resize = w > MAX_FRAME_WIDTH
    if need_resize:
        scale = MAX_FRAME_WIDTH / w
        target_size = (MAX_FRAME_WIDTH, int(h * scale))
        print(f"  → {w}x{h} → {target_size[0]}x{target_size[1]} 다운스케일")

    frames = []
    idx = 0
    while True:
        ret, frame = cap.read()
        if not ret:
            break
        if idx % interval == 0:
            if need_resize:
                frame = cv2.resize(frame, target_size, interpolation=cv2.INTER_AREA)
            frames.append(frame)
            if len(frames) % 50 == 0:
                print(f"    ... {len(frames)}번째 프레임 추출 진행 중...", flush=True)
        idx += 1

    cap.release()
    print(f"  → {len(frames)}개 프레임 추출 ({w}x{h}, 원본 {video_fps:.0f}fps)")
    return frames


# ─── 핵심: 흰색 배경 Tab 영역 검출 ───────────────────────────────────────

def _find_white_tab_strip(frame: np.ndarray, min_strip_ratio: float = 0.10, mode: str = "largest") -> Optional[Tuple[int, int]]:
    """프레임에서 흰색 배경의 Tab 스트립 영역의 Y범위(top, bottom)를 반환.

    mode="largest": 가장 큰 하나의 스트립만 반환 (연속 스크롤용)
    mode="union": 최상단 스트립부터 최하단 스트립까지 전체를 포괄하여 반환 (오버레이용 다중 줄 보존)
    """
    h, w = frame.shape[:2]
    margin_x = int(w * 0.1)

    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
    _, s_ch, v_ch = cv2.split(hsv)

    roi_v = v_ch[:, margin_x:w - margin_x]
    roi_s = s_ch[:, margin_x:w - margin_x]

    pure_white = (roi_v > 180) & (roi_s < 40)
    bright_pastel = (roi_v > 200) & (roi_s < 100)
    tab_mask = pure_white | bright_pastel

    row_tab_ratio = np.mean(tab_mask, axis=1)
    bright_mask = row_tab_ratio > 0.5

    max_gap = int(h * 0.02)
    regions = []
    start = None
    gap_count = 0
    for i in range(h):
        if bright_mask[i]:
            if start is None: start = i
            gap_count = 0
        else:
            if start is not None:
                gap_count += 1
                if gap_count > max_gap:
                    length = (i - gap_count) - start
                    if length >= h * min_strip_ratio:
                        regions.append((start, i - gap_count))
                    start = None
    if start is not None:
        length = (h - gap_count) - start
        if length >= h * min_strip_ratio:
            regions.append((start, h - gap_count))

    if not regions: return None

    pad_top = int(h * 0.15)
    pad_bottom = int(h * 0.03)

    if mode == "union":
        top = max(0, min(r[0] for r in regions) - pad_top)
        bottom = min(h, max(r[1] for r in regions) + pad_bottom)
        return (top, bottom)

    # largest
    best = max(regions, key=lambda r: r[1] - r[0])
    top = max(0, best[0] - pad_top)
    bottom = min(h, best[1] + pad_bottom)
    return (top, bottom)


def _trim_to_content(crop: np.ndarray, margin_px: int = 6) -> np.ndarray:
    """넓게 크롭된 Tab 이미지에서 Tab 콘텐츠 영역만 정밀 트림.

    전략: HSV 기반으로 각 행의 '흰색 배경 비율'을 계산.
    - Tab 영역: 30~95%가 흰색 (흰 배경 + Tab 라인/숫자)
    - 기타 영상: 흰색 < 20% (어두운 배경)
    - 순수 여백: 흰색 > 97%
    이를 통해 상/하단의 기타 영상과 빈 여백 모두 제거."""
    h, w = crop.shape[:2]
    if h < 15 or w < 50:
        return crop

    hsv = cv2.cvtColor(crop, cv2.COLOR_BGR2HSV)
    _, s_ch, v_ch = cv2.split(hsv)

    # 흰색/밝은 파스텔 픽셀 비율 (Tab 배경 감지)
    white_mask = ((v_ch > 180) & (s_ch < 40)) | ((v_ch > 200) & (s_ch < 100))
    row_white = np.mean(white_mask, axis=1)

    # Tab 행 = 흰색 비율 30~97% (라인/숫자 + 흰 배경)
    tab_rows = (row_white > 0.30) & (row_white < 0.97)

    # 콘텐츠 존재 확인 (어두운 픽셀 > 0.2%) - 마디번호 같이 아주 작은 숫자도 보존하기 위해 스레스홀드 극단적 하향
    gray = cv2.cvtColor(crop, cv2.COLOR_BGR2GRAY) if len(crop.shape) == 3 else crop
    row_dark = np.mean(gray < 180, axis=1)
    content_rows = row_dark > 0.002

    # Tab 행 OR 콘텐츠 행
    valid_rows = tab_rows | content_rows

    # 상단: 첫 번째 유효 행
    top = 0
    for i in range(h):
        if valid_rows[i] and row_white[i] > 0.20:
            top = max(0, i - 120)  # 상단 마디번호 보존을 위해 압도적인 120px 강제 보호 (숫자가 꽤 높이 떠있음)
            break

    # 하단: 마지막 유효 행
    bottom = h
    for i in range(h - 1, -1, -1):
        if valid_rows[i] and row_white[i] > 0.20:
            bottom = min(h, i + margin_px)
            break

    if bottom - top < 15:
        return crop

    return crop[top:bottom, :]


def _has_tab_content(region: np.ndarray) -> bool:
    """흰색 영역 내에 실제 Tab 내용이 있는지 검증.
    방법: 흰색 배경 위의 어두운 픽셀(Tab 라인, 숫자, 코드명) 비율을 확인.
    Tab 영역은 일반적으로 3~25%의 어두운 콘텐츠를 포함."""
    if region is None or region.size == 0:
        return False

    gray = cv2.cvtColor(region, cv2.COLOR_BGR2GRAY) if len(region.shape) == 3 else region
    h, w = gray.shape
    if h < 15 or w < 50:
        return False

    # 어두운 픽셀 비율 (< 180 = 라인/숫자/코드 등)
    dark_pixels = np.sum(gray < 180)
    dark_ratio = dark_pixels / gray.size

    # Tab 영역: 3~25%가 어두운 콘텐츠 (순수 흰 배경이면 < 1%, 기타 영상이면 > 30%)
    return 0.02 < dark_ratio < 0.30


# ─── Step 3: 패턴 감지 ────────────────────────────────────────────────────

def _detect_tab_overlay(frame: np.ndarray) -> Optional[Tuple[int, int, int, int]]:
    """Tab을 포함한 흰색 오버레이 박스 검출"""
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    h, w = gray.shape

    _, thresh = cv2.threshold(gray, 220, 255, cv2.THRESH_BINARY)
    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (15, 15))
    closed = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel)
    contours, _ = cv2.findContours(closed, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

    total_area = h * w
    best = None
    best_area = 0

    for cnt in contours:
        x, y, cw, ch = cv2.boundingRect(cnt)
        area = cw * ch
        ratio = area / total_area
        # 오버레이 = 프레임 폭의 85% 미만인 독립 박스 (전폭 스트립은 scroll)
        width_ratio = cw / w
        if (OVERLAY_MIN_AREA_RATIO < ratio < OVERLAY_MAX_AREA_RATIO
                and width_ratio < 0.85
                and cw > ch * 0.5 and area > best_area):
            # Tab 내용 검증
            region = frame[y:y + ch, x:x + cw]
            if _has_tab_content(region):
                best = (x, y, cw, ch)
                best_area = area

    return best


def detect_pattern(frames: List[np.ndarray], sample_count: int = 15) -> str:
    print("[3/5] 영상 패턴 정밀 분석 중 (Motion Tracking)...")
    if len(frames) < 30: return "scroll"

    scroll_votes = 0
    overlay_votes = 0
    tab_bounds = None
    for f in frames[::30]:
        bounds = _find_white_tab_strip(f, mode="largest")
        if bounds:
            tab_bounds = bounds
            break
            
    if tab_bounds:
        top, bottom = tab_bounds
    else:
        top, bottom = int(frames[0].shape[0]*0.2), int(frames[0].shape[0]*0.8) # Default

    step = max(1, len(frames) // sample_count)
    for i in range(2, len(frames)-1, step):
        f1 = frames[i]
        f2 = frames[i+1]
        h, w = f1.shape[:2]
        
        # 악보 영역 내부에서 높이의 중앙부분(잡음이 적은 곳)만 사용
        crop_h = bottom - top
        safe_top = int(top + crop_h * 0.2)
        safe_bottom = int(top + crop_h * 0.8)
        
        crop1 = f1[safe_top:safe_bottom, :]
        crop2 = f2[safe_top:safe_bottom, :]
        
        g1 = _extract_tracking_channel(crop1)
        g2 = _extract_tracking_channel(crop2)
        
        template_w = int(w * 0.5)
        template = g1[:, w - template_w:]
        
        res = cv2.matchTemplate(g2, template, cv2.TM_CCOEFF_NORMED)
        _, max_val, _, max_loc = cv2.minMaxLoc(res)
        
        scroll_px = (w - template_w) - max_loc[0]
        
        # 강한 매칭이면서 스크롤이 없으면 정지된 페이지(overlay)
        if max_val > 0.90 and scroll_px <= 1:
            overlay_votes += 1
        # 의미있는 매칭이면서 확연한 스크롤이 보이면 연속 스크롤(scroll)
        elif max_val > 0.10 and scroll_px > 1:
            scroll_votes += 1
        else:
            overlay_votes += 1
            
    pattern = "scroll" if scroll_votes > overlay_votes else "overlay"
    print(f"  → 판단 패턴: {pattern} (Scroll:{scroll_votes}, Overlay/Static:{overlay_votes})")
    return pattern


# ─── Step 4: 고유 Tab 프레임 추출 ─────────────────────────────────────────

def compare_frames(frame1: np.ndarray, frame2: np.ndarray) -> float:
    """MSE 기반 유사도 (0~1, 1=동일)"""
    g1 = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY) if len(frame1.shape) == 3 else frame1
    g2 = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY) if len(frame2.shape) == 3 else frame2

    if g1.shape != g2.shape:
        g2 = cv2.resize(g2, (g1.shape[1], g1.shape[0]))

    target_w = 480
    if g1.shape[1] > target_w:
        scale = target_w / g1.shape[1]
        sz = (target_w, int(g1.shape[0] * scale))
        g1 = cv2.resize(g1, sz)
        g2 = cv2.resize(g2, sz)

    mse = np.mean(((g1.astype(np.float32) - g2.astype(np.float32)) / 255.0) ** 2)
    return max(0.0, 1.0 - min(mse * 8.0, 1.0))


def _dhash(image: np.ndarray, hash_size: int = 32) -> np.ndarray:
    """Difference Hash — 구조 기반 해시 (32×32 = 1024비트).
    인접 픽셀의 밝기 차이를 기록하여 위치 이동에 강건한 fingerprint 생성.
    16→32 확대로 마디번호/음표 위치까지 구분 가능."""
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) if len(image.shape) == 3 else image
    resized = cv2.resize(gray, (hash_size + 1, hash_size), interpolation=cv2.INTER_AREA)
    return (resized[:, 1:] > resized[:, :-1]).flatten()


def _dedup_by_hash(frames: List[np.ndarray],
                   max_hamming: int = 20) -> List[np.ndarray]:
    """pHash 기반 클러스터 중복 제거.
    유사 프레임을 그룹핑하고, 각 그룹에서 가장 선명한(Laplacian 분산 최대) 1장만 선택.
    → 스크롤 중복 + 반복 연습 구간 모두 제거."""
    if not frames:
        return []

    hashes = [_dhash(f) for f in frames]
    n = len(frames)
    used = [False] * n
    clusters = []

    for i in range(n):
        if used[i]:
            continue
        cluster = [i]
        used[i] = True
        for j in range(i + 1, n):
            if used[j]:
                continue
            dist = int(np.sum(hashes[i] != hashes[j]))
            if dist <= max_hamming:
                cluster.append(j)
                used[j] = True
        clusters.append(cluster)

    # 각 클러스터에서 최고 선명도 프레임 선택
    result = []
    for cluster in clusters:
        best_idx = max(cluster, key=lambda idx: cv2.Laplacian(
            cv2.cvtColor(frames[idx], cv2.COLOR_BGR2GRAY)
            if len(frames[idx].shape) == 3 else frames[idx],
            cv2.CV_64F).var())
        result.append(frames[best_idx])

    return result


def _extract_print_channel(frame: np.ndarray) -> np.ndarray:
    """PDF 출력용 채널 (Red 채널): 노란색을 투명(White)하게 만듦"""
    if len(frame.shape) != 3: return frame
    return frame[:, :, 2]

def _extract_tracking_channel(frame: np.ndarray) -> np.ndarray:
    """트래킹 전용 채널: 유색 커서(빨강, 노랑 등) 및 배경 노이즈를 완벽히 투명화하고, 오직 순수한 검은색 음표와 오선지만을 마스킹하여 추출"""
    if len(frame.shape) != 3: 
        return frame
        
    # B, G, R 모두 120 미만인 어두운 픽셀(순수 블랙 및 진회색)만 True로 마스킹
    # 빨간색(0, 0, 255)이나 노란색(0, 255, 255)은 R이나 G가 255이므로 완벽하게 걸러짐
    black_mask = (frame[:,:,0] < 120) & (frame[:,:,1] < 120) & (frame[:,:,2] < 120)
    
    # 흰 배경 위에 검은 음표만 그리기 (바이너리 이미지와 동일한 효과)
    img = np.full_like(frame[:,:,0], 255)
    img[black_mask] = 0
    
    # OpenCV matchTemplate은 밝기 기준 매칭을 하므로, 이미지 전체를 반전시킬 필요 없이
    # 이대로 넘기면 흰 바탕의 검은색 패턴 매칭이 정확히 일어남
    return img

def _detect_scroll_offset(frame_a: np.ndarray, frame_b: np.ndarray, min_confidence: float = 0.1) -> Tuple[int, float]:
    """이전 프레임(A)과 현재 프레임(B) 사이의 X축 이동량(Scroll)을 추정합니다."""
    h, w = frame_a.shape[:2]
    
    gb = _extract_tracking_channel(frame_b)
    ga = _extract_tracking_channel(frame_a)
    
    template_w = int(w * 0.5)
    template = ga[:, w - template_w:]
    result = cv2.matchTemplate(gb, template, cv2.TM_CCOEFF_NORMED)
    _, max_val, _, max_loc = cv2.minMaxLoc(result)
    scroll_px = (w - template_w) - max_loc[0]
    if max_val < min_confidence or scroll_px <= 0:
        return (0, max_val)
    return (scroll_px, max_val)

def _detect_measure_bars(gray_pano: np.ndarray) -> List[int]:
    """오직 기타 6현의 영역만 계산하여 세로로 쫙 채워진 마디 선(|)의 X좌표만 정밀하게 반환합니다."""
    _, thresh = cv2.threshold(gray_pano, 200, 255, cv2.THRESH_BINARY_INV)
    h, w = thresh.shape
    row_sums = np.sum(thresh, axis=1) / 255
    staff_rows = np.where(row_sums > w * 0.5)[0]
    
    if len(staff_rows) < 2: return []
        
    top_line = staff_rows[0]
    bottom_line = top_line
    for r in staff_rows:
        if r - top_line > 100: break
        bottom_line = r
        
    staff_region = thresh[top_line:bottom_line+1, :]
    expected_h = bottom_line - top_line + 1
    if expected_h < 10: return []
    
    col_sums = np.sum(staff_region, axis=0) / 255
    bar_cols = np.where(col_sums >= expected_h * 0.8)[0]
    
    measures = []
    curr = []
    for c in bar_cols:
        if not curr: curr.append(c)
        else:
            # [BUG3 FIX] 클러스터 허용폭 10→30px (마디선은 보통 2~5px 폭 클러스터)
            if c - curr[-1] < 30: curr.append(c)
            else:
                measures.append(int(np.mean(curr)))
                curr = [c]
    if curr: measures.append(int(np.mean(curr)))
    # [BUG3 FIX] 100px 미만 간격 마디선 제거 (음표 기둥 오탐 방지)
    measures = [x for i, x in enumerate(measures)
                if i == 0 or x - measures[i-1] >= 100]
    return measures

def _stamp_measure_number(measure_bgr: np.ndarray, num: int) -> np.ndarray:
    """마디 이미지 좌측 상단의 빈 공간에 자동으로 순차 진행 마디번호를 파란색 도장(Stamp)으로 찍습니다."""
    text = f"[{num}]"
    font = cv2.FONT_HERSHEY_SIMPLEX
    font_scale = 0.7
    thickness = 2
    color = (200, 0, 0)
    cv2.putText(measure_bgr, text, (15, 30), font, font_scale, color, thickness, cv2.LINE_AA)
    return measure_bgr

def _stitch_scroll_segment(segment: List[np.ndarray]) -> np.ndarray:
    if len(segment) == 1: return segment[0]
    min_h = min(f.shape[0] for f in segment)
    panorama = segment[0][:min_h, :]
    for i in range(1, len(segment)):
        curr = segment[i][:min_h, :]
        scroll_px, conf = _detect_scroll_offset(segment[i-1][:min_h, :], curr, min_confidence=0.1)
        if scroll_px > 0 and conf > 0.15:
            new_strip = curr[:, curr.shape[1] - scroll_px:]
            panorama = np.hstack([panorama, new_strip])
        else:
            panorama = np.hstack([panorama, curr])
    return panorama

def _merge_scroll_candidates(candidates: List[np.ndarray], min_scroll: int = 5, min_segment_len: int = 2) -> List[np.ndarray]:
    if len(candidates) <= 1: return candidates
    result = []
    current_segment = [candidates[0]]
    prev_s_px = 0
    prev_conf = 1.0

    for i in range(1, len(candidates)):
        prev_frame = candidates[i-1]
        curr_frame = candidates[i]
        s_px, conf = _detect_scroll_offset(prev_frame, curr_frame, min_confidence=0.1)
        
        # [BUG1 FIX] 씬 전환 조건: conf 기반만 사용
        # abs(s_px - prev_s_px) > 100 제거 — 스크롤 가속도를 씬전환으로 오탐하던 원인
        is_cut = (conf <= 0.15) or (prev_conf - conf > 0.4)
        
        if not is_cut:
            current_segment.append(curr_frame)
        else:
            if len(current_segment) >= min_segment_len:
                result.append(_stitch_scroll_segment(current_segment))
            else:
                result.extend(current_segment)
            current_segment = [curr_frame]
            
        prev_s_px = s_px
        prev_conf = conf

    if len(current_segment) >= min_segment_len:
        result.append(_stitch_scroll_segment(current_segment))
    else:
        result.extend(current_segment)
        
    return result

def _is_rewind_duplicate(query_bgr: np.ndarray, history_pano: np.ndarray) -> bool:
    if history_pano is None: return False
    h_gray = _extract_tracking_channel(history_pano)
    qw = min(800, query_bgr.shape[1])
    q_gray = _extract_tracking_channel(query_bgr[:, :qw])
    
    if h_gray.shape[0] != q_gray.shape[0] or h_gray.shape[1] < q_gray.shape[1]: return False
        
    res = cv2.matchTemplate(h_gray, q_gray, cv2.TM_CCOEFF_NORMED)
    _, max_val, _, max_loc = cv2.minMaxLoc(res)
    
    if max_val < 0.85: return False
    
    match_x = max_loc[0]
    
    # HEURISTIC 1: Is it just consecutive stitching from the immediate past?
    # If it matched the very end of history (< 2500 pixels from the end), it's just normal scroll overlap!
    if history_pano.shape[1] - match_x < 2500:
        return False
        
    # HEURISTIC 2: It matched deep in the past! It might be a rewind, OR it might be an identical Chorus.
    # We must check the measure number to differentiate identical Chorus vs exact D.S. al Coda rewind.
    
    qw_img = query_bgr[:, :qw]
    gray_for_staff = cv2.cvtColor(qw_img, cv2.COLOR_BGR2GRAY) if len(qw_img.shape) == 3 else qw_img
    _, bin_inv = cv2.threshold(gray_for_staff, 200, 255, cv2.THRESH_BINARY_INV)
    row_sums = np.sum(bin_inv, axis=1) / 255.0
    staff_rows = np.where(row_sums > qw * 0.4)[0]
    
    if len(staff_rows) < 2: return False
    staff_top = staff_rows[0]
    
    box_y1 = max(0, staff_top - 60)
    box_y2 = staff_top + 10
    
    box_x2 = min(250, query_bgr.shape[1], history_pano.shape[1] - match_x)
    
    q_num = query_bgr[box_y1:box_y2, 0:box_x2]
    h_num = history_pano[box_y1:box_y2, match_x:match_x+box_x2]
    
    if q_num.shape != h_num.shape or q_num.size == 0: return False
    
    diff = cv2.absdiff(cv2.cvtColor(q_num, cv2.COLOR_BGR2GRAY), cv2.cvtColor(h_num, cv2.COLOR_BGR2GRAY))
    mse = np.mean(diff ** 2)
    
    if mse < 300.0:
        return True
    return False

def merge_panoramas_list(panoramas):
    if not panoramas: return []
    merged_list = []
    current_master = panoramas[0].copy()
    history_pano = current_master.copy()
    rewind_state = False
    
    for i in range(1, len(panoramas)):
        next_pano = panoramas[i].copy()
        
        if _is_rewind_duplicate(next_pano, history_pano):
            print("    [Rewind Filter] D.S. al Coda or Backward Jump detected. Dropping redundant chronological playback.")
            rewind_state = True
            continue
            
        if rewind_state:
            print("    [Rewind Filter] Returning from rewind jump! Searching for novelty.")
            merged_list.append(current_master)
            current_master = next_pano
            if current_master.shape[0] == history_pano.shape[0]:
                history_pano = np.hstack([history_pano, next_pano])
            rewind_state = False
            continue
            
        head_w = min(800, next_pano.shape[1])
        head = next_pano[:, :head_w]
        
        search_w = min(1500, current_master.shape[1])
        search_region = current_master[:, -search_w:]
        h_gray = _extract_tracking_channel(head)
        s_gray = _extract_tracking_channel(search_region)
        matched = False
        if h_gray.shape[1] <= s_gray.shape[1] and h_gray.shape[0] == s_gray.shape[0]:
            res = cv2.matchTemplate(s_gray, h_gray, cv2.TM_CCOEFF_NORMED)
            _, max_val, _, max_loc = cv2.minMaxLoc(res)
            
            if max_val > 0.50:
                match_x_in_search = max_loc[0]
                absolute_match_x = current_master.shape[1] - search_w + match_x_in_search
                next_start_idx = current_master.shape[1] - absolute_match_x
                if next_start_idx < next_pano.shape[1]:
                    append_part = next_pano[:, next_start_idx:]
                    if append_part.shape[1] > 0:
                        current_master = np.hstack([current_master, append_part])
                        if current_master.shape[0] == history_pano.shape[0]:
                            history_pano = np.hstack([history_pano, append_part])
                matched = True
        
        if not matched:
            merged_list.append(current_master)
            current_master = next_pano
            if current_master.shape[0] == history_pano.shape[0]:
                history_pano = np.hstack([history_pano, next_pano])
            
    merged_list.append(current_master)
    return merged_list

def _find_all_measure_bars_standalone(img_bgr: np.ndarray, max_width: int) -> List[int]:
    cw = min(img_bgr.shape[1], max_width)
    img_gray = cv2.cvtColor(img_bgr[:, :cw], cv2.COLOR_BGR2GRAY) if len(img_bgr.shape) == 3 else img_bgr
    _, bin_inv = cv2.threshold(img_gray, 200, 255, cv2.THRESH_BINARY_INV)
    row_sums = np.sum(bin_inv, axis=1) / 255.0
    staff_rows = np.where(row_sums > cw * 0.4)[0]
    if len(staff_rows) >= 6:
        staff_y_top, staff_y_bottom = staff_rows[0], staff_rows[-1]
    else:
        staff_y_top, staff_y_bottom = int(img_bgr.shape[0] * 0.3), int(img_bgr.shape[0] * 0.8)
    expected_h = max(10, staff_y_bottom - staff_y_top + 1)
    staff_region = bin_inv[staff_y_top:staff_y_bottom+1, :]
    col_sums = np.sum(staff_region, axis=0) / 255.0
    bar_xs = np.where(col_sums >= expected_h * 0.6)[0]
    grouped_bars = []
    if len(bar_xs) > 0:
        c = [bar_xs[0]]
        for x in bar_xs[1:]:
            if x - c[-1] <= 15: c.append(x)
            else:
                grouped_bars.append(int(np.mean(c)))
                c = [x]
        grouped_bars.append(int(np.mean(c)))
    unique_bars = []
    for p in grouped_bars:
        if not unique_bars or p - unique_bars[-1] >= 50:
            unique_bars.append(p)
    return unique_bars

def tile_panoramas_to_a4(panoramas: List[np.ndarray], chunk_width: int=1800) -> List[np.ndarray]:
    if not panoramas: return []
    panorama = np.hstack(panoramas) if len(panoramas) > 1 else panoramas[0]
    rows = []
    x_curr = 0
    total_w = panorama.shape[1]
    while x_curr < total_w:
        remaining_w = total_w - x_curr
        if remaining_w <= chunk_width:
            r = panorama[:, x_curr:]
            if r.shape[1] > 50:
                r_padded = cv2.copyMakeBorder(r, 0, 0, 0, chunk_width - r.shape[1], cv2.BORDER_CONSTANT, value=[255,255,255])
                rows.append(r_padded)
            break
        slice_bgr = panorama[:, x_curr : min(x_curr + chunk_width + 100, total_w)]
        bars = _find_all_measure_bars_standalone(slice_bgr, slice_bgr.shape[1])
        valid_bars = [b for b in bars if 50 < b < chunk_width - 15]
        cut_offset = (valid_bars[-1] - 10) if valid_bars else chunk_width
        r = panorama[:, x_curr : x_curr + cut_offset]
        r_padded = cv2.copyMakeBorder(r, 0, 0, 0, chunk_width - r.shape[1], cv2.BORDER_CONSTANT, value=[255,255,255])
        rows.append(r_padded)
        x_curr += cut_offset
    return rows

def extract_unique_scroll(frames: List[np.ndarray], scan_dist: int = 4) -> List[np.ndarray]:
    from video_cv_tracker import TemporalTracker
    print("[Pipeline] Isolating static structures via TemporalTracker")
    tracker = TemporalTracker(diff_threshold=0.05)
    
    tab_bounds = None
    for f in frames[::30]:
        bounds = _find_white_tab_strip(f)
        if bounds:
            tab_bounds = bounds
            break
            
    if tab_bounds:
        top, bottom = tab_bounds
        print(f"  -> Found precise sheet music bounds: Y={top} to Y={bottom}")
    else:
        top, bottom = 0, frames[0].shape[0]
        
    for frame in frames:
        roi = frame[top:bottom, :]
        tracker.process_frame(roi)
        
    unique_pages = tracker.get_unique_pages()
    print(f"[Pipeline] Reduced down to {len(unique_pages)} static structural median pages.")
    
    print("  -> 점프 컷 및 도돌이표 처리 중...")
    panoramas = merge_panoramas_list(unique_pages)
    
    print("  -> A4 타일링 포맷팅 중...")
    return tile_panoramas_to_a4(panoramas, chunk_width=1800)

def extract_unique_overlay(frames: List[np.ndarray],
                           threshold: float = OVERLAY_SIMILARITY_THRESHOLD) -> List[np.ndarray]:
    """오버레이형: TemporalTracker 기반의 고해상도 페이지(단일 스트립 크롭) 추출 및 정밀 픽셀 중복 필터"""
    from video_cv_tracker import TemporalTracker
    print("[4/5] 정지형(Overlay) Tab 트래킹 및 고해상도 추출 중...")

    tab_bounds = None
    for f in frames[::30]:
        bounds = _find_white_tab_strip(f, mode="largest")
        if bounds:
            tab_bounds = bounds
            break
            
    if tab_bounds:
        top, bottom = tab_bounds
        print(f"  -> Found precise sheet music bounds: Y={top} to Y={bottom}")
    else:
        top, bottom = int(frames[0].shape[0]*0.2), int(frames[0].shape[0]*0.8)

    # BGR2GRAY 대신 True Black 채널을 사용하므로, 붉은색 재생커서 이동을 완벽히 무시합니다.
    # 따라서 악보가 물리적으로 넘어갈 때 발생하는 픽셀 변화(음표 교체)만 감지하게 되므로, 임계값을 0.03(3%)으로 극도로 낮춰 정밀도를 높입니다.
    tracker = TemporalTracker(diff_threshold=0.03)
    
    for frame in frames:
        if top is not None and bottom is not None:
            roi = frame[top:bottom, :]
        else:
            roi = frame
            
        roi_tracking = _extract_tracking_channel(roi)
        # 상하단 20%는 악보 밖이므로(예: 연주자 머리카락, 천장 등) 변화 감지에서 완전히 배제
        h_r = roi_tracking.shape[0]
        s_top = int(h_r * 0.20)
        s_bot = int(h_r * 0.80)
        roi_tracking[:s_top, :] = 255
        roi_tracking[s_bot:, :] = 255
        
        tracker.process_frame(roi, tracking_channel=roi_tracking)

    pages = tracker.get_unique_pages()
    print(f"[Tracker] {len(pages)}개의 최초 구분 페이지 추출됨. 전역 중복 페이지 병합 심사 중...")

    unique = []
    
    for crop in pages:
        if np.mean(cv2.cvtColor(crop, cv2.COLOR_BGR2GRAY)) < 80:
            continue

        is_dup = False
        crop_gray = _extract_tracking_channel(crop)
        h_c, w_c = crop_gray.shape
        crop_gray[:int(h_c * 0.20), :] = 255
        crop_gray[int(h_c * 0.80):, :] = 255
        
        for past_crop in unique:
            past_gray = _extract_tracking_channel(past_crop)
            past_gray[:int(h_c * 0.20), :] = 255
            past_gray[int(h_c * 0.80):, :] = 255
            
            # 약간의 위치 이동(+/- 10픽셀)을 탐색하기 위해 템플릿 사이즈를 줄임
            template = crop_gray[10:h_c-10, 10:w_c-10]
            res = cv2.matchTemplate(past_gray, template, cv2.TM_CCOEFF_NORMED)
            _, max_val, _, _ = cv2.minMaxLoc(res)
            
            # 90% 이상의 강한 상관계수를 가지면 인간의 눈에는 완벽히 똑같은 악보(도돌이표)임.
            if max_val > 0.90:
                is_dup = True
                break
                
        if not is_dup:
            unique.append(crop)

    print(f"  → 임시: {len(unique)}개 고유 오버레이 페이지 추출 성공. 상하단 여백 및 제목 정리 중...")
    
    trimmed_unique = []
    for crop in unique:
        gray = cv2.cvtColor(crop, cv2.COLOR_BGR2GRAY)
        _, thresh = cv2.threshold(gray, 200, 255, cv2.THRESH_BINARY_INV)
        row_sums = np.sum(thresh, axis=1) / 255.0
        
        # 폭의 40% 이상 차지하는 검은 오선지 영역만 찾음 (정적 제목 등 배제)
        h_c, w_c = crop.shape[:2]
        staff_rows = np.where(row_sums > w_c * 0.4)[0]
        if len(staff_rows) > 0:
            # 상단 여백 60px (코드, 기호 등), 하단 여백 30px
            top_y = max(0, staff_rows[0] - 60)
            bottom_y = min(h_c, staff_rows[-1] + 30)
            trimmed_unique.append(crop[top_y:bottom_y, :])
        else:
            trimmed_unique.append(crop)

    print(f"  → 최종: {len(trimmed_unique)}개 정제된 오버레이 페이지 추출 성공")
    return trimmed_unique


# ─── Step 5: A4 PDF 생성 ─────────────────────────────────────────────────

def generate_pdf(frames: List[np.ndarray], output_path: Path,
                 debug_dir: Optional[Path] = None) -> None:
    """Tab 프레임들을 A4 페이지에 여러 행으로 배치"""
    print("[5/5] A4 PDF 생성 중...")
    if not frames:
        print("  ⚠ 프레임 없음!")
        return

    page_w = int(PDF_PAGE_HEIGHT_MM / 25.4 * PDF_DPI)  # Landscape width
    page_h = int(PDF_PAGE_WIDTH_MM / 25.4 * PDF_DPI)   # Landscape height
    margin = int(PDF_MARGIN_MM / 25.4 * PDF_DPI)
    gap = int(TAB_GAP_MM / 25.4 * PDF_DPI)
    content_w = page_w - 2 * margin

    resized = []
    for i, frame in enumerate(frames):
        rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        img = Image.fromarray(rgb)
        if debug_dir:
            img.save(debug_dir / f"frame_{i:04d}.png")
        scale = content_w / img.width
        img_r = img.resize((content_w, int(img.height * scale)), Image.LANCZOS)
        resized.append(img_r)

    pages = []
    cur_y = margin
    page = Image.new('RGB', (page_w, page_h), (255, 255, 255))

    for img in resized:
        if cur_y + img.height > page_h - margin:
            pages.append(page)
            page = Image.new('RGB', (page_w, page_h), (255, 255, 255))
            cur_y = margin
        page.paste(img, (margin, cur_y))
        cur_y += img.height + gap

    if cur_y > margin + gap:
        pages.append(page)

    if not pages:
        return

    pages[0].save(str(output_path), save_all=True,
                  append_images=pages[1:], resolution=PDF_DPI)
    print(f"  → PDF: {len(resized)} Tab → {len(pages)} 페이지, {output_path.stat().st_size // 1024} KB")


def generate_long_image(chunks: List[np.ndarray], output_path: str):
    if not chunks:
        return
        
    print(f"DEBUG: First chunk shape = {chunks[0].shape}, dtype = {chunks[0].dtype}")
    # Calculate exact total height required
    total_h = sum(chunk.shape[0] for chunk in chunks)
    max_w = max(chunk.shape[1] for chunk in chunks)
    
    # Ensure correct channel dimensions for the canvas to prevent squishing!
    if len(chunks[0].shape) == 3:
        canvas = np.full((total_h, max_w, 3), 255, dtype=np.uint8)
    else:
        canvas = np.full((total_h, max_w), 255, dtype=np.uint8)
        
    y_offset = 0
    for chunk in chunks:
        h, w = chunk.shape[:2]
        if len(chunk.shape) == 3 and len(canvas.shape) == 2:
            canvas[y_offset:y_offset+h, :w] = cv2.cvtColor(chunk, cv2.COLOR_BGR2GRAY)
        elif len(chunk.shape) == 2 and len(canvas.shape) == 3:
            canvas[y_offset:y_offset+h, :w] = cv2.cvtColor(chunk, cv2.COLOR_GRAY2BGR)
        else:
            canvas[y_offset:y_offset+h, :w] = chunk
            
        y_offset += h
        
    cv2.imwrite(str(output_path), canvas)


# ─── Main ─────────────────────────────────────────────────────────────────

def main():
    parser = argparse.ArgumentParser(description="YouTube TAB → A4 PDF")
    parser.add_argument("url", help="YouTube URL")
    parser.add_argument("-o", "--output", help="출력 PDF 경로")
    parser.add_argument("--fps", type=float, default=DEFAULT_FPS)
    parser.add_argument("--similarity", type=float, default=None)
    parser.add_argument("--pattern", choices=["auto", "scroll", "overlay"],
                        default="auto")
    parser.add_argument("--debug", action="store_true")
    args = parser.parse_args()

    output_dir = Path("output")
    output_dir.mkdir(exist_ok=True)
    debug_dir = None
    if args.debug:
        debug_dir = output_dir / "debug_frames"
        debug_dir.mkdir(exist_ok=True)

    video_path, safe_title = download_video(args.url, output_dir)
    frames = extract_frames(video_path, fps=args.fps)
    if not frames:
        print("❌ 프레임 추출 실패")
        sys.exit(1)

    pattern = detect_pattern(frames) if args.pattern == "auto" else args.pattern

    if pattern == "scroll":
        sim = args.similarity if args.similarity else SIMILARITY_THRESHOLD
        unique = extract_unique_scroll(frames, threshold=sim)
    else:
        sim = args.similarity if args.similarity else OVERLAY_SIMILARITY_THRESHOLD
        unique = extract_unique_overlay(frames, threshold=sim)

    if not unique:
        print("❌ 고유 Tab 프레임 없음. --similarity를 낮추거나 --pattern을 수동 지정하세요.")
        sys.exit(1)

    pdf_path = Path(args.output) if args.output else output_dir / f"{safe_title}.pdf"
    generate_pdf(unique, pdf_path, debug_dir=debug_dir)
    generate_long_image(unique, pdf_path.with_suffix(".png"))

    print(f"\n✅ 완료! PDF: {pdf_path}")


if __name__ == "__main__":
    main()