#!/usr/bin/env python
"""
Utilitaire de test pour le système de stockage adaptatif AMIFOND
"""

import os
import sys
import django
from pathlib import Path

# Ajouter le répertoire backend au PATH
backend_dir = Path(__file__).parent
sys.path.insert(0, str(backend_dir))

# Configuration Django
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
django.setup()

from django.conf import settings
from apps.core.models import get_storage_type, STORAGE_TYPE


def test_storage_configuration():
    """Teste la configuration du système de stockage"""

    print("🔧 CONFIGURATION SYSTÈME DE STOCKAGE AMIFOND")
    print("=" * 60)

    # Variables d'environnement
    print("\n📋 Variables d'environnement:")
    print(f"   IS_CLOUDINARY = {os.getenv('IS_CLOUDINARY', 'Non défini')}")
    print(
        f"   AWS_STORAGE_BUCKET_NAME = {os.getenv('AWS_STORAGE_BUCKET_NAME', 'Non défini')}"
    )
    print(f"   AWS_S3_ENDPOINT_URL = {os.getenv('AWS_S3_ENDPOINT_URL', 'Non défini')}")
    print(
        f"   CLOUDINARY_CLOUD_NAME = {os.getenv('CLOUDINARY_CLOUD_NAME', 'Non défini')}"
    )

    # Configuration Django
    print(f"\n⚙️  Configuration Django:")
    print(f"   IS_CLOUDINARY = {getattr(settings, 'IS_CLOUDINARY', 'Non défini')}")
    print(
        f"   DEFAULT_FILE_STORAGE = {getattr(settings, 'DEFAULT_FILE_STORAGE', 'Non défini')}"
    )
    print(f"   MEDIA_ROOT = {getattr(settings, 'MEDIA_ROOT', 'Non défini')}")
    print(f"   MEDIA_URL = {getattr(settings, 'MEDIA_URL', 'Non défini')}")

    # Type de stockage détecté
    print(f"\n🎯 Stockage détecté:")
    print(f"   Type = {STORAGE_TYPE}")

    # Status
    if STORAGE_TYPE == "cloudinary":
        print("   ✅ Cloudinary configuré et activé")
        try:
            import cloudinary

            print(f"   📦 Cloudinary version: {cloudinary.__version__}")
        except ImportError:
            print("   ❌ Module Cloudinary non installé")

    elif STORAGE_TYPE == "s3":
        print("   ✅ S3/MinIO configuré")
        aws_endpoint = getattr(settings, "AWS_S3_ENDPOINT_URL", None)
        if aws_endpoint:
            print(f"   🐳 MinIO endpoint: {aws_endpoint}")
        else:
            print("   ☁️  AWS S3 configuré")

    else:  # local
        print("   📁 Stockage local (développement)")
        media_root = getattr(settings, "MEDIA_ROOT", None)
        if media_root:
            print(f"   📂 Répertoire: {media_root}")
            # Créer le répertoire si nécessaire
            Path(media_root).mkdir(parents=True, exist_ok=True)
            print("   📁 Répertoire créé/vérifié")

    print("\n" + "=" * 60)
    print("✅ Test de configuration terminé")


def simulate_environments():
    """Simule différentes configurations d'environnement"""

    print("\n🧪 SIMULATION DES ENVIRONNEMENTS")
    print("=" * 60)

    environments = {
        "Développement": {
            "IS_CLOUDINARY": "False",
            # Pas de config S3
        },
        "Staging (MinIO)": {
            "IS_CLOUDINARY": "False",
            "AWS_STORAGE_BUCKET_NAME": "amifond-staging",
            "AWS_S3_ENDPOINT_URL": "http://minio:9000",
        },
        "Production (S3)": {
            "IS_CLOUDINARY": "False",
            "AWS_STORAGE_BUCKET_NAME": "amifond-prod",
            # Pas d'endpoint = AWS S3
        },
        "Production (Cloudinary)": {
            "IS_CLOUDINARY": "True",
            "CLOUDINARY_CLOUD_NAME": "amifond-prod",
        },
    }

    for env_name, env_vars in environments.items():
        print(f"\n🌍 {env_name}:")

        # Simuler les variables d'environnement
        original_env = {}
        for key, value in env_vars.items():
            original_env[key] = os.environ.get(key)
            os.environ[key] = value

        # Simuler la détection
        storage_type = get_storage_type()
        print(f"   → Type détecté: {storage_type}")

        # Suggestions
        if storage_type == "local":
            print("   💡 Idéal pour le développement local")
        elif storage_type == "s3":
            if "minio" in env_vars.get("AWS_S3_ENDPOINT_URL", "").lower():
                print("   💡 MinIO - Parfait pour staging/test")
            else:
                print("   💡 AWS S3 - Production sans Cloudinary")
        elif storage_type == "cloudinary":
            print("   💡 Cloudinary - Production optimisée")

        # Restaurer l'environnement
        for key, original_value in original_env.items():
            if original_value is not None:
                os.environ[key] = original_value
            elif key in os.environ:
                del os.environ[key]


if __name__ == "__main__":
    print("🏦 SYSTÈME DE STOCKAGE ADAPTATIF - COOP-CA AMIFOND")
    print("Testeur de configuration automatique\n")

    try:
        test_storage_configuration()
        simulate_environments()

        print("\n🎉 RECOMMANDATIONS:")
        print("-" * 60)
        print("1. 🚀 Développement: IS_CLOUDINARY=False (stockage local)")
        print("2. 🐳 Staging: IS_CLOUDINARY=False + MinIO")
        print("3. ☁️  Production: IS_CLOUDINARY=True (recommandé)")
        print("4. 📦 Alternative: IS_CLOUDINARY=False + AWS S3")

    except Exception as e:
        print(f"❌ Erreur lors du test: {e}")
        sys.exit(1)