import os
import yaml
from pathlib import Path
import uuid

def init_uuid():
    if not TEMP_SECTIONS.exists():
        TEMP_SECTIONS.mkdir(parents=True)
    session_uuid = str(uuid.uuid4())[:8]  # Utiliser les 8 premiers caractères pour plus de concision
    print(f"🔑 UUID de session généré: {session_uuid}")
    return session_uuid

BASE_DIR = Path(__file__).resolve().parent.parent
CORPUS_DIR = BASE_DIR.parent / "Corpus"
THRESHOLDS_PATH = BASE_DIR.parent / "assets" / "config.yaml"
REFERENCE_GRAPH_PATH = BASE_DIR.parent / "schema.txt"
GRAPH_PATH = BASE_DIR.parent / "graphe.dot"
TEMP_SECTIONS = BASE_DIR / "temp_sections"
session_uuid = init_uuid()
TEMPLATE_PATH = TEMP_SECTIONS / f"rapport_final - {session_uuid}.md"

PGPT_URL = "http://127.0.0.1:8001"
API_URL = f"{PGPT_URL}/v1"
PROMPT_METHODOLOGIE = """
Le rapport à examiner a été établi à partir de la méthodologie suivante.

Le dispositif d’évaluation des risques proposé repose sur quatre indices clairement définis, chacun analysant un aspect spécifique des risques dans la chaîne d’approvisionnement numérique. L’indice IHH mesure la concentration géographique ou industrielle, permettant d’évaluer la dépendance vis-à-vis de certains acteurs ou régions. L’indice ISG indique la stabilité géopolitique des pays impliqués dans la chaîne de production, en intégrant des critères politiques, sociaux et climatiques. L’indice ICS quantifie la facilité ou la difficulté à remplacer ou substituer un élément spécifique dans la chaîne, évaluant ainsi les risques liés à la dépendance technologique et économique. Enfin, l’indice IVC examine la pression concurrentielle sur les ressources utilisées par le numérique, révélant ainsi le risque potentiel que ces ressources soient détournées vers d’autres secteurs industriels.

Ces indices se combinent judicieusement par paires pour une évaluation approfondie et pertinente des risques. La combinaison IHH-ISG permet d’associer la gravité d'un impact potentiel (IHH) à la probabilité de survenance d’un événement perturbateur (ISG), créant ainsi une matrice de vulnérabilité combinée utile pour identifier rapidement les points critiques dans la chaîne de production. La combinaison ICS-IVC fonctionne selon la même logique, mais se concentre spécifiquement sur les ressources minérales : l’ICS indique la gravité potentielle d'une rupture d'approvisionnement due à une faible substituabilité, tandis que l’IVC évalue la probabilité que les ressources soient captées par d'autres secteurs industriels concurrents. Ces combinaisons permettent d’obtenir une analyse précise et opérationnelle du niveau de risque global.

Les avantages de cette méthodologie résident dans son approche à la fois systématique et granulaire, adaptée à l'échelle décisionnelle d'un COMEX. Elle permet d’identifier avec précision les vulnérabilités majeures et leurs origines spécifiques, facilitant ainsi la prise de décision stratégique éclairée et proactive. En combinant des facteurs géopolitiques, industriels, technologiques et concurrentiels, ces indices offrent un suivi efficace de la chaîne de fabrication numérique, garantissant ainsi une gestion optimale des risques et la continuité opérationnelle à long terme.
"""

DICTIONNAIRE_CRITICITES = {
    "IHH": {"vert": "Faible", "orange": "Modérée", "rouge": "Élevée"},
    "ISG": {"vert": "Stable", "orange": "Intermédiaire", "rouge": "Instable"},
    "ICS": {"vert": "Facile", "orange": "Moyenne", "rouge": "Difficile"},
    "IVC": {"vert": "Faible", "orange": "Modérée", "rouge": "Forte"}
}
POIDS_COULEURS = {
    "Vert": 1,
    "Orange": 2,
    "Rouge": 3
}

def load_config(thresholds_path=THRESHOLDS_PATH):
    """Charge la configuration depuis les fichiers YAML."""
    config = {}
    # Charger les seuils
    if os.path.exists(thresholds_path):
        with open(thresholds_path, 'r', encoding='utf-8') as f:
            thresholds = yaml.safe_load(f)
            config['thresholds'] = thresholds.get('seuils', {})
    return config

def determine_threshold_color(value, index_type, thresholds):
    """
    Détermine la couleur du seuil en fonction du type d'indice et de sa valeur.
    Utilise les seuils de config.yaml si disponibles.
    """

    # Récupérer les seuils pour cet indice
    if index_type in thresholds:
        index_thresholds = thresholds[index_type]
        # Déterminer la couleur
        if "vert" in index_thresholds and "max" in index_thresholds["vert"] and \
           index_thresholds["vert"]["max"] is not None and value < index_thresholds["vert"]["max"]:
            suffix = get_suffix_for_index(index_type, "vert")
            return "Vert", suffix
        elif "orange" in index_thresholds and "min" in index_thresholds["orange"] and "max" in index_thresholds["orange"] and \
             index_thresholds["orange"]["min"] is not None and index_thresholds["orange"]["max"] is not None and \
             index_thresholds["orange"]["min"] <= value < index_thresholds["orange"]["max"]:
            suffix = get_suffix_for_index(index_type, "orange")
            return "Orange", suffix
        elif "rouge" in index_thresholds and "min" in index_thresholds["rouge"] and \
             index_thresholds["rouge"]["min"] is not None and value >= index_thresholds["rouge"]["min"]:
            suffix = get_suffix_for_index(index_type, "rouge")
            return "Rouge", suffix

    return "Non déterminé", ""

def get_suffix_for_index(index_type, color):
    """Retourne le suffixe approprié pour chaque indice et couleur."""
    suffixes = DICTIONNAIRE_CRITICITES

    if index_type in suffixes and color in suffixes[index_type]:
        return suffixes[index_type][color]
    return ""

def get_weight_for_color(color):
    """Retourne le poids correspondant à une couleur."""
    weights = POIDS_COULEURS
    return weights.get(color, 0)
