import os
import uuid
from datetime import datetime
from flask import current_app
from werkzeug.utils import secure_filename

def save_image(file, folder='uploads/products'):
    """
    Save an uploaded image file to the upload folder
    and return the filename or None if failed.
    The path returned is compatible with both local and production environments.
    """
    if not file:
        return None
    
    # Create uploads directory if it doesn't exist
    upload_folder = os.path.join(current_app.static_folder, folder)
    if not os.path.exists(upload_folder):
        os.makedirs(upload_folder)
        current_app.logger.info(f"Dossier créé: {upload_folder}")
    
    # Generate unique filename with timestamp to prevent caching issues
    filename = secure_filename(file.filename)
    timestamp = int(datetime.now().timestamp())
    unique_filename = f"{uuid.uuid4().hex}_{timestamp}_{filename}"
    
    try:
        file_path = os.path.join(upload_folder, unique_filename)
        file.save(file_path)
        current_app.logger.info(f"Image sauvegardée: {file_path}")
        
        # Return path relative to static folder for consistency
        # This works in both local and production environments
        # Format: static/uploads/products/image.jpg -> uploads/products/image.jpg
        relative_path = os.path.join(folder, unique_filename)
        current_app.logger.info(f"Chemin relatif de l'image: {relative_path}")
        return relative_path
    except Exception as e:
        current_app.logger.error(f"Erreur lors de la sauvegarde de l'image: {e}")
        return None

def get_nested_categories(categories, parent_id=None, level=0):
    """
    Convert flat list of categories to hierarchical structure.
    Returns a list of tuples (id, name) for display in select fields.
    The name is indented to show hierarchy level.
    """
    result = []
    for category in categories:
        if category.parent_id == parent_id:
            # Only include id and name in the tuple for SelectField
            result.append((category.id, '  ' * level + category.name))
            # Add children
            result.extend(get_nested_categories(categories, category.id, level + 1))
    return result

def initialize_site_settings():
    """
    Initialize site settings with default values if they don't exist.
    """
    from app import db
    from models import SiteSetting
    
    default_settings = {
        'company_name': 'GMPL - General Motors Poids Lourds',
        'company_description': 'Spécialiste des moteurs et pièces détachées pour poids lourds',
        'company_address': 'Km 12, route de Rufisque, Dakar, Sénégal',
        'company_email': 'gmplsn6@gmail.com',
        'company_phone': '+221 77 125 29 29 / 77 049 62 17 / 76 011 53 53 / 77 522 36 36',
        'home_intro': 'Bienvenue chez GMPL, votre partenaire de confiance pour les moteurs et pièces détachées de poids lourds.',
        'about_content': 'GMPL est une entreprise spécialisée dans la vente de moteurs et pièces détachées pour poids lourds.',
        'meta_keywords': 'GMPL, poids lourds, moteurs, pièces détachées, Dakar, Sénégal',
        'meta_description': 'GMPL - Spécialiste des moteurs et pièces détachées pour poids lourds à Dakar, Sénégal.'
    }
    
    for key, value in default_settings.items():
        setting = SiteSetting.query.filter_by(key=key).first()
        if not setting:
            setting = SiteSetting(key=key, value=value)
            db.session.add(setting)
    
    db.session.commit()

def fix_image_paths():
    """
    Vérifie et corrige les chemins d'images dans la base de données.
    Ceci garantit que les images sont correctement affichées en mode local.
    """
    from app import db
    from models import Product, Service
    import os
    
    try:
        current_app.logger.info("Vérification des chemins d'images...")
        
        # Vérifier les images de produits
        products = Product.query.all()
        current_app.logger.info(f"Nombre de produits trouvés: {len(products)}")
        for product in products:
            current_app.logger.info(f"Produit: {product.id} - {product.name} - {product.image_url}")
            
            # S'il n'y a pas d'image_url, assigner une image de démo
            if not product.image_url:
                product.image_url = f"uploads/products/demo_motor{(product.id % 3) + 1}.jpg"
                current_app.logger.info(f"Image de produit assignée: {product.image_url}")
                continue
                
            # Si le chemin commence par 'static/', le supprimer
            if product.image_url.startswith('static/'):
                product.image_url = product.image_url.replace('static/', '', 1)
                current_app.logger.info(f"Image de produit corrigée: {product.image_url}")
            
            # Garantir que le chemin commence par 'uploads/'
            if not product.image_url.startswith('uploads/'):
                product.image_url = os.path.join('uploads/products', os.path.basename(product.image_url))
                current_app.logger.info(f"Chemin d'image normalisé: {product.image_url}")
                
            # Vérifier si le fichier existe
            full_path = os.path.join(current_app.static_folder, product.image_url)
            if not os.path.exists(full_path):
                # Si l'image n'existe pas, utiliser une image de démo
                product.image_url = f"uploads/products/demo_motor{(product.id % 3) + 1}.jpg"
                current_app.logger.info(f"Image de produit remplacée par une image de démo: {product.image_url}")
        
        # Vérifier les images de services
        services = Service.query.all()
        current_app.logger.info(f"Nombre de services trouvés: {len(services)}")
        for service in services:
            current_app.logger.info(f"Service: {service.id} - {service.name} - {service.image_url}")
            
            # S'il n'y a pas d'image_url, assigner une image de démo
            if not service.image_url:
                service.image_url = f"uploads/services/demo_service{(service.id % 3) + 1}.jpg"
                current_app.logger.info(f"Image de service assignée: {service.image_url}")
                continue
                
            # Si le chemin commence par 'static/', le supprimer
            if service.image_url.startswith('static/'):
                service.image_url = service.image_url.replace('static/', '', 1)
                current_app.logger.info(f"Image de service corrigée: {service.image_url}")
            
            # Garantir que le chemin commence par 'uploads/'
            if not service.image_url.startswith('uploads/'):
                service.image_url = os.path.join('uploads/services', os.path.basename(service.image_url))
                current_app.logger.info(f"Chemin d'image normalisé: {service.image_url}")
                
            # Vérifier si le fichier existe
            full_path = os.path.join(current_app.static_folder, service.image_url)
            if not os.path.exists(full_path):
                # Si l'image n'existe pas, utiliser une image de démo
                service.image_url = f"uploads/services/demo_service{(service.id % 3) + 1}.jpg"
                current_app.logger.info(f"Image de service remplacée par une image de démo: {service.image_url}")
        
        # Sauvegarder les modifications
        db.session.commit()
        current_app.logger.info("Correction des chemins d'images terminée")
        return True
    except Exception as e:
        current_app.logger.error(f"Erreur lors de la correction des chemins d'images: {e}")
        db.session.rollback()
        return False