#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
Monitor de transmisiones en vivo de YouTube.
Solo guarda transmisiones realmente activas (no replays).
Optimizado para bajo consumo de cuota.
"""

import os
import logging
import mysql.connector
from googleapiclient.discovery import build
import requests

# ========== CONFIGURACIÓN ==========
API_KEY = "AIzaSyBDh-t8YZjWwqA2qiqviwKtJ1K2C1vG0ow"  # 👈 reemplaza por tu clave válida

DB_CONFIG = {
    "host": "165.22.170.125",
    "user": "jotasantelices_admin",
    "password": "Jot@1972",
    "database": "jotasantelices_mediabytes"
}

CHANNELS = {
    "megaoficial": "UCEpId-jtRABuZyX6D2z6FZQ",
    "Chilevision": "UC8EdTmyUaFIfZvVttJ9lgIA",
    "El13Chile": "UCd4D3LfXC_9MY2zSv_3gMgw",
    "T13_cl": "UCsRnhjcUCR78Q3Ud6OXCTNg"
}

THUMB_DIR = "thumbnails"
os.makedirs(THUMB_DIR, exist_ok=True)

# ========== LOGGING ==========
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(message)s",
    handlers=[
        logging.FileHandler("youtube_monitor.log"),
        logging.StreamHandler()
    ]
)

# ========== FUNCIONES ==========

def connect_db():
    return mysql.connector.connect(**DB_CONFIG)


def save_to_db(registros):
    """Guarda o actualiza transmisiones en MySQL."""
    conn = connect_db()
    cursor = conn.cursor()

    sql = """
        INSERT INTO youtube_live (
            video_id, title, concurrent_viewers, view_count,
            channel_url_or_handle, channel_id, video_url, thumbnail_path, timestamp_utc
        )
        VALUES (%s,%s,%s,%s,%s,%s,%s,%s,UTC_TIMESTAMP())
        ON DUPLICATE KEY UPDATE
            concurrent_viewers = VALUES(concurrent_viewers),
            view_count = VALUES(view_count),
            title = VALUES(title),
            thumbnail_path = VALUES(thumbnail_path),
            timestamp_utc = UTC_TIMESTAMP();
    """

    cursor.executemany(sql, registros)
    conn.commit()
    cursor.close()
    conn.close()


def download_thumbnail(video_id, url):
    """Descarga la miniatura solo si no existe."""
    thumb_path = os.path.join(THUMB_DIR, f"{video_id}.jpg")
    if not os.path.exists(thumb_path):
        try:
            r = requests.get(url, timeout=10)
            if r.status_code == 200:
                with open(thumb_path, "wb") as f:
                    f.write(r.content)
                logging.info(f"Miniatura guardada: {thumb_path}")
        except Exception as e:
            logging.warning(f"No se pudo descargar miniatura: {e}")
    return thumb_path


def monitor_youtube():
    youtube = build("youtube", "v3", developerKey=API_KEY)
    registros = []
    seen_ids = set()

    for handle, channel_id in CHANNELS.items():
        try:
            logging.info(f"Buscando transmisiones en vivo de: {handle}")

            # Búsqueda simple por canal (consume poco)
            search = youtube.search().list(
                part="id,snippet",
                channelId=channel_id,
                eventType="live",
                type="video",
                maxResults=5
            ).execute()

            items = search.get("items", [])
            if not items:
                logging.info(f"No hay transmisiones activas para {handle}")
                continue

            for item in items:
                video_id = item["id"]["videoId"]
                if video_id in seen_ids:
                    continue
                seen_ids.add(video_id)

                title = item["snippet"]["title"]
                thumb_url = item["snippet"]["thumbnails"]["high"]["url"]
                video_url = f"https://www.youtube.com/watch?v={video_id}"

                details = youtube.videos().list(
                    part="liveStreamingDetails,statistics,snippet,status",
                    id=video_id
                ).execute()

                if not details["items"]:
                    continue

                data = details["items"][0]
                live = data.get("liveStreamingDetails", {})
                stats = data.get("statistics", {})
                snippet = data.get("snippet", {})
                status = data.get("status", {})

                # 🚫 Filtros para excluir falsos positivos
                if "actualEndTime" in live:
                    logging.info(f"⏹️ {title} ya finalizó — se omite.")
                    continue

                if snippet.get("liveBroadcastContent") != "live":
                    logging.info(f"⏹️ {title} no está activo (estado: {snippet.get('liveBroadcastContent')})")
                    continue

                concurrent = int(live.get("concurrentViewers", 0))
                if concurrent == 0:
                    logging.info(f"⏹️ {title} sin viewers activos — se omite.")
                    continue

                views = int(stats.get("viewCount", 0))
                thumb_path = download_thumbnail(video_id, thumb_url)

                registros.append((
                    video_id, title, concurrent, views,
                    f"https://www.youtube.com/@{handle}",
                    channel_id, video_url, thumb_path
                ))

                logging.info(f"✅ {handle} → {title} | {concurrent} concurrentes | {views} views")

        except Exception as e:
            logging.error(f"Error procesando {handle}: {e}")

    if registros:
        save_to_db(registros)
        logging.info(f"💾 {len(registros)} transmisiones guardadas o actualizadas.")
    else:
        logging.info("No se guardaron transmisiones activas.")


# ========== EJECUCIÓN ==========
if __name__ == "__main__":
    logging.info("=== Iniciando monitor de transmisiones en vivo ===")
    monitor_youtube()
    logging.info("=== Finalizado ===")