#!/usr/bin/env python
"""
Script pour ajouter des produits à la base de données locale.
Ce script ajoute des produits de démonstration à une base de données SQLite locale.
"""
import os
import sys
import shutil
from pathlib import Path

# Couleurs pour les messages console
COLORS = {
    'GREEN': '\033[92m',
    'YELLOW': '\033[93m',
    'RED': '\033[91m',
    'BOLD': '\033[1m',
    'END': '\033[0m'
}

# Fonction pour afficher des messages colorés
def print_colored(message, color):
    print(f"{COLORS[color]}{message}{COLORS['END']}")

def print_header(message):
    print("\n" + "=" * 80)
    print_colored(f" {message.upper()} ", 'BOLD')
    print("=" * 80)

def print_step(step, message):
    print(f"\n{COLORS['BOLD']}[{step}]{COLORS['END']} {message}")

def print_error(message):
    print(f"{COLORS['RED']}ERROR: {message}{COLORS['END']}")

def print_success(message):
    print(f"{COLORS['GREEN']}SUCCESS: {message}{COLORS['END']}")

def print_warning(message):
    print(f"{COLORS['YELLOW']}WARNING: {message}{COLORS['END']}")

# Vérification et création des catégories
def ensure_categories():
    print_step("1", "Vérification et création des catégories de produits...")
    
    try:
        # Configuration Flask pour accéder à la base de données
        from app import app, db
        from models import Category
        
        # Catégories de base
        categories = [
            {"name": "Moteurs", "description": "Moteurs industriels et poids lourds"},
            {"name": "Pièces détachées", "description": "Pièces de rechange pour moteurs"},
            {"name": "Accessoires", "description": "Accessoires pour moteurs et véhicules"},
            {"name": "Reconditionnement", "description": "Pièces et moteurs reconditionnés"}
        ]
        
        # Dictionnaire pour stocker les catégories créées (nom -> id)
        created_categories = {}
        
        with app.app_context():
            # Vérifier les catégories existantes
            existing_categories = Category.query.all()
            existing_count = len(existing_categories)
            print(f"Catégories existantes dans la base de données: {existing_count}")
            
            # Stocker les catégories existantes
            for category in existing_categories:
                created_categories[category.name] = category.id
            
            # Ajouter les catégories manquantes
            if existing_count < len(categories):
                for category_data in categories:
                    if category_data["name"] not in created_categories:
                        category = Category(
                            name=category_data["name"],
                            description=category_data["description"]
                        )
                        db.session.add(category)
                
                # Sauvegarder les nouvelles catégories
                db.session.commit()
                
                # Mettre à jour le dictionnaire avec les nouvelles catégories
                new_categories = Category.query.all()
                for category in new_categories:
                    if category.name not in created_categories:
                        created_categories[category.name] = category.id
                        print_success(f"Catégorie ajoutée: {category.name}")
            
            return created_categories
    
    except ImportError as e:
        print_error(f"Erreur d'importation: {e}")
        print_warning("Vérifiez que vous avez bien exécuté la commande 'python run_local_debug.py' au moins une fois.")
        return {}
    except Exception as e:
        print_error(f"Erreur lors de la création des catégories: {e}")
        return {}

# Vérification de l'existence du dossier pour les images des produits
def check_products_folder():
    uploads_path = Path('static/uploads/products')
    if not uploads_path.exists():
        print_warning("Dossier pour les images des produits non trouvé. Création...")
        uploads_path.mkdir(parents=True, exist_ok=True)
        print_success("Dossier créé: static/uploads/products")
    else:
        print_success("Dossier pour les images des produits OK.")

# Copie des images de démonstration ou création d'images par défaut
def setup_demo_images():
    print_step("2", "Préparation des images de produits...")
    
    # Vérifier le dossier d'images
    check_products_folder()
    
    # Liste des produits avec leurs images par défaut
    product_images = {
        'product1.jpg': 'Moteur industriel',
        'product2.jpg': 'Bloc moteur',
        'product3.jpg': 'Culasse',
        'product4.jpg': 'Vilebrequin',
        'product5.jpg': 'Piston',
        'product6.jpg': 'Système d\'échappement',
        'product7.jpg': 'Système de refroidissement',
        'product8.jpg': 'Kit de révision',
    }
    
    # Chercher les images existantes dans le dossier attached_assets
    attached_assets = Path('attached_assets')
    found_images = []
    
    if attached_assets.exists():
        # Chercher des images dans attached_assets
        for img_file in attached_assets.glob('*.jpg'):
            if img_file.name.startswith('IMG-') or 'WA' in img_file.name:
                shutil.copy(img_file, f'static/uploads/products/{img_file.name}')
                found_images.append(img_file.name)
                if len(found_images) >= 8:  # Limiter à 8 images
                    break
    
    # Si nous n'avons pas assez d'images, créons des images par défaut avec du texte
    if len(found_images) < 8:
        print_warning(f"Seulement {len(found_images)} images trouvées. Création d'images par défaut...")
        
        try:
            from PIL import Image, ImageDraw, ImageFont
            
            for i, (img_name, product_name) in enumerate(product_images.items()):
                if i < len(found_images):
                    continue
                    
                # Créer une image avec du texte
                img = Image.new('RGB', (800, 600), color=(73, 109, 137))
                d = ImageDraw.Draw(img)
                
                # Essayer de trouver une police
                try:
                    font = ImageFont.truetype("arial.ttf", 36)
                except IOError:
                    try:
                        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 36)
                    except IOError:
                        font = ImageFont.load_default()
                
                # Ajouter le texte
                d.text((400, 300), product_name, fill=(255, 255, 255), anchor="mm", font=font)
                
                # Sauvegarder
                img_path = f'static/uploads/products/{img_name}'
                img.save(img_path)
                found_images.append(img_name)
                print_success(f"Image créée: {img_path}")
                
        except ImportError:
            print_warning("PIL (Pillow) n'est pas installé. Tentative d'installation...")
            try:
                import subprocess
                subprocess.check_call([sys.executable, "-m", "pip", "install", "Pillow"])
                print_success("PIL (Pillow) installé avec succès!")
                # Rappel récursif après installation
                return setup_demo_images()
            except Exception as e:
                print_error(f"Impossible d'installer PIL: {e}")
                print_warning("Continuons sans créer d'images...")
    
    # Retourner les noms des images trouvées ou créées
    return found_images

# Préparation et ajout des produits dans la base de données
def add_demo_products(categories):
    print_step("3", "Ajout des produits dans la base de données locale...")
    
    try:
        # Obtenir les images pour les produits
        product_images = setup_demo_images()
        
        # Configuration Flask pour accéder à la base de données
        from app import app, db
        from models import Product
        
        # Produits démos à ajouter (avec catégories réelles)
        demo_products = [
            {
                "name": "Moteur Industriel MAN D2868",
                "description": "Le MAN D2868 est un moteur diesel 8 cylindres robuste et fiable, conçu pour les applications industrielles exigeantes. Sa conception avancée assure une performance optimale, une consommation réduite de carburant et une maintenance facile.",
                "price": 12500000,
                "image_url": f"uploads/products/{product_images[0]}" if product_images else "",
                "category_id": categories.get("Moteurs", 1),
                "is_available": True,
                "condition": "new"
            },
            {
                "name": "Bloc Moteur MAN D2066",
                "description": "Bloc moteur de qualité pour moteur diesel MAN D2066. Pièce robuste et durable, usinage de précision pour une performance optimale. Compatible avec les véhicules poids lourds et applications industrielles.",
                "price": 2800000,
                "image_url": f"uploads/products/{product_images[1]}" if len(product_images) > 1 else "",
                "category_id": categories.get("Pièces détachées", 2),
                "is_available": True,
                "condition": "new"
            },
            {
                "name": "Culasse Complète D2066 LF01",
                "description": "Culasse complète pour moteur MAN D2066 LF01. Inclut soupapes, ressorts et arbres à cames. Pièce de qualité OEM garantissant une performance optimale et une durée de vie prolongée.",
                "price": 1150000,
                "image_url": f"uploads/products/{product_images[2]}" if len(product_images) > 2 else "",
                "category_id": categories.get("Pièces détachées", 2),
                "is_available": True,
                "condition": "new"
            },
            {
                "name": "Vilebrequin MAN D2876",
                "description": "Vilebrequin de précision pour moteur MAN D2876. Fabriqué selon les normes les plus strictes pour assurer une fiabilité et une performance exceptionnelles. Equilibrage dynamique pour minimiser les vibrations.",
                "price": 980000,
                "image_url": f"uploads/products/{product_images[3]}" if len(product_images) > 3 else "",
                "category_id": categories.get("Pièces détachées", 2),
                "is_available": True,
                "condition": "new"
            },
            {
                "name": "Kit Pistons et Segments D2066",
                "description": "Ensemble complet de pistons et segments pour moteur MAN D2066. Kit de 6 pistons avec segments de compression et segments racleurs. Pièces de qualité supérieure pour une compression optimale et une consommation d'huile réduite.",
                "price": 620000,
                "image_url": f"uploads/products/{product_images[4]}" if len(product_images) > 4 else "",
                "category_id": categories.get("Pièces détachées", 2),
                "is_available": True,
                "condition": "new"
            },
            {
                "name": "Turbocompresseur Holset HX55",
                "description": "Turbocompresseur Holset HX55 pour moteurs poids lourds et industriels. Performance supérieure avec une réponse rapide et un boost de puissance optimisé. Compatible avec plusieurs modèles de moteurs MAN.",
                "price": 750000,
                "image_url": f"uploads/products/{product_images[5]}" if len(product_images) > 5 else "",
                "category_id": categories.get("Accessoires", 3),
                "is_available": True,
                "condition": "new"
            },
            {
                "name": "Radiateur Industriel MAN D2868",
                "description": "Radiateur haute performance pour moteur industriel MAN D2868. Conçu pour une dissipation thermique optimale dans les conditions les plus exigeantes. Construction robuste avec alliage d'aluminium et tubes renforcés.",
                "price": 480000,
                "image_url": f"uploads/products/{product_images[6]}" if len(product_images) > 6 else "",
                "category_id": categories.get("Accessoires", 3),
                "is_available": True,
                "condition": "new"
            },
            {
                "name": "Moteur Reconditionné MAN D2066",
                "description": "Moteur MAN D2066 entièrement reconditionné selon les spécifications d'usine. Toutes les pièces d'usure remplacées, bloc moteur et culasse rectifiés, vilebrequin poli. Livré avec une garantie de 12 mois.",
                "price": 6500000,
                "image_url": f"uploads/products/{product_images[7]}" if len(product_images) > 7 else "",
                "category_id": categories.get("Reconditionnement", 4),
                "is_available": True,
                "condition": "reconditioned"
            }
        ]
        
        # Créer un contexte d'application Flask
        with app.app_context():
            # Vérifier si la table des produits existe et contient des données
            existing_products = Product.query.count()
            print(f"Produits existants dans la base de données: {existing_products}")
            
            if existing_products == 0:
                print_warning("Aucun produit trouvé. Ajout des produits de démonstration...")
                
                # Ajouter les produits de démo
                for product_data in demo_products:
                    product = Product(
                        name=product_data["name"],
                        description=product_data["description"],
                        price=product_data["price"],
                        image_url=product_data["image_url"],
                        category_id=product_data["category_id"],
                        is_available=product_data["is_available"],
                        condition=product_data["condition"]
                    )
                    db.session.add(product)
                
                # Sauvegarder dans la base de données
                db.session.commit()
                print_success(f"{len(demo_products)} produits ajoutés avec succès!")
            else:
                print_warning(f"La base de données contient déjà {existing_products} produits.")
                answer = input("Voulez-vous ajouter quand même 8 produits supplémentaires? (o/n): ")
                if answer.lower() == 'o':
                    # Ajouter les produits de démo
                    for product_data in demo_products:
                        product = Product(
                            name=product_data["name"],
                            description=product_data["description"],
                            price=product_data["price"],
                            image_url=product_data["image_url"],
                            category_id=product_data["category_id"],
                            is_available=product_data["is_available"],
                            condition=product_data["condition"]
                        )
                        db.session.add(product)
                    
                    # Sauvegarder dans la base de données
                    db.session.commit()
                    print_success(f"{len(demo_products)} produits supplémentaires ajoutés avec succès!")
                else:
                    print_warning("Aucun produit supplémentaire ajouté.")
        
        return True
        
    except ImportError as e:
        print_error(f"Erreur d'importation: {e}")
        print_warning("Vérifiez que vous avez bien exécuté la commande 'python run_local_debug.py' au moins une fois.")
        return False
    except Exception as e:
        print_error(f"Erreur lors de l'ajout des produits: {e}")
        return False

# Fonction principale
def main():
    print_header("Ajout de produits de démonstration pour GMPL")
    
    # 1. Assurer que les catégories existent
    categories = ensure_categories()
    if not categories:
        print_error("Impossible de créer les catégories nécessaires.")
        return
    
    # 2. Ajouter les produits
    if add_demo_products(categories):
        print_header("Produits ajoutés avec succès")
        print(f"\n{COLORS['GREEN']}Des produits de démonstration ont été ajoutés à votre base de données locale.{COLORS['END']}")
        print("\nPour les voir:")
        print(f"1. Exécutez: {COLORS['BOLD']}python run_local_debug.py{COLORS['END']}")
        print(f"2. Accédez à: {COLORS['BOLD']}http://localhost:5000/products{COLORS['END']}")
        print(f"\nPour gérer les produits:")
        print(f"1. Accédez à: {COLORS['BOLD']}http://localhost:5000/admin/products{COLORS['END']}")
    else:
        print_header("Impossible d'ajouter des produits")
        print(f"\n{COLORS['YELLOW']}Des erreurs ont été rencontrées lors de l'ajout des produits.{COLORS['END']}")
        print("\nSolutions alternatives:")
        print("1. Exécutez d'abord le script de correction pour l'admin:")
        print(f"   {COLORS['BOLD']}python fix_admin_local.py{COLORS['END']}")
        print("2. Puis lancez le serveur en mode local:")
        print(f"   {COLORS['BOLD']}python run_local_debug.py{COLORS['END']}")
        print("3. Connectez-vous à l'admin et ajoutez des produits manuellement:")
        print(f"   {COLORS['BOLD']}http://localhost:5000/admin/products/add{COLORS['END']}")

if __name__ == "__main__":
    main()
