"""
ÈwéBench — Benchmark de référence pour l'évaluation de LLMs en langue Ewe.

Catégories d'évaluation:
1. Compréhension linguistique (grammaire, vocabulaire, tonalité)
2. Génération de texte (fluence, cohérence, naturel)
3. Raisonnement logique en Ewe
4. Traduction bidirectionnelle (Français↔Ewe, Anglais↔Ewe)
5. Connaissance culturelle (proverbes, traditions, histoire)
6. Suivi d'instructions complexes
7. Conversation multi-tour
8. Capacités agentiques (function calling)
9. Adaptation stylistique
10. Robustesse et cohérence

Métriques:
- Score par catégorie (0-100)
- Score global pondéré (ÈwéScore)
- BLEU/ROUGE pour la génération
- Accuracy pour le QA
- F1 pour la classification
- Human-eval score (optionnel)
"""

import json
import os
import time
import re
from pathlib import Path
from datetime import datetime
from typing import Optional
import requests

BENCHMARK_DIR = Path(__file__).parent
TESTS_DIR = BENCHMARK_DIR / "tests"
RESULTS_DIR = BENCHMARK_DIR / "results"


class EweBench:
    """Moteur principal du benchmark ÈwéBench."""

    VERSION = "1.0.0"

    CATEGORIES = {
        "linguistic_comprehension": {
            "name": "Compréhension Linguistique",
            "weight": 0.15,
            "description": "Grammaire, vocabulaire, tons, morphologie de l'Ewe"
        },
        "text_generation": {
            "name": "Génération de Texte",
            "weight": 0.15,
            "description": "Fluence, cohérence, naturel du texte généré en Ewe"
        },
        "reasoning": {
            "name": "Raisonnement Logique",
            "weight": 0.12,
            "description": "Capacité de raisonnement exprimée en Ewe"
        },
        "translation": {
            "name": "Traduction Bidirectionnelle",
            "weight": 0.12,
            "description": "Qualité de traduction FR↔Ewe et EN↔Ewe"
        },
        "cultural_knowledge": {
            "name": "Connaissance Culturelle",
            "weight": 0.10,
            "description": "Proverbes, traditions, histoire Ewe et togolaise"
        },
        "instruction_following": {
            "name": "Suivi d'Instructions",
            "weight": 0.10,
            "description": "Respect précis d'instructions complexes"
        },
        "multi_turn": {
            "name": "Conversation Multi-Tour",
            "weight": 0.08,
            "description": "Cohérence et contexte sur plusieurs échanges"
        },
        "agentic": {
            "name": "Capacités Agentiques",
            "weight": 0.08,
            "description": "Function calling, planification, chaînage d'outils"
        },
        "style_adaptation": {
            "name": "Adaptation Stylistique",
            "weight": 0.05,
            "description": "Registres formel/informel, technique/simple"
        },
        "robustness": {
            "name": "Robustesse",
            "weight": 0.05,
            "description": "Cohérence face aux ambiguïtés, adversarial inputs"
        }
    }

    def __init__(self, model_endpoint: str, model_name: str, api_key: Optional[str] = None,
                 headers: Optional[dict] = None):
        self.model_endpoint = model_endpoint
        self.model_name = model_name
        self.api_key = api_key
        self.headers = headers or {}
        self.results = {}
        self.run_id = datetime.now().strftime("%Y%m%d_%H%M%S")

        if api_key and "Authorization" not in self.headers:
            self.headers["Authorization"] = f"Bearer {api_key}"
        if "Content-Type" not in self.headers:
            self.headers["Content-Type"] = "application/json"

    def query_model(self, messages: list, temperature: float = 0.3, max_tokens: int = 1024) -> str:
        """Envoie une requête au modèle et retourne la réponse."""
        payload = {
            "model": self.model_name,
            "messages": messages,
            "temperature": temperature,
            "max_tokens": max_tokens
        }

        try:
            resp = requests.post(
                self.model_endpoint,
                headers=self.headers,
                json=payload,
                timeout=60
            )
            resp.raise_for_status()
            data = resp.json()
            return data["choices"][0]["message"]["content"]
        except Exception as e:
            return f"[ERROR] {str(e)}"

    def load_test_suite(self, category: str) -> list:
        """Charge les tests d'une catégorie depuis le fichier JSON."""
        test_file = TESTS_DIR / f"{category}.json"
        if not test_file.exists():
            return []
        with open(test_file, "r", encoding="utf-8") as f:
            return json.load(f)

    def evaluate_exact_match(self, expected: str, response: str) -> float:
        """Score par correspondance exacte (normalisée)."""
        expected_norm = expected.strip().lower()
        response_norm = response.strip().lower()
        return 1.0 if expected_norm == response_norm else 0.0

    def evaluate_contains(self, expected_keywords: list, response: str) -> float:
        """Score par présence de mots-clés attendus."""
        response_lower = response.lower()
        found = sum(1 for kw in expected_keywords if kw.lower() in response_lower)
        return found / len(expected_keywords) if expected_keywords else 0.0

    def evaluate_multiple_choice(self, correct_answer: str, response: str) -> float:
        """Score pour les QCM (détecte la lettre de réponse)."""
        response_clean = response.strip().upper()
        correct = correct_answer.strip().upper()

        if correct in response_clean[:5]:
            return 1.0
        patterns = [
            rf'\b{correct}\b',
            rf'{correct}\)',
            rf'{correct}\.',
            rf'réponse.*{correct}',
        ]
        for p in patterns:
            if re.search(p, response_clean):
                return 1.0
        return 0.0

    def evaluate_format_compliance(self, expected_format: dict, response: str) -> float:
        """Vérifie la conformité au format demandé."""
        score = 0.0
        checks = 0

        if "contains_ewe" in expected_format:
            ewe_markers = ["ɖe", "nye", "wò", "mí", "ɛ", "ɔ", "ƒe", "kple", "dzi", "le"]
            has_ewe = any(m in response.lower() for m in ewe_markers)
            score += 1.0 if has_ewe else 0.0
            checks += 1

        if "min_length" in expected_format:
            score += 1.0 if len(response) >= expected_format["min_length"] else 0.0
            checks += 1

        if "max_length" in expected_format:
            score += 1.0 if len(response) <= expected_format["max_length"] else 0.0
            checks += 1

        if "contains_function_call" in expected_format:
            has_fc = "<function_call>" in response
            score += 1.0 if has_fc else 0.0
            checks += 1

        if "markdown_elements" in expected_format:
            md_checks = expected_format["markdown_elements"]
            md_found = 0
            if "table" in md_checks and "|" in response and "---" in response:
                md_found += 1
            if "header" in md_checks and re.search(r'^#{1,3}\s', response, re.MULTILINE):
                md_found += 1
            if "list" in md_checks and re.search(r'^[\-\*]\s', response, re.MULTILINE):
                md_found += 1
            if "bold" in md_checks and "**" in response:
                md_found += 1
            score += md_found / len(md_checks) if md_checks else 0.0
            checks += 1

        return score / checks if checks > 0 else 0.0

    def evaluate_ewe_quality(self, response: str) -> float:
        """Évalue la qualité linguistique Ewe (heuristique)."""
        if not response or response.startswith("[ERROR]"):
            return 0.0

        score = 0.0

        ewe_chars = set("ɖɛɔƒŋɣ")
        has_ewe_chars = any(c in response for c in ewe_chars)
        if has_ewe_chars:
            score += 0.3

        ewe_common = ["nye", "wò", "mí", "ɖe", "le", "kple", "dzi", "ƒe", "gbɔ",
                      "aɖe", "ame", "esia", "eya", "mele", "woɖo", "afi", "nyo"]
        words_found = sum(1 for w in ewe_common if w in response.lower())
        score += min(0.4, words_found * 0.05)

        french_words = ["le", "la", "les", "de", "du", "des", "un", "une", "est", "sont",
                       "pour", "dans", "avec", "cette", "voici"]
        french_count = sum(1 for w in french_words
                         if re.search(rf'\b{w}\b', response.lower()))
        if french_count > 5:
            score -= 0.2

        sentences = response.split('.')
        if len(sentences) > 1:
            score += 0.2

        if len(response) > 20:
            score += 0.1

        return max(0.0, min(1.0, score))

    def run_category(self, category: str, verbose: bool = False) -> dict:
        """Exécute tous les tests d'une catégorie."""
        tests = self.load_test_suite(category)
        if not tests:
            return {"score": 0.0, "total": 0, "passed": 0, "details": [], "skipped": True}

        results = []
        total_score = 0.0

        for i, test in enumerate(tests):
            if "messages" in test:
                messages = test["messages"]
            else:
                messages = [
                    {"role": "system", "content": test.get("system", "Tu es Yawo, un assistant IA qui répond en Ewe.")},
                    {"role": "user", "content": test["prompt"]}
                ]

            response = self.query_model(messages, temperature=test.get("temperature", 0.3))

            eval_method = test.get("eval_method", "keywords")

            if eval_method == "exact_match":
                score = self.evaluate_exact_match(test["expected"], response)
            elif eval_method == "multiple_choice":
                score = self.evaluate_multiple_choice(test["expected"], response)
            elif eval_method == "keywords":
                score = self.evaluate_contains(test.get("expected_keywords", []), response)
            elif eval_method == "format":
                score = self.evaluate_format_compliance(test.get("expected_format", {}), response)
            elif eval_method == "ewe_quality":
                score = self.evaluate_ewe_quality(response)
            elif eval_method == "composite":
                s1 = self.evaluate_contains(test.get("expected_keywords", []), response)
                s2 = self.evaluate_ewe_quality(response)
                s3 = self.evaluate_format_compliance(test.get("expected_format", {}), response)
                score = (s1 + s2 + s3) / 3
            else:
                score = self.evaluate_ewe_quality(response)

            total_score += score
            result_entry = {
                "test_id": test.get("id", f"{category}_{i}"),
                "score": round(score, 3),
                "response_preview": response[:200] if not verbose else response
            }
            results.append(result_entry)

            if verbose:
                status = "✓" if score >= 0.7 else "✗"
                print(f"  {status} [{i+1}/{len(tests)}] {test.get('id', f'test_{i}')}: {score:.2f}")

        avg_score = total_score / len(tests) if tests else 0.0

        return {
            "score": round(avg_score * 100, 1),
            "total": len(tests),
            "passed": sum(1 for r in results if r["score"] >= 0.7),
            "details": results,
            "skipped": False
        }

    def run_full_benchmark(self, verbose: bool = True) -> dict:
        """Exécute le benchmark complet sur toutes les catégories."""
        print(f"\n{'='*60}")
        print(f"  ÈwéBench v{self.VERSION} — Benchmark d'évaluation LLM en Ewe")
        print(f"  Modèle: {self.model_name}")
        print(f"  Date: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        print(f"{'='*60}\n")

        category_results = {}
        ewe_score_weighted = 0.0

        for cat_key, cat_info in self.CATEGORIES.items():
            print(f"\n▸ {cat_info['name']} (poids: {cat_info['weight']*100:.0f}%)")
            print(f"  {cat_info['description']}")

            result = self.run_category(cat_key, verbose=verbose)
            category_results[cat_key] = result

            if result["skipped"]:
                print(f"  ⚠ Aucun test trouvé — catégorie ignorée")
            else:
                weighted = result["score"] * cat_info["weight"]
                ewe_score_weighted += weighted
                print(f"  Score: {result['score']:.1f}/100 ({result['passed']}/{result['total']} tests réussis)")

        active_weight = sum(
            info["weight"] for key, info in self.CATEGORIES.items()
            if not category_results.get(key, {}).get("skipped", True)
        )
        if active_weight > 0:
            ewe_score = ewe_score_weighted / active_weight
        else:
            ewe_score = 0.0

        final_report = {
            "benchmark": "ÈwéBench",
            "version": self.VERSION,
            "run_id": self.run_id,
            "model": self.model_name,
            "endpoint": self.model_endpoint,
            "timestamp": datetime.now().isoformat(),
            "ewe_score": round(ewe_score, 1),
            "categories": category_results,
            "summary": {
                "total_tests": sum(r["total"] for r in category_results.values()),
                "total_passed": sum(r["passed"] for r in category_results.values()),
                "categories_evaluated": sum(1 for r in category_results.values() if not r.get("skipped")),
                "categories_skipped": sum(1 for r in category_results.values() if r.get("skipped")),
            }
        }

        print(f"\n{'='*60}")
        print(f"  ÈwéScore Global: {ewe_score:.1f}/100")
        print(f"  Tests: {final_report['summary']['total_passed']}/{final_report['summary']['total_tests']} réussis")
        print(f"  Catégories évaluées: {final_report['summary']['categories_evaluated']}/10")
        print(f"{'='*60}\n")

        self._save_results(final_report)
        return final_report

    def _save_results(self, report: dict):
        """Sauvegarde les résultats du benchmark."""
        RESULTS_DIR.mkdir(parents=True, exist_ok=True)
        filename = f"ewebench_{self.model_name}_{self.run_id}.json"
        filepath = RESULTS_DIR / filename
        with open(filepath, "w", encoding="utf-8") as f:
            json.dump(report, f, ensure_ascii=False, indent=2)
        print(f"  Résultats sauvegardés: {filepath}")

    def compare_models(self, other_report_path: str) -> dict:
        """Compare les résultats avec un autre modèle."""
        with open(other_report_path, "r", encoding="utf-8") as f:
            other = json.load(f)

        comparison = {
            "model_a": self.model_name,
            "model_b": other["model"],
            "score_a": self.results.get("ewe_score", 0),
            "score_b": other["ewe_score"],
            "categories": {}
        }

        for cat_key in self.CATEGORIES:
            a_score = self.results.get("categories", {}).get(cat_key, {}).get("score", 0)
            b_score = other.get("categories", {}).get(cat_key, {}).get("score", 0)
            comparison["categories"][cat_key] = {
                "model_a": a_score,
                "model_b": b_score,
                "delta": round(a_score - b_score, 1)
            }

        return comparison


def run_quick_eval(endpoint: str, model: str, api_key: str = None):
    """Lance une évaluation rapide (subset de tests)."""
    bench = EweBench(endpoint, model, api_key)
    return bench.run_full_benchmark(verbose=True)


if __name__ == "__main__":
    import argparse

    parser = argparse.ArgumentParser(description="ÈwéBench — Benchmark LLM pour l'Ewe")
    parser.add_argument("--endpoint", required=True, help="URL de l'API du modèle")
    parser.add_argument("--model", required=True, help="Nom du modèle")
    parser.add_argument("--api-key", help="Clé API (optionnel)")
    parser.add_argument("--verbose", action="store_true", help="Affichage détaillé")
    parser.add_argument("--category", help="Évaluer une seule catégorie")

    args = parser.parse_args()

    bench = EweBench(args.endpoint, args.model, args.api_key)

    if args.category:
        result = bench.run_category(args.category, verbose=args.verbose)
        print(json.dumps(result, ensure_ascii=False, indent=2))
    else:
        bench.run_full_benchmark(verbose=args.verbose)