import os
import json
import re
import time
import requests
import argparse
from datetime import datetime
from tqdm import tqdm
from concurrent.futures import ThreadPoolExecutor

# 🔹 CONFIGURATION 🔹
API_TMDB = "ff2a5e4ba27621d899afc6c49a2040e9"  # 🔑 TMDb API Key
HOSTNAME = "https://alldebrid.com/f/"  # 🌍 Base URL
LOCAL_JSON = "magnets_files.json"  # 📂 Fichier contenant les liens extraits
OUTPUT_FILE = "films.json"  # 📂 Fichier de sortie

DEBUG = False  # 🔍 Mode Debug

# 🔹 Charger les données existantes 🔹
def load_json(filename):
    if os.path.exists(filename):
        with open(filename, "r", encoding="utf-8") as f:
            return json.load(f)
    return []

# 🔹 Sauvegarder JSON 🔹
def save_json(filename, data):
    with open(filename, "w", encoding="utf-8") as f:
        json.dump(data, f, indent=4, ensure_ascii=False)

# 🔹 Extraire titre et année 🔹
def clean_title(filename):
    match = re.search(r"(.+?)\s*(\d{4})", filename)
    if match:
        title, year = match.groups()
        title = re.sub(r"\.|_", " ", title).strip()
        return title, int(year)
    return filename, None

# 🔹 Détection de la langue 🔹
def detect_language(filename):
    lang_patterns = {
        "FR": r"\b(FRENCH|FR|TRUEFRENCH|VOF|VFF|VF|VFI|VF2|MULTI)\b",
        "MULTI": r"\bMULTI\b",
        "MUET": r"\bMUET\b",
        "VFQ": r"\bVFQ\b",
        "VO": r"\bVO\b",
        "VOSTFR": r"\b(VOSTFR|VOESPSTFR|VOST|SUBFRENCH)\b"
    }

    for lang, pattern in lang_patterns.items():
        if re.search(pattern, filename, re.IGNORECASE):
            return lang

    return "FR"  # Si aucune langue trouvée

# 🔹 Recherche TMDb 🔹
def search_tmdb(title, year):
    query = title.replace(" ", "+")
    url = f"https://api.themoviedb.org/3/search/movie?api_key={API_TMDB}&query={query}&include_adult=False&language=fr-FR"

    if year:
        url += f"&year={year}"

    response = requests.get(url).json()

    if DEBUG:
        print(f"\n🔍 Recherche TMDb pour : {title} ({year})")
        print(f"📡 URL requête : {url}")
        print(f"🔹 Réponse TMDb : {json.dumps(response, indent=4)}")

    if response["results"]:
        best_match = response["results"][0]
        return best_match["title"], best_match["release_date"][:4], best_match["id"]

    return "N/A", "N/A", "N/A"

# 🔹 Obtenir la date actuelle formatée 🔹
def get_current_datetime():
    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

# 🔹 Générer un nom de fichier avec date 🔹
def generate_no_tmdb_filename():
    date_str = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
    return f"no_tmdb_{date_str}.json"

# 🔹 Traitement des films 🔹
def process_movie(film):
    filename = film["filename"]
    url = film["url"]
    date_added = get_current_datetime()  # Ajoute une date formatée

    title, year = clean_title(filename)
    tmdb_title, tmdb_year, tmdb_id = search_tmdb(title, year)
    language = detect_language(filename)

    quality_match = re.search(r"(720p|1080p|2160p)", filename, re.IGNORECASE)
    quality = quality_match.group(1).upper() if quality_match else "720P"

    movie_entry = {
        "title": tmdb_title if tmdb_title != "N/A" else title,
        "year": tmdb_year if tmdb_year != "N/A" else year,
        "tmdb_id": tmdb_id,
        "quality": quality,
        "language": language,
        "urls": [url],
        "date_added": date_added  # Ajoute la date ici
    }

    return movie_entry

# 🔹 Fonction principale 🔹
def process_movies():
    print("📥 Chargement des films depuis le JSON local...")
    all_movies = load_json(LOCAL_JSON)

    if not all_movies:
        print("❌ Aucun film trouvé dans `magnets_files.json`.")
        return

    existing_movies = load_json(OUTPUT_FILE)
    no_tmdb_filename = generate_no_tmdb_filename()
    no_tmdb_movies = []

    print(f"🆕 {len(all_movies)} fichiers à traiter.")

    updated_movies = {f"{m['title']}_{m['year']}_{m['quality']}": m for m in existing_movies}

    # 🔹 ThreadPool pour accélérer le traitement
    with ThreadPoolExecutor(max_workers=10) as executor:
        results = list(tqdm(executor.map(process_movie, all_movies), total=len(all_movies), desc="🔄 Traitement"))

    for new_movie in results:
        if new_movie["tmdb_id"] == "N/A":
            no_tmdb_movies.append(new_movie)
            continue

        key = f"{new_movie['title']}_{new_movie['year']}_{new_movie['quality']}"
        if key in updated_movies:
            existing_movie = updated_movies[key]
            if new_movie["urls"][0] not in existing_movie["urls"]:
                existing_movie["urls"].append(new_movie["urls"][0])
        else:
            updated_movies[key] = new_movie

    # 🔹 Sauvegarde des fichiers JSON
    save_json(OUTPUT_FILE, list(updated_movies.values()))

    # 🔹 Sauvegarde des films sans TMDb avec date dans le nom
    if no_tmdb_movies:
        save_json(no_tmdb_filename, no_tmdb_movies)
        print(f"⚠️ Films sans TMDb ({len(no_tmdb_movies)} films) enregistrés dans `{no_tmdb_filename}`")

    # 🔹 Suppression de `magnets_files.json` après exécution
    if os.path.exists(LOCAL_JSON):
        os.remove(LOCAL_JSON)
        print(f"🗑️ Fichier `{LOCAL_JSON}` supprimé.")

    print(f"✅ Films mis à jour ({len(updated_movies)} films) dans `{OUTPUT_FILE}`")

# 🔹 Exécuter le script 🔹
if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--debug", action="store_true", help="Affiche les logs détaillés")
    args = parser.parse_args()
    DEBUG = args.debug

    process_movies()