Youtube

"""
Fetch public channel data via YouTube Data API v3.

Uses the uploads playlist path (channels.list → playlistItems.list → videos.list)
to avoid expensive search.list calls. Total cost: ~16 units for channel + 10 videos.

Input: channel ID, handle (@username), or channel URL
Output: JSON with channel stats and top N videos

Usage:
    python execution/fetch_channel_data.py UCxxxxxxxxxxxxxxxx
    python execution/fetch_channel_data.py @channelhandle
    python execution/fetch_channel_data.py "https://youtube.com/@handle"
    python execution/fetch_channel_data.py UCxxx --videos 20
"""

import argparse
import json
import re
import sys
from datetime import datetime
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parent))
from utils.quota_tracker import check_quota, consume_quota
from utils.youtube_auth import get_data_api_service

TMP_DIR = Path.home() / ".claude" / ".tmp"


def parse_channel_input(raw):
    """Extract channel ID or handle from various input formats."""
    raw = raw.strip()

    # Direct channel ID
    if raw.startswith("UC") and len(raw) == 24:
        return {"type": "id", "value": raw}

    # Handle format
    if raw.startswith("@"):
        return {"type": "handle", "value": raw}

    # URL formats
    url_patterns = [
        (r"youtube\.com/channel/(UC[\w-]{22})", "id"),
        (r"youtube\.com/@([\w.-]+)", "handle"),
        (r"youtube\.com/c/([\w.-]+)", "custom_url"),
        (r"youtube\.com/user/([\w.-]+)", "username"),
    ]

    for pattern, ptype in url_patterns:
        match = re.search(pattern, raw)
        if match:
            val = match.group(1)
            if ptype == "handle":
                val = f"@{val}"
            return {"type": ptype, "value": val}

    # Assume it's a handle without @
    if not raw.startswith("http"):
        return {"type": "handle", "value": f"@{raw}"}

    return {"type": "unknown", "value": raw}


def resolve_channel_id(service, parsed):
    """Resolve various inputs to a channel ID."""
    if parsed["type"] == "id":
        return parsed["value"]

    if parsed["type"] == "handle":
        response = service.channels().list(
            part="id", forHandle=parsed["value"].lstrip("@")
        ).execute()
        consume_quota("channels.list")
        items = response.get("items", [])
        if items:
            return items[0]["id"]

    if parsed["type"] in ("custom_url", "username"):
        response = service.search().list(
            part="id", q=parsed["value"], type="channel", maxResults=1
        ).execute()
        consume_quota("search.list")
        items = response.get("items", [])
        if items:
            return items[0]["id"]["channelId"]

    return None


def fetch_channel_info(service, channel_id):
    """Fetch channel snippet, statistics, and branding."""
    response = service.channels().list(
        part="snippet,statistics,contentDetails,brandingSettings",
        id=channel_id,
    ).execute()
    consume_quota("channels.list")

    items = response.get("items", [])
    if not items:
        return None

    ch = items[0]
    snippet = ch.get("snippet", {})
    stats = ch.get("statistics", {})
    content = ch.get("contentDetails", {})
    branding = ch.get("brandingSettings", {}).get("channel", {})

    return {
        "channel_id": channel_id,
        "title": snippet.get("title"),
        "description": snippet.get("description", "")[:500],
        "custom_url": snippet.get("customUrl"),
        "published_at": snippet.get("publishedAt"),
        "country": snippet.get("country"),
        "subscriber_count": int(stats.get("subscriberCount", 0)),
        "total_views": int(stats.get("viewCount", 0)),
        "video_count": int(stats.get("videoCount", 0)),
        "uploads_playlist": content.get("relatedPlaylists", {}).get("uploads"),
        "keywords": branding.get("keywords", ""),
    }


def fetch_recent_videos(service, uploads_playlist_id, max_results=10):
    """Fetch recent videos via uploads playlist (cheaper than search.list)."""
    # Step 1: Get video IDs from playlist
    video_ids = []
    next_page = None
    remaining = max_results

    while remaining > 0:
        page_size = min(remaining, 50)
        response = service.playlistItems().list(
            part="contentDetails",
            playlistId=uploads_playlist_id,
            maxResults=page_size,
            pageToken=next_page,
        ).execute()
        consume_quota("playlistItems.list")

        for item in response.get("items", []):
            video_ids.append(item["contentDetails"]["videoId"])
            remaining -= 1
            if remaining <= 0:
                break

        next_page = response.get("nextPageToken")
        if not next_page:
            break

    if not video_ids:
        return []

    # Step 2: Get full video details in batches of 50
    videos = []
    for i in range(0, len(video_ids), 50):
        batch = video_ids[i:i + 50]
        response = service.videos().list(
            part="snippet,statistics,contentDetails",
            id=",".join(batch),
        ).execute()
        consume_quota("videos.list", len(batch))

        for v in response.get("items", []):
            snippet = v.get("snippet", {})
            stats = v.get("statistics", {})
            content = v.get("contentDetails", {})

            videos.append({
                "video_id": v["id"],
                "title": snippet.get("title"),
                "published_at": snippet.get("publishedAt"),
                "description": snippet.get("description", "")[:200],
                "duration": content.get("duration"),
                "views": int(stats.get("viewCount", 0)),
                "likes": int(stats.get("likeCount", 0)),
                "comments": int(stats.get("commentCount", 0)),
                "thumbnail": snippet.get("thumbnails", {}).get("high", {}).get("url"),
            })

    return videos


def main():
    parser = argparse.ArgumentParser(description="Fetch YouTube channel data")
    parser.add_argument("channel", help="Channel ID, @handle, or URL")
    parser.add_argument("--videos", type=int, default=10,
                        help="Number of recent videos to fetch (default: 10)")
    parser.add_argument("--no-cache", action="store_true",
                        help="Skip cache and fetch fresh data")
    args = parser.parse_args()

    # Check quota before starting
    estimated_cost = 2 + (args.videos // 50 + 1) * 2  # channels + playlist + videos
    quota_check = check_quota("videos.list", estimated_cost)
    if not quota_check.get("can_execute", True):
        print(json.dumps({"error": quota_check["error"]}), file=sys.stderr)
        sys.exit(1)

    # Check cache
    parsed = parse_channel_input(args.channel)
    cache_key = parsed["value"].replace("/", "_").replace("@", "")
    today = datetime.now().strftime("%Y-%m-%d")
    cache_path = TMP_DIR / f"channel_{cache_key}_{today}.json"

    if cache_path.exists() and not args.no_cache:
        with open(cache_path) as f:
            cached = json.load(f)
        cached["_cached"] = True
        print(json.dumps(cached, indent=2))
        return

    # Build service
    service, error = get_data_api_service()
    if error:
        print(json.dumps(error), file=sys.stderr)
        sys.exit(1)

    # Resolve channel ID
    channel_id = resolve_channel_id(service, parsed)
    if not channel_id:
        print(json.dumps({"error": f"Could not resolve channel: {args.channel}"}),
              file=sys.stderr)
        sys.exit(1)

    # Fetch data
    channel_info = fetch_channel_info(service, channel_id)
    if not channel_info:
        print(json.dumps({"error": f"Channel not found: {channel_id}"}),
              file=sys.stderr)
        sys.exit(1)

    videos = []
    if channel_info.get("uploads_playlist"):
        videos = fetch_recent_videos(
            service, channel_info["uploads_playlist"], args.videos
        )

    result = {
        "channel": channel_info,
        "videos": videos,
        "fetched_at": datetime.now().isoformat(),
        "quota_consumed": estimated_cost,
    }

    # Cache result
    TMP_DIR.mkdir(parents=True, exist_ok=True)
    with open(cache_path, "w") as f:
        json.dump(result, f, indent=2)

    print(json.dumps(result, indent=2))


if __name__ == "__main__":
    main()

"""
Fetch video transcript/captions via multiple fallback methods.

Cascade:
  1. YouTube Data API v3 captions (requires OAuth for own videos)
  2. yt-dlp auto-subtitle extraction (if installed)
  3. Graceful failure with instructions

Input: video ID or URL
Output: JSON with transcript text, timestamps, language

Usage:
    python execution/fetch_transcript.py dQw4w9WgXcQ
    python execution/fetch_transcript.py "https://youtube.com/watch?v=dQw4w9WgXcQ"
    python execution/fetch_transcript.py VIDEO_ID --format text
    python execution/fetch_transcript.py VIDEO_ID --format segments
"""

import argparse
import json
import re
import shutil
import subprocess
import sys
import tempfile
from datetime import datetime
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parent))
from utils.quota_tracker import consume_quota

TMP_DIR = Path.home() / ".claude" / ".tmp"


def parse_video_id(raw):
    """Extract video ID from URL or direct ID input."""
    raw = raw.strip()

    # Direct video ID (11 characters)
    if re.match(r"^[\w-]{11}$", raw):
        return raw

    # URL patterns
    patterns = [
        r"(?:youtube\.com/watch\?v=|youtu\.be/|youtube\.com/shorts/)([\w-]{11})",
    ]
    for pattern in patterns:
        match = re.search(pattern, raw)
        if match:
            return match.group(1)

    return raw  # Return as-is, let the API validate


def fetch_via_ytdlp(video_id, lang="en"):
    """Fetch transcript using yt-dlp (fallback method)."""
    ytdlp = shutil.which("yt-dlp")
    if not ytdlp:
        return None, "yt-dlp not installed"

    url = f"https://www.youtube.com/watch?v={video_id}"

    with tempfile.TemporaryDirectory() as tmpdir:
        output_template = str(Path(tmpdir) / "transcript")

        cmd = [
            ytdlp,
            "--skip-download",
            "--write-auto-sub",
            "--sub-lang", lang,
            "--sub-format", "vtt",
            "--output", output_template,
            url,
        ]

        try:
            result = subprocess.run(
                cmd, capture_output=True, text=True, timeout=30
            )
        except subprocess.TimeoutExpired:
            return None, "yt-dlp timed out after 30 seconds"

        # Find the subtitle file
        vtt_files = list(Path(tmpdir).glob("*.vtt"))
        if not vtt_files:
            # Try SRT format as fallback
            cmd[cmd.index("vtt")] = "srt"
            try:
                subprocess.run(cmd, capture_output=True, text=True, timeout=30)
            except subprocess.TimeoutExpired:
                return None, "yt-dlp timed out"

            srt_files = list(Path(tmpdir).glob("*.srt"))
            if not srt_files:
                return None, f"No subtitles found. yt-dlp stderr: {result.stderr[:200]}"

            return parse_srt(srt_files[0].read_text()), None

        return parse_vtt(vtt_files[0].read_text()), None


def parse_vtt(content):
    """Parse WebVTT subtitle content into segments."""
    segments = []
    lines = content.strip().split("\n")
    current_text = []
    current_start = None

    for line in lines:
        line = line.strip()
        # Skip header and empty lines
        if line.startswith("WEBVTT") or line.startswith("Kind:") or \
           line.startswith("Language:") or not line:
            if current_text and current_start:
                text = " ".join(current_text).strip()
                # Remove VTT tags
                text = re.sub(r"<[^>]+>", "", text)
                if text:
                    segments.append({"start": current_start, "text": text})
                current_text = []
            continue

        # Timestamp line
        time_match = re.match(
            r"(\d{2}:\d{2}:\d{2}\.\d{3})\s*-->\s*(\d{2}:\d{2}:\d{2}\.\d{3})", line
        )
        if time_match:
            if current_text and current_start:
                text = " ".join(current_text).strip()
                text = re.sub(r"<[^>]+>", "", text)
                if text:
                    segments.append({"start": current_start, "text": text})
                current_text = []
            current_start = time_match.group(1)
            continue

        # Skip numeric cue identifiers
        if re.match(r"^\d+$", line):
            continue

        current_text.append(line)

    # Last segment
    if current_text and current_start:
        text = " ".join(current_text).strip()
        text = re.sub(r"<[^>]+>", "", text)
        if text:
            segments.append({"start": current_start, "text": text})

    # Deduplicate consecutive identical segments
    deduped = []
    for seg in segments:
        if not deduped or deduped[-1]["text"] != seg["text"]:
            deduped.append(seg)

    return deduped


def parse_srt(content):
    """Parse SRT subtitle content into segments."""
    segments = []
    blocks = re.split(r"\n\n+", content.strip())

    for block in blocks:
        lines = block.strip().split("\n")
        if len(lines) < 3:
            continue

        time_match = re.match(
            r"(\d{2}:\d{2}:\d{2},\d{3})\s*-->\s*(\d{2}:\d{2}:\d{2},\d{3})",
            lines[1],
        )
        if time_match:
            start = time_match.group(1).replace(",", ".")
            text = " ".join(lines[2:]).strip()
            text = re.sub(r"<[^>]+>", "", text)
            if text:
                segments.append({"start": start, "text": text})

    return segments


def segments_to_text(segments):
    """Convert segments to plain text."""
    return " ".join(seg["text"] for seg in segments)


def main():
    parser = argparse.ArgumentParser(description="Fetch YouTube video transcript")
    parser.add_argument("video", help="Video ID or URL")
    parser.add_argument("--lang", default="en", help="Language code (default: en)")
    parser.add_argument("--format", choices=["text", "segments", "both"],
                        default="both", help="Output format (default: both)")

    args = parser.parse_args()

    video_id = parse_video_id(args.video)

    # Check cache
    TMP_DIR.mkdir(parents=True, exist_ok=True)
    cache_path = TMP_DIR / f"transcript_{video_id}_{args.lang}.json"

    if cache_path.exists():
        with open(cache_path) as f:
            cached = json.load(f)
        cached["_cached"] = True
        print(json.dumps(cached, indent=2))
        return

    # Try yt-dlp (most reliable for public videos, no API quota cost)
    segments, error = fetch_via_ytdlp(video_id, args.lang)

    if segments:
        result = {
            "video_id": video_id,
            "language": args.lang,
            "method": "yt-dlp",
            "segment_count": len(segments),
            "fetched_at": datetime.now().isoformat(),
        }

        if args.format in ("segments", "both"):
            result["segments"] = segments
        if args.format in ("text", "both"):
            result["text"] = segments_to_text(segments)

        # Cache
        with open(cache_path, "w") as f:
            json.dump(result, f, indent=2)

        print(json.dumps(result, indent=2))
        return

    # All methods failed
    print(json.dumps({
        "error": "Could not fetch transcript",
        "video_id": video_id,
        "attempts": [
            {"method": "yt-dlp", "error": error or "not attempted"},
        ],
        "suggestions": [
            "Install yt-dlp: pip install yt-dlp",
            "Check if the video has captions enabled",
            "Try a different language with --lang",
            "For private videos, ensure OAuth is configured",
        ],
    }, indent=2), file=sys.stderr)
    sys.exit(1)


if __name__ == "__main__":
    main()

"""
Fetch private video analytics from YouTube Analytics API.

Requires OAuth 2.0 authentication. Can ONLY access analytics for channels
you own or manage. Competitor analytics are NOT accessible via any official API.

Input: video ID(s), optional date range and metric list
Output: JSON with views, watch time, AVD, CTR, impressions, subs gained, etc.

Usage:
    python execution/fetch_video_analytics.py VIDEO_ID
    python execution/fetch_video_analytics.py VIDEO_ID --days 90
    python execution/fetch_video_analytics.py VIDEO_ID1 VIDEO_ID2 --metrics views,estimatedMinutesWatched
"""

import argparse
import json
import sys
from datetime import datetime, timedelta
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parent))
from utils.youtube_auth import get_oauth_service

DEFAULT_METRICS = [
    "views",
    "estimatedMinutesWatched",
    "averageViewDuration",
    "impressions",
    "impressionClickThroughRate",
    "subscribersGained",
    "subscribersLost",
    "likes",
    "shares",
    "comments",
]

TRAFFIC_SOURCE_METRICS = [
    "views",
    "estimatedMinutesWatched",
]


def fetch_video_metrics(service, channel_id, video_ids, start_date, end_date, metrics):
    """Fetch standard metrics for specified videos."""
    filters = f"video=={','.join(video_ids)}"

    try:
        response = service.reports().query(
            ids=f"channel=={channel_id}",
            startDate=start_date,
            endDate=end_date,
            metrics=",".join(metrics),
            filters=filters,
            dimensions="video",
            maxResults=200,
        ).execute()
    except Exception as e:
        return {"error": str(e)}

    rows = response.get("rows", [])
    headers = [h["name"] for h in response.get("columnHeaders", [])]
    results = []

    for row in rows:
        entry = dict(zip(headers, row))
        results.append(entry)

    return results


def fetch_traffic_sources(service, channel_id, video_ids, start_date, end_date):
    """Fetch traffic source breakdown for videos."""
    filters = f"video=={','.join(video_ids)}"

    try:
        response = service.reports().query(
            ids=f"channel=={channel_id}",
            startDate=start_date,
            endDate=end_date,
            metrics=",".join(TRAFFIC_SOURCE_METRICS),
            filters=filters,
            dimensions="insightTrafficSourceType",
            maxResults=200,
        ).execute()
    except Exception as e:
        return {"error": str(e)}

    rows = response.get("rows", [])
    headers = [h["name"] for h in response.get("columnHeaders", [])]
    return [dict(zip(headers, row)) for row in rows]


def fetch_daily_metrics(service, channel_id, video_ids, start_date, end_date):
    """Fetch daily metric breakdown for trend analysis."""
    filters = f"video=={','.join(video_ids)}"
    daily_metrics = ["views", "estimatedMinutesWatched", "likes", "subscribersGained"]

    try:
        response = service.reports().query(
            ids=f"channel=={channel_id}",
            startDate=start_date,
            endDate=end_date,
            metrics=",".join(daily_metrics),
            filters=filters,
            dimensions="day",
            sort="day",
            maxResults=200,
        ).execute()
    except Exception as e:
        return {"error": str(e)}

    rows = response.get("rows", [])
    headers = [h["name"] for h in response.get("columnHeaders", [])]
    return [dict(zip(headers, row)) for row in rows]


def get_channel_id(oauth_creds):
    """Get the authenticated user's channel ID."""
    try:
        from googleapiclient.discovery import build
        yt_service = build("youtube", "v3", credentials=oauth_creds)
        response = yt_service.channels().list(part="id", mine=True).execute()
        items = response.get("items", [])
        if items:
            return items[0]["id"]
    except Exception:
        pass
    return None


def main():
    parser = argparse.ArgumentParser(description="Fetch YouTube video analytics")
    parser.add_argument("video_ids", nargs="+", help="One or more video IDs")
    parser.add_argument("--days", type=int, default=28,
                        help="Number of days to look back (default: 28)")
    parser.add_argument("--metrics", type=str, default=None,
                        help="Comma-separated metrics (default: standard set)")
    parser.add_argument("--traffic-sources", action="store_true",
                        help="Include traffic source breakdown")
    parser.add_argument("--daily", action="store_true",
                        help="Include daily metric breakdown")

    args = parser.parse_args()

    end_date = datetime.now().strftime("%Y-%m-%d")
    start_date = (datetime.now() - timedelta(days=args.days)).strftime("%Y-%m-%d")

    metrics = args.metrics.split(",") if args.metrics else DEFAULT_METRICS

    # Build OAuth service
    service, error = get_oauth_service()
    if error:
        print(json.dumps(error), file=sys.stderr)
        sys.exit(1)

    # We need the YouTube Data API service to get channel ID
    try:
        from google.oauth2.credentials import Credentials
        from googleapiclient.discovery import build

        token_path = Path.home() / ".claude" / ".tmp" / "youtube_oauth_token.json"
        if token_path.exists():
            creds = Credentials.from_authorized_user_file(str(token_path))
            yt = build("youtube", "v3", credentials=creds)
            ch_resp = yt.channels().list(part="id", mine=True).execute()
            channel_id = ch_resp["items"][0]["id"]
        else:
            print(json.dumps({"error": "OAuth token not found. Run auth first."}),
                  file=sys.stderr)
            sys.exit(1)
    except Exception as e:
        print(json.dumps({"error": f"Failed to get channel ID: {e}"}),
              file=sys.stderr)
        sys.exit(1)

    # Fetch metrics
    result = {
        "video_ids": args.video_ids,
        "date_range": {"start": start_date, "end": end_date},
        "metrics": {},
        "fetched_at": datetime.now().isoformat(),
    }

    video_metrics = fetch_video_metrics(
        service, channel_id, args.video_ids, start_date, end_date, metrics
    )
    result["metrics"]["standard"] = video_metrics

    if args.traffic_sources:
        traffic = fetch_traffic_sources(
            service, channel_id, args.video_ids, start_date, end_date
        )
        result["metrics"]["traffic_sources"] = traffic

    if args.daily:
        daily = fetch_daily_metrics(
            service, channel_id, args.video_ids, start_date, end_date
        )
        result["metrics"]["daily"] = daily

    print(json.dumps(result, indent=2))


if __name__ == "__main__":
    main()

"""
Search YouTube for videos by topic or from a competitor channel.

Uses YouTube Data API v3 search.list (100 units per call — use sparingly).
For competitor channel videos, prefer using the uploads playlist path via
fetch_channel_data.py which costs only ~16 units instead of 100.

Note: Private metrics (retention, CTR, revenue) are NOT accessible for
competitor channels via any official API. Only public data is returned.

Input: search query or channel ID filter
Output: JSON array of videos with public metrics

Usage:
    python execution/search_competitor_videos.py "python tutorial 2025"
    python execution/search_competitor_videos.py --channel-id UCxxxx --max-results 20
    python execution/search_competitor_videos.py "cooking tips" --order viewCount
"""

import argparse
import json
import sys
from datetime import datetime, timedelta
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parent))
from utils.quota_tracker import check_quota, consume_quota
from utils.youtube_auth import get_data_api_service

TMP_DIR = Path.home() / ".claude" / ".tmp"


def search_videos(service, query, channel_id=None, max_results=10,
                  order="relevance", published_after=None):
    """Search for videos with optional channel filter."""
    search_params = {
        "part": "id,snippet",
        "q": query,
        "type": "video",
        "maxResults": min(max_results, 50),
        "order": order,
    }

    if channel_id:
        search_params["channelId"] = channel_id

    if published_after:
        search_params["publishedAfter"] = published_after

    response = service.search().list(**search_params).execute()
    consume_quota("search.list")

    video_ids = []
    snippets = {}

    for item in response.get("items", []):
        vid = item["id"]["videoId"]
        video_ids.append(vid)
        snippets[vid] = item["snippet"]

    if not video_ids:
        return []

    # Fetch full statistics for found videos (1 unit per batch of 50)
    stats_response = service.videos().list(
        part="statistics,contentDetails",
        id=",".join(video_ids),
    ).execute()
    consume_quota("videos.list", len(video_ids))

    stats_map = {}
    for v in stats_response.get("items", []):
        stats_map[v["id"]] = {
            "statistics": v.get("statistics", {}),
            "content_details": v.get("contentDetails", {}),
        }

    # Combine data
    results = []
    for vid in video_ids:
        snippet = snippets.get(vid, {})
        data = stats_map.get(vid, {})
        stats = data.get("statistics", {})
        content = data.get("content_details", {})

        views = int(stats.get("viewCount", 0))
        likes = int(stats.get("likeCount", 0))
        comments = int(stats.get("commentCount", 0))

        engagement_rate = 0
        if views > 0:
            engagement_rate = round((likes + comments) / views * 100, 2)

        results.append({
            "video_id": vid,
            "title": snippet.get("title"),
            "channel_title": snippet.get("channelTitle"),
            "channel_id": snippet.get("channelId"),
            "published_at": snippet.get("publishedAt"),
            "description": snippet.get("description", "")[:200],
            "duration": content.get("duration"),
            "views": views,
            "likes": likes,
            "comments": comments,
            "engagement_rate_pct": engagement_rate,
            "thumbnail": snippet.get("thumbnails", {}).get("high", {}).get("url"),
        })

    return results


def flag_outliers(videos, multiplier=3.0):
    """Flag videos that significantly outperform the channel average."""
    if not videos:
        return videos

    # Group by channel
    channels = {}
    for v in videos:
        ch = v.get("channel_id", "unknown")
        channels.setdefault(ch, []).append(v)

    for ch_id, ch_videos in channels.items():
        if len(ch_videos) < 3:
            continue

        avg_views = sum(v["views"] for v in ch_videos) / len(ch_videos)

        for v in ch_videos:
            if avg_views > 0:
                ratio = v["views"] / avg_views
                v["vs_channel_avg"] = round(ratio, 1)
                v["is_outlier"] = ratio >= multiplier
            else:
                v["vs_channel_avg"] = 0
                v["is_outlier"] = False

    return videos


def main():
    parser = argparse.ArgumentParser(description="Search YouTube competitor videos")
    parser.add_argument("query", nargs="?", default="",
                        help="Search query")
    parser.add_argument("--channel-id", type=str,
                        help="Filter to specific channel")
    parser.add_argument("--max-results", type=int, default=10,
                        help="Max results (default: 10, max: 50)")
    parser.add_argument("--order", choices=["relevance", "viewCount", "date", "rating"],
                        default="relevance", help="Sort order")
    parser.add_argument("--days", type=int, default=None,
                        help="Only videos from last N days")
    parser.add_argument("--flag-outliers", action="store_true",
                        help="Flag videos that outperform channel average by 3x+")

    args = parser.parse_args()

    if not args.query and not args.channel_id:
        parser.error("Provide a search query or --channel-id")

    # Quota check — search.list costs 100 units
    quota_status = check_quota("search.list")
    if not quota_status.get("can_execute", True):
        print(json.dumps({
            "error": quota_status["error"],
            "suggestion": "Use fetch_channel_data.py instead (~16 units) "
                          "if you just need a channel's recent videos.",
        }), file=sys.stderr)
        sys.exit(1)

    remaining = quota_status.get("remaining", 10000)
    if remaining < 200:
        print(json.dumps({
            "warning": f"Only {remaining} quota units remaining. "
                       f"This search costs 100+ units. Proceed with caution.",
        }), file=sys.stderr)

    # Build service
    service, error = get_data_api_service()
    if error:
        print(json.dumps(error), file=sys.stderr)
        sys.exit(1)

    # Date filter
    published_after = None
    if args.days:
        dt = datetime.now() - timedelta(days=args.days)
        published_after = dt.strftime("%Y-%m-%dT00:00:00Z")

    # Search
    videos = search_videos(
        service,
        query=args.query,
        channel_id=args.channel_id,
        max_results=args.max_results,
        order=args.order,
        published_after=published_after,
    )

    if args.flag_outliers:
        videos = flag_outliers(videos)

    # Sort by views descending
    videos.sort(key=lambda v: v["views"], reverse=True)

    result = {
        "query": args.query,
        "channel_filter": args.channel_id,
        "result_count": len(videos),
        "videos": videos,
        "fetched_at": datetime.now().isoformat(),
        "note": "Only public metrics shown. Retention, CTR, and revenue "
                "data are private and not accessible for competitor channels.",
    }

    print(json.dumps(result, indent=2))


if __name__ == "__main__":
    main()

"""
YouTube Data API v3 quota tracker.

Tracks unit consumption per operation and warns before quota exhaustion.
Daily quota: 10,000 units, resets at midnight Pacific Time.

Quota costs:
    search.list    = 100 units
    videos.list    = 1 unit
    channels.list  = 1 unit
    playlistItems.list = 1 unit
    commentThreads.list = 1 unit
    videos.insert  = 100 units

Usage:
    python execution/utils/quota_tracker.py --check
    python execution/utils/quota_tracker.py --consume search.list
    python execution/utils/quota_tracker.py --consume videos.list --count 10
    python execution/utils/quota_tracker.py --reset
"""

import argparse
import json
import sys
from datetime import datetime, timezone, timedelta
from pathlib import Path

TMP_DIR = Path.home() / ".claude" / ".tmp"
DAILY_QUOTA = 10000
WARN_THRESHOLD = 0.80  # Warn at 80% consumed

OPERATION_COSTS = {
    "search.list": 100,
    "videos.list": 1,
    "channels.list": 1,
    "playlistItems.list": 1,
    "commentThreads.list": 1,
    "captions.list": 1,
    "playlists.list": 1,
    "videos.insert": 100,
}

PACIFIC_OFFSET = timedelta(hours=-8)  # PST (approximate; doesn't handle DST)


def _pacific_date():
    """Return current date in Pacific Time."""
    utc_now = datetime.now(timezone.utc)
    pacific_now = utc_now + PACIFIC_OFFSET
    return pacific_now.strftime("%Y-%m-%d")


def _quota_file():
    """Return path to today's quota file."""
    TMP_DIR.mkdir(parents=True, exist_ok=True)
    return TMP_DIR / f"youtube_quota_{_pacific_date()}.json"


def _load_quota():
    """Load today's quota state."""
    path = _quota_file()
    if path.exists():
        with open(path) as f:
            return json.load(f)
    return {"date": _pacific_date(), "consumed": 0, "operations": {}}


def _save_quota(data):
    """Save quota state."""
    path = _quota_file()
    with open(path, "w") as f:
        json.dump(data, f, indent=2)


def get_remaining():
    """Return remaining quota units for today."""
    data = _load_quota()
    return DAILY_QUOTA - data["consumed"]


def check_quota(operation=None, count=1):
    """Check if an operation can be performed within quota.

    Returns dict with status, remaining units, and warning if applicable.
    """
    data = _load_quota()
    remaining = DAILY_QUOTA - data["consumed"]
    used_pct = data["consumed"] / DAILY_QUOTA

    result = {
        "date": data["date"],
        "consumed": data["consumed"],
        "remaining": remaining,
        "daily_quota": DAILY_QUOTA,
        "used_percent": round(used_pct * 100, 1),
    }

    if used_pct >= WARN_THRESHOLD:
        result["warning"] = (
            f"Quota {result['used_percent']}% consumed. "
            f"Only {remaining} units remaining. Use sparingly."
        )

    if operation:
        cost = OPERATION_COSTS.get(operation, 0)
        total_cost = cost * count
        result["operation"] = operation
        result["operation_cost"] = total_cost
        result["can_execute"] = total_cost <= remaining

        if not result["can_execute"]:
            result["error"] = (
                f"Operation {operation} (×{count}) costs {total_cost} units "
                f"but only {remaining} remaining. Defer to tomorrow."
            )

    return result


def consume_quota(operation, count=1):
    """Record quota consumption for an operation.

    Returns dict with updated quota state.
    """
    cost = OPERATION_COSTS.get(operation, 0)
    if cost == 0:
        return {"warning": f"Unknown operation '{operation}'. No quota consumed."}

    total_cost = cost * count
    data = _load_quota()
    remaining = DAILY_QUOTA - data["consumed"]

    if total_cost > remaining:
        return {
            "error": f"Quota exceeded. Need {total_cost} units, only {remaining} available.",
            "remaining": remaining,
            "consumed": data["consumed"],
        }

    data["consumed"] += total_cost
    op_key = operation
    data["operations"][op_key] = data["operations"].get(op_key, 0) + count
    _save_quota(data)

    new_remaining = DAILY_QUOTA - data["consumed"]
    result = {
        "operation": operation,
        "units_consumed": total_cost,
        "remaining": new_remaining,
        "used_percent": round(data["consumed"] / DAILY_QUOTA * 100, 1),
    }

    if data["consumed"] / DAILY_QUOTA >= WARN_THRESHOLD:
        result["warning"] = (
            f"Quota {result['used_percent']}% consumed. "
            f"Only {new_remaining} units remaining."
        )

    return result


def reset_quota():
    """Force reset today's quota (for testing only)."""
    data = {"date": _pacific_date(), "consumed": 0, "operations": {}}
    _save_quota(data)
    return {"status": "reset", "date": data["date"], "remaining": DAILY_QUOTA}


def main():
    parser = argparse.ArgumentParser(description="YouTube API quota tracker")
    parser.add_argument("--check", action="store_true",
                        help="Check current quota status")
    parser.add_argument("--consume", type=str,
                        help="Record quota consumption for an operation")
    parser.add_argument("--count", type=int, default=1,
                        help="Number of operations (default: 1)")
    parser.add_argument("--reset", action="store_true",
                        help="Reset quota counter (testing only)")
    parser.add_argument("--can-afford", type=str,
                        help="Check if operation is affordable")
    args = parser.parse_args()

    if args.reset:
        result = reset_quota()
    elif args.consume:
        result = consume_quota(args.consume, args.count)
    elif args.can_afford:
        result = check_quota(args.can_afford, args.count)
    elif args.check:
        result = check_quota()
    else:
        parser.print_help()
        return

    print(json.dumps(result, indent=2))
    if "error" in result:
        sys.exit(1)


if __name__ == "__main__":
    main()

"""
YouTube API authentication manager.

Handles API key auth for public Data API v3 and OAuth 2.0 for Analytics API.
Input: auth_type ('api_key' | 'oauth'), optional credentials path
Output: authenticated googleapiclient service object OR error dict

Usage:
    python execution/utils/youtube_auth.py --check api_key
    python execution/utils/youtube_auth.py --check oauth
"""

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

TMP_DIR = Path.home() / ".claude" / ".tmp"
TOKEN_PATH = TMP_DIR / "youtube_oauth_token.json"
CLIENT_SECRETS_PATH = Path.home() / ".claude" / "youtube_client_secrets.json"


def get_api_key():
    """Return YouTube Data API v3 key from environment or config file."""
    key = os.environ.get("YOUTUBE_API_KEY")
    if key:
        return key

    config_path = Path.home() / ".claude" / "youtube-credentials.json"
    if config_path.exists():
        with open(config_path) as f:
            data = json.load(f)
            key = data.get("api_key")
            if key:
                return key

    return None


def get_data_api_service(api_key=None):
    """Build and return YouTube Data API v3 service object."""
    try:
        from googleapiclient.discovery import build
    except ImportError:
        return None, {
            "error": "google-api-python-client not installed",
            "fix": "pip install google-api-python-client google-auth-oauthlib",
        }

    if api_key is None:
        api_key = get_api_key()

    if not api_key:
        return None, {
            "error": "YouTube API key not found",
            "fix": (
                "Set YOUTUBE_API_KEY environment variable or add to "
                "~/.claude/youtube-credentials.json as {\"api_key\": \"YOUR_KEY\"}. "
                "Get a key at https://console.cloud.google.com/apis/credentials"
            ),
        }

    try:
        service = build("youtube", "v3", developerKey=api_key)
        return service, None
    except Exception as e:
        return None, {"error": f"Failed to build YouTube service: {e}"}


def get_oauth_service(scopes=None):
    """Build YouTube Analytics API service with OAuth 2.0."""
    try:
        from google.auth.transport.requests import Request
        from google.oauth2.credentials import Credentials
        from google_auth_oauthlib.flow import InstalledAppFlow
        from googleapiclient.discovery import build
    except ImportError:
        return None, {
            "error": "OAuth dependencies not installed",
            "fix": "pip install google-api-python-client google-auth-oauthlib",
        }

    if scopes is None:
        scopes = [
            "https://www.googleapis.com/auth/yt-analytics.readonly",
            "https://www.googleapis.com/auth/youtube.readonly",
        ]

    TMP_DIR.mkdir(parents=True, exist_ok=True)
    creds = None

    if TOKEN_PATH.exists():
        try:
            creds = Credentials.from_authorized_user_file(str(TOKEN_PATH), scopes)
        except Exception:
            creds = None

    if creds and creds.expired and creds.refresh_token:
        try:
            creds.refresh(Request())
            with open(TOKEN_PATH, "w") as f:
                f.write(creds.to_json())
        except Exception:
            creds = None

    if not creds or not creds.valid:
        if not CLIENT_SECRETS_PATH.exists():
            return None, {
                "error": "OAuth client secrets not found",
                "fix": (
                    f"Download OAuth 2.0 client secrets from Google Cloud Console "
                    f"and save to {CLIENT_SECRETS_PATH}. "
                    f"Guide: https://developers.google.com/youtube/analytics/registering_an_application"
                ),
            }

        try:
            flow = InstalledAppFlow.from_client_secrets_file(
                str(CLIENT_SECRETS_PATH), scopes
            )
            creds = flow.run_local_server(port=0)
            with open(TOKEN_PATH, "w") as f:
                f.write(creds.to_json())
        except Exception as e:
            return None, {"error": f"OAuth flow failed: {e}"}

    try:
        service = build("youtubeAnalytics", "v2", credentials=creds)
        return service, None
    except Exception as e:
        return None, {"error": f"Failed to build Analytics service: {e}"}


def check_auth(auth_type):
    """Check if authentication is configured and return status."""
    if auth_type == "api_key":
        key = get_api_key()
        if key:
            masked = key[:4] + "..." + key[-4:]
            return {"status": "ok", "type": "api_key", "key": masked}
        return {"status": "missing", "type": "api_key",
                "fix": "Set YOUTUBE_API_KEY env var or add to ~/.claude/youtube-credentials.json"}

    elif auth_type == "oauth":
        if TOKEN_PATH.exists():
            return {"status": "ok", "type": "oauth", "token_path": str(TOKEN_PATH)}
        if CLIENT_SECRETS_PATH.exists():
            return {"status": "needs_auth", "type": "oauth",
                    "message": "Client secrets found but no token yet. Run OAuth flow."}
        return {"status": "missing", "type": "oauth",
                "fix": f"Download OAuth client secrets to {CLIENT_SECRETS_PATH}"}

    return {"status": "error", "message": f"Unknown auth type: {auth_type}"}


def main():
    parser = argparse.ArgumentParser(description="YouTube API auth manager")
    parser.add_argument("--check", choices=["api_key", "oauth"],
                        help="Check auth status")
    args = parser.parse_args()

    if args.check:
        result = check_auth(args.check)
        print(json.dumps(result, indent=2))
        sys.exit(0 if result["status"] == "ok" else 1)
    else:
        parser.print_help()


if __name__ == "__main__":
    main()