"""
Full integration test script to validate UTF-8 implementation
and French localization.

This script runs all unit tests and checks full integration.
"""

import json
import os
import subprocess
import sys
import tempfile
from pathlib import Path


def run_utf8_integration_tests():
    """Run UTF-8 integration tests."""
    print("🚀 Starting UTF-8 integration tests")
    print("=" * 60)

    # Test environment setup
    os.environ["LOCALE"] = "fr-FR"
    os.environ["GEMINI_API_KEY"] = "dummy-key-for-tests"
    os.environ["OPENAI_API_KEY"] = "dummy-key-for-tests"

    # Test 1: Validate UTF-8 characters in json.dumps
    print("\n1️⃣ UTF-8 encoding test with json.dumps")
    test_utf8_json_encoding()

    # Test 2: Validate language instruction generation
    print("\n2️⃣ Language instruction generation test")
    test_language_instruction_generation()

    # Test 3: Validate UTF-8 file handling
    print("\n3️⃣ UTF-8 file handling test")
    test_file_utf8_handling()

    # Test 4: Validate MCP tools integration
    print("\n4️⃣ MCP tools integration test")
    test_mcp_tools_integration()

    # Test 5: Run unit tests
    print("\n5️⃣ Running unit tests")
    run_unit_tests()

    print("\n✅ All UTF-8 integration tests completed!")
    print("🇫🇷 French localization works correctly!")


def test_utf8_json_encoding():
    """Test UTF-8 encoding with json.dumps(ensure_ascii=False)."""
    print("   Testing UTF-8 JSON encoding...")

    # Test data with French characters and emojis
    test_data = {
        "analyse": {
            "statut": "terminée",
            "résultat": "Aucun problème critique détecté",
            "recommandations": [
                "Améliorer la documentation",
                "Optimiser les performances",
                "Ajouter des tests unitaires",
            ],
            "métadonnées": {
                "créé_par": "Développeur Principal",
                "date_création": "2024-01-01",
                "dernière_modification": "2024-01-15",
            },
            "émojis_status": {
                "critique": "🔴",
                "élevé": "🟠",
                "moyen": "🟡",
                "faible": "🟢",
                "succès": "✅",
                "erreur": "❌",
            },
        },
        "outils": [
            {"nom": "analyse", "description": "Analyse architecturale avancée"},
            {"nom": "révision", "description": "Révision de code automatisée"},
            {"nom": "génération", "description": "Génération de documentation"},
        ],
    }

    # Test with ensure_ascii=False
    json_correct = json.dumps(test_data, ensure_ascii=False, indent=2)

    # Checks
    utf8_terms = [
        "terminée",
        "résultat",
        "détecté",
        "Améliorer",
        "créé_par",
        "Développeur",
        "création",
        "métadonnées",
        "dernière",
        "émojis_status",
        "élevé",
        "révision",
        "génération",
    ]

    emojis = ["🔴", "🟠", "🟡", "🟢", "✅", "❌"]

    for term in utf8_terms:
        assert term in json_correct, f"Missing UTF-8 term: {term}"

    for emoji in emojis:
        assert emoji in json_correct, f"Missing emoji: {emoji}"

    # Check for escaped characters
    assert "\\u" not in json_correct, "Escaped Unicode characters detected!"

    # Test parsing
    parsed = json.loads(json_correct)
    assert parsed["analyse"]["statut"] == "terminée"
    assert parsed["analyse"]["émojis_status"]["critique"] == "🔴"

    print("   ✅ UTF-8 JSON encoding: SUCCESS")


def test_language_instruction_generation():
    """Test language instruction generation."""
    print("   Testing language instruction generation...")

    # Simulation of get_language_instruction
    def get_language_instruction():
        locale = os.getenv("LOCALE", "").strip()
        if not locale:
            return ""
        return f"Always respond in {locale}.\n\n"

    # Test with different locales
    test_locales = [
        ("fr-FR", "French"),
        ("en-US", "English"),
        ("es-ES", "Spanish"),
        ("de-DE", "German"),
        ("", "none"),
    ]

    for locale, description in test_locales:
        os.environ["LOCALE"] = locale
        instruction = get_language_instruction()

        if locale:
            assert locale in instruction, f"Missing {locale} in instruction"
            assert instruction.endswith("\n\n"), "Incorrect instruction format"
            print(f"     📍 {description}: {instruction.strip()}")
        else:
            assert instruction == "", "Empty instruction expected for empty locale"
            print(f"     📍 {description}: (empty)")

    # Restore French locale
    os.environ["LOCALE"] = "fr-FR"
    print("   ✅ Language instruction generation: SUCCESS")


def test_file_utf8_handling():
    """Test handling of files with UTF-8 content."""
    print("   Testing UTF-8 file handling...")

    # File content with French characters
    french_content = '''#!/usr/bin/env python3
"""
Module de gestion des préférences utilisateur.
Développé par: Équipe Technique
Date de création: 15 décembre 2024
"""

import json
from typing import Dict, Optional

class GestionnairePreferences:
    """Gestionnaire des préférences utilisateur avec support UTF-8."""

    def __init__(self):
        self.données = {}
        self.historique = []

    def définir_préférence(self, clé: str, valeur) -> bool:
        """
        Définit une préférence utilisateur.

        Args:
            clé: Identifiant de la préférence
            valeur: Valeur à enregistrer

        Returns:
            True si la préférence a été définie avec succès
        """
        try:
            self.données[clé] = valeur
            self.historique.append({
                "action": "définition",
                "clé": clé,
                "horodatage": "2024-01-01T12:00:00Z"
            })
            return True
        except Exception as e:
            print(f"Error setting preference: {e}")
            return False

    def obtenir_préférence(self, clé: str) -> Optional:
        """Récupère une préférence par sa clé."""
        return self.données.get(clé)

    def exporter_données(self) -> str:
        """Exporte les données en JSON UTF-8."""
        return json.dumps(self.données, ensure_ascii=False, indent=2)

# Configuration par défaut avec caractères UTF-8
CONFIG_DÉFAUT = {
    "langue": "français",
    "région": "France",
    "thème": "sombre",
    "notifications": "activées"
}

def créer_gestionnaire() -> GestionnairePreferences:
    """Crée une instance du gestionnaire."""
    gestionnaire = GestionnairePreferences()

    # Application de la configuration par défaut
    for clé, valeur in CONFIG_DÉFAUT.items():
        gestionnaire.définir_préférence(clé, valeur)

    return gestionnaire

if __name__ == "__main__":
    # Test d'utilisation
    gestionnaire = créer_gestionnaire()
    print("Gestionnaire créé avec succès! 🎉")
    print(f"Données: {gestionnaire.exporter_données()}")
'''

    # Test writing and reading UTF-8
    with tempfile.NamedTemporaryFile(mode="w", encoding="utf-8", suffix=".py", delete=False) as f:
        f.write(french_content)
        temp_file = f.name

    try:
        # Test reading
        with open(temp_file, encoding="utf-8") as f:
            read_content = f.read()

        # Checks
        assert read_content == french_content, "Altered UTF-8 content"

        # Check specific terms
        utf8_terms = [
            "préférences",
            "Développé",
            "Équipe",
            "création",
            "données",
            "définir_préférence",
            "horodatage",
            "Récupère",
            "français",
            "activées",
            "créer_gestionnaire",
            "succès",
        ]

        for term in utf8_terms:
            assert term in read_content, f"Missing UTF-8 term: {term}"

        print("   ✅ UTF-8 file handling: SUCCESS")

    finally:
        # Cleanup
        os.unlink(temp_file)


def test_mcp_tools_integration():
    """Test MCP tools integration with UTF-8."""
    print("   Testing MCP tools integration...")

    # Simulation of MCP tool response
    def simulate_mcp_tool_response():
        """Simulate MCP tool response with UTF-8 content."""
        response_data = {
            "status": "success",
            "content_type": "markdown",
            "content": """# Analyse Terminée avec Succès ✅

## Résumé de l'Analyse

L'analyse architecturale du projet a été **terminée** avec succès. Voici les principaux résultats :

### 🎯 Objectifs Atteints
- ✅ Révision complète du code
- ✅ Identification des problèmes de performance
- ✅ Recommandations d'amélioration générées

### 📊 Métriques Analysées
| Métrique | Valeur | Statut |
|----------|--------|--------|
| Complexité cyclomatique | 12 | 🟡 Acceptable |
| Couverture de tests | 85% | 🟢 Bon |
| Dépendances externes | 23 | 🟠 À réviser |

### 🔍 Problèmes Identifiés

#### 🔴 Critique
Aucun problème critique détecté.

#### 🟠 Élevé
1. **Performance des requêtes** : Optimisation nécessaire
2. **Gestion mémoire** : Fuites potentielles détectées

#### 🟡 Moyen
1. **Documentation** : Certaines fonctions manquent de commentaires
2. **Tests unitaires** : Couverture à améliorer

### � Détails de l'Analyse

Pour plus de détails sur chaque problème identifié, consultez les recommandations ci-dessous.

### �🚀 Recommandations Prioritaires

1. **Optimisation DB** : Implémenter un cache Redis
2. **Refactoring** : Séparer les responsabilités
3. **Documentation** : Ajouter les docstrings manquantes
4. **Tests** : Augmenter la couverture à 90%+

### 📈 Prochaines Étapes

- [ ] Implémenter le système de cache
- [ ] Refactorer les modules identifiés
- [ ] Compléter la documentation
- [ ] Exécuter les tests de régression

---
*Analyse générée automatiquement par MCP PAL* 🤖
""",
            "metadata": {
                "tool_name": "analyze",
                "execution_time": 2.5,
                "locale": "fr-FR",
                "timestamp": "2024-01-01T12:00:00Z",
                "analysis_summary": {
                    "files_analyzed": 15,
                    "issues_found": 4,
                    "recommendations": 4,
                    "overall_score": "B+ (Good level)",
                },
            },
            "continuation_offer": {
                "continuation_id": "analysis-123",
                "note": "In-depth analysis available with more details",
            },
        }

        # Serialization with ensure_ascii=False
        json_response = json.dumps(response_data, ensure_ascii=False, indent=2)

        # UTF-8 checks
        utf8_checks = [
            "Terminée",
            "Succès",
            "Résumé",
            "terminée",
            "Atteints",
            "Révision",
            "problèmes",
            "générées",
            "Métriques",
            "Identifiés",
            "détecté",
            "Élevé",
            "nécessaire",
            "détectées",
            "améliorer",
            "Prioritaires",
            "responsabilités",
            "Étapes",
            "régression",
            "générée",
            "détails",
        ]

        for term in utf8_checks:
            assert term in json_response, f"Missing UTF-8 term: {term}"

        # Emoji check
        emojis = ["✅", "🎯", "📊", "🟡", "🟢", "🟠", "🔍", "🔴", "🚀", "📈", "🤖"]
        for emoji in emojis:
            assert emoji in json_response, f"Missing emoji: {emoji}"

        # Test parsing
        parsed = json.loads(json_response)
        assert parsed["status"] == "success"
        assert "Terminée" in parsed["content"]
        assert parsed["metadata"]["locale"] == "fr-FR"

        return json_response

    # Test simulation
    response = simulate_mcp_tool_response()
    assert len(response) > 1000, "MCP response too short"

    print("   ✅ MCP tools integration: SUCCESS")


def run_unit_tests():
    """Run unit tests."""
    print("   Running unit tests...")

    # List of test files to run
    test_files = ["test_utf8_localization.py", "test_provider_utf8.py", "test_workflow_utf8.py"]

    current_dir = Path(__file__).parent
    test_results = []

    for test_file in test_files:
        test_path = current_dir / test_file
        if test_path.exists():
            print(f"     📝 Running {test_file}...")
            try:
                # Test execution
                result = subprocess.run(
                    [sys.executable, "-m", "unittest", test_file.replace(".py", ""), "-v"],
                    cwd=current_dir,
                    capture_output=True,
                    text=True,
                    timeout=60,
                )

                if result.returncode == 0:
                    print(f"     ✅ {test_file}: SUCCESS")
                    test_results.append((test_file, "SUCCESS"))
                else:
                    print(f"     ❌ {test_file}: FAILURE")
                    print(f"        Error: {result.stderr[:200]}...")
                    test_results.append((test_file, "FAILURE"))

            except subprocess.TimeoutExpired:
                print(f"     ⏰ {test_file}: TIMEOUT")
                test_results.append((test_file, "TIMEOUT"))
            except Exception as e:
                print(f"     💥 {test_file}: ERROR - {e}")
                test_results.append((test_file, "ERROR"))
        else:
            print(f"     ⚠️ {test_file}: NOT FOUND")
            test_results.append((test_file, "NOT FOUND"))

    # Test summary
    print("\n   📋 Unit test summary:")
    for test_file, status in test_results:
        status_emoji = {"SUCCESS": "✅", "FAILURE": "❌", "TIMEOUT": "⏰", "ERROR": "💥", "NOT FOUND": "⚠️"}.get(
            status, "❓"
        )
        print(f"     {status_emoji} {test_file}: {status}")


def main():
    """Main function."""
    print("🇫🇷 UTF-8 Integration Test - PAL MCP Server")
    print("=" * 60)

    try:
        run_utf8_integration_tests()
        print("\n🎉 SUCCESS: All UTF-8 integration tests passed!")
        print("🚀 PAL MCP Server fully supports French localization!")
        return 0

    except AssertionError as e:
        print(f"\n❌ FAILURE: Assertion test failed: {e}")
        return 1

    except Exception as e:
        print(f"\n💥 ERROR: Unexpected exception: {e}")
        return 1


if __name__ == "__main__":
    sys.exit(main())
