import requests
import json
import time
import os

# 🔹 CONFIGURATION 🔹
API_KEY = "lUCRvOPYXci0DOVAz61u"  # 🔑 Clé API AllDebrid
PROXY = "http://lClXMfmYmiIMtc2:8ww25795ye6RYjO@46.203.211.10:45803"  # 🔹 Proxy
MAGNET_FILE = "magnets.txt"  # 📂 Fichier contenant les magnets
OUTPUT_FILE = "magnets_files.json"  # 📂 Liens sauvegardés

# 🔹 URLs API AllDebrid 🔹
API_MAGNET_UPLOAD = "https://api.alldebrid.com/v4/magnet/upload"
API_MAGNET_STATUS = "https://api.alldebrid.com/v4.1/magnet/status"
API_MAGNET_FILES = "https://api.alldebrid.com/v4/magnet/files"
API_MAGNET_DELETE = "https://api.alldebrid.com/v4/magnet/delete"

# 🔹 Configurer le proxy 🔹
PROXIES = {"http": PROXY, "https": PROXY}
DEBUG = False  # 🔍 Mode Debugging

# 🔹 Extensions vidéo valides 🔹
VIDEO_EXTENSIONS = {".mkv", ".mp4", ".avi"}

# 🔹 Lire le fichier magnets.txt par blocs de 30 🔹
def read_magnets_by_chunks(filename, chunk_size=30):
    with open(filename, "r", encoding="utf-8") as f:
        lines = f.readlines()

    total_magnets = len(lines)
    if not DEBUG:
        print(f"📂 Magnets détectés : {total_magnets}")

    for i in range(0, total_magnets, chunk_size):
        yield lines[i:i + chunk_size], total_magnets - i

# 🔹 Envoyer un batch de magnets à AllDebrid 🔹
def upload_magnet_batch(magnet_links):
    headers = {"Authorization": f"Bearer {API_KEY}"}
    response = requests.post(API_MAGNET_UPLOAD, headers=headers, proxies=PROXIES, data={"magnets[]": magnet_links})
    data = response.json()

    if DEBUG:
        print("\n🔍 **Réponse API Upload :**", json.dumps(data, indent=4))

    uploaded_ids = []
    if data.get("status") == "success":
        for item in data["data"]["magnets"]:
            if "id" in item:
                uploaded_ids.append(item["id"])
            else:
                print(f"⚠️ Magnet ignoré (pas d'ID) : {item}")

    return uploaded_ids

# 🔹 Vérifier le statut des magnets 🔹
def check_magnet_status():
    headers = {"Authorization": f"Bearer {API_KEY}"}
    response = requests.post(API_MAGNET_STATUS, headers=headers, proxies=PROXIES)
    data = response.json()

    if DEBUG:
        print("\n🔍 **Réponse API Statut Magnets :**", json.dumps(data, indent=4))

    ready_magnets = []
    all_magnets = []

    if data.get("status") == "success" and "magnets" in data["data"]:
        for magnet in data["data"]["magnets"]:
            all_magnets.append(magnet["id"])
            if magnet["status"] == "Ready":
                ready_magnets.append(magnet)

    return ready_magnets, all_magnets

# 🔹 Récupérer les fichiers des magnets 🔹
def fetch_magnet_files(magnet_ids):
    headers = {"Authorization": f"Bearer {API_KEY}"}
    response = requests.post(API_MAGNET_FILES, headers=headers, proxies=PROXIES, data={"id[]": magnet_ids})
    data = response.json()

    if DEBUG:
        print("\n🔍 **Réponse API Fichiers :**", json.dumps(data, indent=4))

    if not data or "data" not in data or "magnets" not in data["data"]:
        return []

    return data["data"]["magnets"]

# 🔹 Extraire les liens vidéo 🔹
def extract_and_save_files(files_data):
    all_files = []

    def parse_tree(tree):
        for item in tree:
            if "e" in item:
                parse_tree(item["e"])
            else:
                file_ext = os.path.splitext(item["n"])[1].lower()
                if file_ext in VIDEO_EXTENSIONS:
                    all_files.append({"filename": item["n"], "size": round(item["s"] / (1024 * 1024 * 1024), 2), "url": item["l"]})

    for file_data in files_data:
        if "files" in file_data:
            parse_tree(file_data["files"])

    return all_files

# 🔹 Enregistrer les liens dans un fichier JSON 🔹
def save_links_to_json(links):
    if not links:
        return

    try:
        with open(OUTPUT_FILE, "r", encoding="utf-8") as f:
            existing_data = json.load(f)
    except (FileNotFoundError, json.JSONDecodeError):
        existing_data = []

    existing_data.extend(links)

    with open(OUTPUT_FILE, "w", encoding="utf-8") as f:
        json.dump(existing_data, f, indent=4, ensure_ascii=False)

# 🔹 Supprimer un batch de magnets 🔹
def delete_magnets(magnet_ids):
    if not magnet_ids:
        return  

    headers = {"Authorization": f"Bearer {API_KEY}"}
    for magnet_id in magnet_ids:
        if not magnet_id:
            continue

        response = requests.post(API_MAGNET_DELETE, headers=headers, proxies=PROXIES, data={"id": magnet_id})
        data = response.json()

        if DEBUG:
            print("\n🔍 **Réponse API Suppression Magnet :**", json.dumps(data, indent=4))

        if data.get("status") == "error" and data["error"]["code"] == "MAGNET_INVALID_ID":
            print(f"⚠️ Magnet ID {magnet_id} déjà supprimé ou inexistant, on ignore.")

# 🔹 Processus par batch de 30 🔹
def process_magnets():
    all_uploaded_ids = []

    for magnet_batch, remaining in read_magnets_by_chunks(MAGNET_FILE, 30):
        magnet_links = [line.strip().split(" | ")[-1] for line in magnet_batch]  # Extraire uniquement les liens
        uploaded_ids = upload_magnet_batch(magnet_links)
        all_uploaded_ids.extend(uploaded_ids)

        if not uploaded_ids:
            continue  

        time.sleep(5)

        ready_magnets, all_magnets = check_magnet_status()

        if ready_magnets:
            files_data = fetch_magnet_files([m["id"] for m in ready_magnets])
            extracted_files = extract_and_save_files(files_data)

            if extracted_files:
                links_to_save = [{"filename": file["filename"], "url": file["url"]} for file in extracted_files]
                save_links_to_json(links_to_save)

        if all_magnets:
            delete_magnets(all_magnets)

        if not DEBUG:
            print(f"🔄 Magnets restants : {remaining - len(magnet_batch)}")

    if all_uploaded_ids:
        delete_magnets(all_uploaded_ids)

# 🔹 Exécuter le script 🔹
if __name__ == "__main__":
    process_magnets()