import os
import sys
import asyncio
import paramiko

# Ajout du répertoire parent dans le path pour les imports locaux
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))

from api.products import get_all_products, get_all_variants, get_variant_metafields
from api.customers import get_access_token, load_tokens, _rate_limiters, _tokens
from utils.utils import map_csv_file, find_rule_by_name, extract_datas_by_label
from api.BSS.api import get_all_rules, create_or_update_rule_async
from mapping.products import products_pricing_map

# Initialisation des tokens et rate limiters (créés dans le même event loop)
load_tokens()

base_dir = os.path.dirname(__file__)
mapping_dir = os.path.abspath(os.path.join(base_dir, '..', 'files', 'products'))
os.makedirs(mapping_dir, exist_ok=True)

BSS_API_KEY = 'c4uiY9TEKt07cK0LuRkruq7eRX0+Xo6vIigtHzpEueg='
SHOP_NAME = 'https://emde-b2b.myshopify.com/'

# Récupération des règles existantes


def download_sftp_file(remote_folder: str, file_name: str, local_folder: str) -> str:
    host = "emde.autarcia.com"
    port = 22
    username = "ftp-shoppingfeed"
    password = "5vm_*2I[f2yL2A6J!/dE"
    
    local_path = os.path.join(local_folder, file_name)
    remote_path = os.path.join(remote_folder, file_name)
    
    transport = paramiko.Transport((host, port))
    try:
        transport.connect(username=username, password=password)
        sftp = paramiko.SFTPClient.from_transport(transport)
        sftp.get(remote_path, local_path)
        print(f"Téléchargement de {remote_path} réussi vers {local_path}")
    finally:
        sftp.close()
        transport.close()
        
    return local_path

async def process_variant(index, variant, products_pricing_data,all_cp_rules):
    variant_id = variant["id"]
    # La fonction get_variant_metafields doit respecter le quota de 2 appels par token via _rate_limiters
    metafields = await get_variant_metafields(variant_id, index)
    for metafield in metafields:
        if metafield['key'] == 'variant_id':
            variant_tag_id = metafield.get('value')
            product_prices_data = extract_datas_by_label('product_id', variant_tag_id, products_pricing_data)
            if product_prices_data:
                for product_price_data in product_prices_data:
                    if product_price_data['product_GPV'] != 'PPC':
                        rule_name = f"Produit: {product_price_data['product_id']} ---  GPV: {product_price_data['product_GPV']}"
                        print(rule_name)
                        founded_rule = find_rule_by_name(rule_name, all_cp_rules)
                        rule_id = founded_rule['id'] if founded_rule else None
                        # La création/mise à jour de règles n'est pas limitée par le quota
                        await create_or_update_rule_async(
                            0, 4, 4, rule_name,
                            f"code_tarif_{product_price_data['product_GPV']}",
                            None, None, float(product_price_data['product_base_price'].replace(',', '.')),
                            rule_id, BSS_API_KEY,
                            variant_id, 0, None
                        )

async def process_variant_with_semaphore(index, variant, products_pricing_data, semaphore, all_cp_rules):
    async with semaphore:
        await process_variant(index, variant, products_pricing_data, all_cp_rules)

async def main():
    rules_data = await get_all_rules('emde-b2b.myshopify.com', BSS_API_KEY)
    all_cp_rules = rules_data["rules"]
    rule_ids = [rule["id"] for rule in rules_data.get("rules", [])]
    # Dossier distant SFTP et nom du fichier à télécharger
    remote_folder = "/exports/CSV/exp_swing"
    products_pricing_file_name = "SW_DATA_SELLSCONDITI_2671.CSV"
    
    # Téléchargement du fichier CSV via SFTP
    products_pricing_file = download_sftp_file(remote_folder, products_pricing_file_name, mapping_dir)
    
    # Récupérer les variantes de manière asynchrone
    variants = await get_all_variants()
    products_pricing_data = map_csv_file(products_pricing_file, products_pricing_map)
    
    # Limiter le nombre de tâches concurrentes à 8
    semaphore = asyncio.Semaphore(8)
    tasks = []
    for index, variant in enumerate(variants):
        tasks.append(process_variant_with_semaphore(index, variant, products_pricing_data, semaphore, all_cp_rules))
    
    await asyncio.gather(*tasks)

if __name__ == "__main__":
    asyncio.run(main())