#!/usr/bin/env python3
"""
youtube-check-new-transcripts.py

유튜브 요약 대기 영상 감지 스크립트 (Haiku 팀원용)

Firestore youtube_summary_queue 컬렉션에서 summaryStatus='pending'인 영상을 확인합니다.
새 전문이 있으면 videoId, 제목, 채널명 등의 정보를 JSON으로 출력합니다.

사용법:
    python3 youtube-check-new-transcripts.py
    python3 youtube-check-new-transcripts.py --with-transcript --video-id <videoId>

작업: task-192.1
"""

import json
import os
import subprocess
import sys
import argparse
from pathlib import Path
from datetime import datetime

# 프로젝트 경로
INSUWIKI_PROJECT_DIR = Path("/home/jay/projects/insuwiki")
SCRIPTS_DIR = INSUWIKI_PROJECT_DIR / "scripts"
YOUTUBE_GET_PENDING_SCRIPT = SCRIPTS_DIR / "youtube-get-pending.ts"

# 전문 저장 디렉토리
_WORKSPACE_ROOT = os.environ.get("WORKSPACE_ROOT", str(Path(__file__).resolve().parent.parent))
TRANSCRIPT_DIR = Path(_WORKSPACE_ROOT) / "memory" / "youtube-transcripts"


def run_ts_script(script_path: Path, args: list[str] = None) -> dict:
    """
    TypeScript 스크립트를 실행하고 JSON 결과를 반환
    
    Args:
        script_path: TypeScript 스크립트 경로
        args: 추가 인수 목록
        
    Returns:
        dict: 파싱된 JSON 결과
    """
    cmd = ["npx", "ts-node", str(script_path)]
    if args:
        cmd.extend(args)
    
    try:
        result = subprocess.run(
            cmd,
            capture_output=True,
            text=True,
            cwd=str(INSUWIKI_PROJECT_DIR),
            timeout=60
        )
        
        if result.returncode != 0:
            print(f"[ERROR] 스크립트 실행 실패: {result.stderr}", file=sys.stderr)
            return {"error": result.stderr, "returncode": result.returncode}
        
        # stdout에서 JSON 파싱
        stdout_lines = result.stdout.strip().split('\n')
        # 마지막 라인이 JSON일 가능성이 높음
        for line in reversed(stdout_lines):
            line = line.strip()
            if line.startswith('{') and line.endswith('}'):
                try:
                    return json.loads(line)
                except json.JSONDecodeError:
                    continue
        
        # JSON을 찾지 못한 경우
        return {"error": "JSON 파싱 실패", "stdout": result.stdout}
        
    except subprocess.TimeoutExpired:
        return {"error": "타임아웃 (60초)"}
    except Exception as e:
        return {"error": str(e)}


def get_pending_videos() -> dict:
    """
    요약 대기 중인 영상 목록 조회
    
    Returns:
        dict: {pendingCount, videos: [{videoId, title, channelName, ...}]}
    """
    print("[youtube-check-new-transcripts] 대기 영상 조회 중...", file=sys.stderr)
    return run_ts_script(YOUTUBE_GET_PENDING_SCRIPT)


def get_transcript(video_id: str) -> dict:
    """
    특정 영상의 전문(transcript) 조회
    
    Args:
        video_id: 유튜브 영상 ID
        
    Returns:
        dict: {videoId, title, channelName, transcript}
    """
    print(f"[youtube-check-new-transcripts] videoId={video_id} 전문 조회 중...", file=sys.stderr)
    return run_ts_script(YOUTUBE_GET_PENDING_SCRIPT, ["--with-transcript", "--videoId", video_id])


def save_transcript(video_id: str, title: str, channel_name: str, transcript: str) -> Path:
    """
    전문을 로컬 파일로 저장
    
    Args:
        video_id: 유튜브 영상 ID
        title: 영상 제목
        channel_name: 채널명
        transcript: 전문 텍스트
        
    Returns:
        Path: 저장된 파일 경로
    """
    TRANSCRIPT_DIR.mkdir(parents=True, exist_ok=True)
    
    # 파일명에 특수문자 제거
    safe_title = "".join(c for c in title if c.isalnum() or c in " -_")[:50] if title else "unknown"
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    filename = f"{video_id}_{safe_title}_전문.md"
    filepath = TRANSCRIPT_DIR / filename
    
    # 마크다운 헤더 추가
    content = f"""# {title or '(제목 없음)'}

- **채널**: {channel_name or '(채널 없음)'}
- **영상 ID**: {video_id}
- **원본 URL**: https://www.youtube.com/watch?v={video_id}
- **저장일**: {datetime.now().isoformat()}

---

## 전문

{transcript}
"""
    
    with open(filepath, 'w', encoding='utf-8') as f:
        f.write(content)
    
    print(f"[youtube-check-new-transcripts] 전문 저장 완료: {filepath}", file=sys.stderr)
    return filepath


def main():
    parser = argparse.ArgumentParser(description='유튜브 요약 대기 영상 감지 스크립트')
    parser.add_argument('--with-transcript', action='store_true', 
                        help='특정 영상의 전문 조회')
    parser.add_argument('--video-id', type=str, 
                        help='전문 조회할 영상 ID (--with-transcript 필요)')
    parser.add_argument('--save-transcript', action='store_true',
                        help='전문을 로컬 파일로 저장')
    parser.add_argument('--format', choices=['json', 'text'], default='json',
                        help='출력 형식 (기본: json)')
    
    args = parser.parse_args()
    
    if args.with_transcript:
        if not args.video_id:
            print("[ERROR] --with-transcript 사용 시 --video-id 필요", file=sys.stderr)
            sys.exit(1)
        
        result = get_transcript(args.video_id)
        
        if "error" in result:
            print(json.dumps(result, ensure_ascii=False))
            sys.exit(1)
        
        # 전문 저장 옵션
        if args.save_transcript and result.get("transcript"):
            filepath = save_transcript(
                result["videoId"],
                result.get("title"),
                result.get("channelName"),
                result["transcript"]
            )
            result["savedTo"] = str(filepath)
        
        if args.format == 'text':
            print(f"=== 영상 정보 ===")
            print(f"Video ID: {result.get('videoId')}")
            print(f"제목: {result.get('title')}")
            print(f"채널: {result.get('channelName')}")
            print(f"\n=== 전문 ({len(result.get('transcript', ''))}자) ===")
            print(result.get('transcript', '(없음)')[:500] + "...")
        else:
            print(json.dumps(result, ensure_ascii=False, indent=2))
    
    else:
        # 기본 모드: pending 영상 목록 조회
        result = get_pending_videos()
        
        if "error" in result:
            print(json.dumps(result, ensure_ascii=False))
            sys.exit(1)
        
        if args.format == 'text':
            print(f"=== 요약 대기 영상 ({result.get('pendingCount', 0)}개) ===")
            for i, video in enumerate(result.get('videos', []), 1):
                print(f"\n{i}. {video.get('title', '(제목 없음)')}")
                print(f"   Video ID: {video.get('videoId')}")
                print(f"   채널: {video.get('channelName')}")
                print(f"   업로드일: {video.get('publishedAt')}")
                print(f"   자막: {'있음' if video.get('hasTranscript') else '없음'}")
        else:
            print(json.dumps(result, ensure_ascii=False, indent=2))
        
        # pending이 없으면 exit code 0으로 종료 (cron 친화적)
        if result.get('pendingCount', 0) == 0:
            sys.exit(0)


if __name__ == '__main__':
    main()