import requests
import time
import concurrent.futures

# 🌍 CONFIGURATION API ALLDEBRID
API_KEY = "lUCRvOPYXci0DOVAz61u"  # 🔑 Mets ta clé API ici
TORRENT_LIST_FILE = "torrent_list.txt"  # 📜 Fichier contenant les magnets
BATCH_SIZE = 100  # 📌 Nombre de magnets envoyés par batch
THREADS = 5  # ⚡ Nombre de requêtes simultanées
PAUSE_TIME = 15  # ⏸️ Pause entre chaque batch
LONG_PAUSE_TIME = 300  # ⏸️ Pause de 5 minutes si trop d'échecs (300s)
MAX_RETRY_FAILURES = 10  # 📌 Si 10 erreurs, on fait une pause de 5 minutes

# 🌍 CONFIGURATION PROXY (si nécessaire)
PROXY_URL = "http://lClXMfmYmiIMtc2:8ww25795ye6RYjO@46.203.211.10:45803"
PROXIES = {"http": PROXY_URL, "https": PROXY_URL}

# 🌍 URLs API AllDebrid
MAGNET_UPLOAD_URL = "https://api.alldebrid.com/v4/magnet/upload"

# 📝 Charger les magnets depuis `torrent_list.txt`
def load_magnets():
    try:
        with open(TORRENT_LIST_FILE, "r", encoding="utf-8") as file:
            magnets = [line.strip().split(" | ")[-1] for line in file if line.strip()]
        return magnets
    except FileNotFoundError:
        print("❌ Fichier torrent_list.txt introuvable.")
        return []

# 🔄 Ajouter un magnet (avec gestion des erreurs et retry)
def add_magnet(magnet):
    try:
        response = requests.get(MAGNET_UPLOAD_URL, params={"apikey": API_KEY, "agent": "myapp", "magnet": magnet},
                                proxies=PROXIES, timeout=10)

        if not response.text.strip():  # Réponse vide
            print("⚠️ Réponse vide, attente de 5s avant de réessayer...")
            time.sleep(5)
            return add_magnet(magnet)  # ⏳ Réessaye après 5s

        data = response.json()  # 🔄 Convertit la réponse en JSON
        
        if data.get("status") == "success":
            print(f"✅ Magnet ajouté : {magnet[:50]}...")
            return magnet  # Retourne le magnet si succès
        else:
            print(f"❌ Erreur d'ajout : {data}")
            return None

    except requests.exceptions.JSONDecodeError:
        print("⚠️ Erreur JSON, attente de 5s avant de réessayer...")
        time.sleep(5)
        return add_magnet(magnet)

    except requests.exceptions.RequestException as e:
        print(f"⚠️ Erreur réseau : {e}, attente de 10s...")
        time.sleep(10)
        return add_magnet(magnet)

# 🔄 Ajouter des magnets en parallèle
def add_magnet_batch(magnets):
    sent_magnets = []
    failed_count = 0

    with concurrent.futures.ThreadPoolExecutor(max_workers=THREADS) as executor:
        results = list(executor.map(add_magnet, magnets))
    
    for magnet, result in zip(magnets, results):
        if result is not None:
            sent_magnets.append(result)
        else:
            failed_count += 1

    print(f"\n🚀 {len(sent_magnets)} magnets envoyés avec succès ! {failed_count} échecs.\n")

    return sent_magnets, failed_count

# 📝 Supprimer les magnets envoyés du fichier
def remove_sent_magnets(sent_magnets):
    all_magnets = load_magnets()
    remaining_magnets = [magnet for magnet in all_magnets if magnet not in sent_magnets]

    with open(TORRENT_LIST_FILE, "w", encoding="utf-8") as file:
        for magnet in remaining_magnets:
            file.write(magnet + "\n")

    print(f"\n🗑️ {len(sent_magnets)} magnets supprimés du fichier. {len(remaining_magnets)} restants.\n")

# 🚀 Gestion de l'envoi automatique par batch avec pause intelligente
def send_magnets_in_batches():
    total_failures = 0

    while True:
        magnets = load_magnets()

        if not magnets:
            print("✅ Tous les magnets ont été envoyés.")
            break

        batch = magnets[:BATCH_SIZE]  # Prend les 100 premiers magnets
        sent_magnets, batch_failures = add_magnet_batch(batch)

        remove_sent_magnets(sent_magnets)

        total_failures += batch_failures

        if total_failures >= MAX_RETRY_FAILURES:
            print(f"\n⏳ Trop d'erreurs ({total_failures}), pause de {LONG_PAUSE_TIME//60} minutes...\n")
            time.sleep(LONG_PAUSE_TIME)
            total_failures = 0  # Réinitialise le compteur après la pause
        else:
            print(f"\n⏳ Pause de {PAUSE_TIME} secondes avant d'envoyer le prochain batch...\n")
            time.sleep(PAUSE_TIME)

# 🚀 Lancer le script
if __name__ == "__main__":
    send_magnets_in_batches()