import sys
import os
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../..')))

import csv
import json
import asyncio
import aiohttp
from Harken.General.Product.product import Product
from Harken.General.Product.image_service import ImageService
from Harken.General.Product.tag_service import TagService
from Harken.General.Product.product_generation_service import ProductGenerationService
from Harken.API.tokens import access_tokens
from Harken.API.product_create import create_shopify_product

# Chemin vers le fichier CSV
file_path = '../../Harken/files/Products/products-B2B.csv'
if not os.path.exists(file_path):
    print(f"Le fichier CSV '{file_path}' est introuvable.")
    exit()

# Limite de 9 requêtes simultanées
semaphore = asyncio.Semaphore(9)

async def process_row(session, row, token_index):
    try:
        print(f"Traitement de la ligne : {row}")
        if len(row) < 4:
            print(f"La ligne a un nombre insuffisant de colonnes : {row}")
            return

        article_code = row[0].strip()  # Utilisé comme SKU
        family = row[1].strip()
        designation = row[2].strip()
        image = row[3].strip()
        category = row[4].strip()
        sku = row[0].strip()  # Nouveau champ pour le SKU

        # Créer un produit avec une variante
        product = Product(
            title = sku+" - "+designation,
            description = "Description",
            vendor = "",
            product_type = category,
        )

        # Ajouter une variante avec le SKU
        variant = {
            "option1": "Default",  # Shopify demande au moins une option (par exemple, "Taille" ou "Couleur")
            "sku": sku,
            "price": "0.00",  # Vous pouvez définir un prix par défaut ou l'extraire du CSV
            "inventory_management": "shopify",
        }
        product.add_variant(variant)

        # Services pour gérer les images et les tags
        image_service = ImageService()
        tag_service = TagService()

        # Ajouter une image si elle existe
        if image:
            image_url = f'https://api.huggii.com/Harken/images/{image}'
            image_service.add_image(image_url, article_code)

        # Ajouter des tags
        tag_service.add_tag(family)
        tag_service.add_tag(category)

        # Générer les données formatées du produit
        product_service = ProductGenerationService(product, image_service, tag_service)
        product_data = product_service.get_formatted_product_data()

        # Ajouter les variantes au produit
        product_data["variants"] = [variant]

        # Sélectionner un token basé sur l'index
        access_token = access_tokens[token_index % len(access_tokens)]

        print(f"Appel de create_shopify_product avec le token : {access_token}")

        # Envoyer le produit à Shopify
        async with semaphore:
            response = await create_shopify_product(session, product_data, access_token)

        # Afficher le retour de l'API
        if response:
            print(f"Produit créé avec succès : {response}")
        else:
            print(f"Erreur lors de la création du produit : {designation}")
    except Exception as e:
        print(f"Exception dans process_row pour la ligne {row}: {e}")

async def process_csv(file_path):
    try:
        # Ouverture et lecture du fichier CSV
        with open(file_path, mode='r', encoding='ISO-8859-1') as file:
            csv_reader = csv.reader(file, delimiter=';')
            headers = next(csv_reader)

            async with aiohttp.ClientSession() as session:
                tasks = []
                for index, row in enumerate(csv_reader):
                    print(f"Ajout d'une tâche pour la ligne : {row}")
                    task = asyncio.create_task(process_row(session, row, index))
                    tasks.append(task)

                    # Traiter les tâches par lots de 100 pour éviter la surcharge
                    if len(tasks) >= 100:
                        print(f"Traitement d'un lot de {len(tasks)} tâches")
                        results = await asyncio.gather(*tasks, return_exceptions=True)
                        tasks = []
                        # Vérifier les exceptions
                        for result in results:
                            if isinstance(result, Exception):
                                print(f"Exception levée dans une tâche : {result}")

                # Traiter les tâches restantes
                if tasks:
                    print(f"Traitement du dernier lot de {len(tasks)} tâches")
                    results = await asyncio.gather(*tasks, return_exceptions=True)
                    for result in results:
                        if isinstance(result, Exception):
                            print(f"Exception levée dans une tâche : {result}")

    except FileNotFoundError:
        print("Le fichier CSV n'existe pas.")
    except Exception as e:
        print(f"Erreur dans process_csv : {e}")

if __name__ == "__main__":
    # Exécution de la boucle asynchrone
    asyncio.run(process_csv(file_path))