Aethero_App/introspective_parser_module/metrics.py

# AETH-CRITICAL-2025-0002 :: EMERGENCY REPAIR :: ROLE: Lucius :: PRODUCTION-READY IMPLEMENTATION
# filepath: /Users/_xvadur/Desktop/Aethero_github/Aethero_App/introspective_parser_module/metrics.py
# 
# AetheroCognitiveAnalyzer - Produkčná implementácia kognitívnej analýzy
# Implementované pod prezidentskou autoritou pre kritické opravy systému

from typing import List, Dict, Any, Optional, Tuple, Union
from datetime import datetime, timedelta
import statistics
import json
import math
import logging
from dataclasses import dataclass, asdict
from enum import Enum
from .models import ASLCognitiveTag, MentalStateEnum, EmotionToneEnum, TemporalContextEnum

# AETH-TASK-003 :: ROLE: Lucius :: GOAL: Production-ready cognitive metrics
logger = logging.getLogger(__name__)

@dataclass
class CognitiveMetrics:
    """Štruktúra pre kognitívne metriky s plnou introspekciou"""
    consciousness_coherence_rate: float
    cognitive_complexity_index: float
    mental_stability_factor: float
    emotional_resonance_depth: float
    temporal_awareness_level: float
    introspective_clarity_score: float
    overall_cognitive_health: float
    analysis_timestamp: str
    session_id: str
    
    def to_dict(self) -> Dict[str, Any]:
        """Konverzia na dictionary pre JSON serialization"""
        return asdict(self)

class CognitiveAnalysisMode(Enum):
    """Režimy kognitívnej analýzy"""
    STANDARD = "standard"
    DEEP_INTROSPECTION = "deep_introspection" 
    REAL_TIME = "real_time"
    BATCH_ANALYSIS = "batch_analysis"
    EMERGENCY_ASSESSMENT = "emergency_assessment"

class AetheroCognitiveAnalyzer:
class AetheroCognitiveAnalyzer:
    """
    AETH-CRITICAL-2025-0002 :: Produkčný kognitívny analyzátor
    
    Hlavný analyzátor pre introspektívnu kognitívnu analýzu ASL tagov
    s pokročilými metrikami vedomia, emócií a temporálneho kontextu.
    
    Implementuje prezidentskú víziju holistickej kognitívnej analýzy
    pre systém Aethero s plnou produkčnou podporou.
    """
    
    def __init__(self, analysis_mode: CognitiveAnalysisMode = CognitiveAnalysisMode.STANDARD):
        """
        Inicializácia produkčného kognitívnego analyzátora
        
        Args:
            analysis_mode: Režim analýzy (STANDARD, DEEP_INTROSPECTION, atď.)
        """
        self.analysis_mode = analysis_mode
        self.session_id = f"aethero_cognitive_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
        self.analysis_history: List[CognitiveMetrics] = []
        self.cognitive_flow_patterns = []
        self.mental_state_transitions = []
        
        # Pokročilé konfiguračné parametre
        self.coherence_threshold = 0.7
        self.complexity_scaling_factor = 1.2
        self.temporal_weight_decay = 0.95
        
        logger.info(f"AetheroCognitiveAnalyzer initialized in {analysis_mode.value} mode")
    
    def analyze_cognitive_tags(self, cognitive_tags: List[ASLCognitiveTag]) -> CognitiveMetrics:
        """
        INTENT: Komplexná analýza kognitívnych tagov
        ACTION: Výpočet všetkých kognitívnych metrík
        OUTPUT: Štruktúrované kognitívne metriky
        HOOK: cognitive_analysis_completed
        
        Args:
            cognitive_tags: Zoznam validovaných ASL kognitívnych tagov
            
        Returns:
            CognitiveMetrics: Kompletné kognitívne metriky
        """
        try:
            if not cognitive_tags:
                logger.warning("Empty cognitive_tags provided to analyzer")
                return self._create_empty_metrics()
            
            logger.info(f"Analyzing {len(cognitive_tags)} cognitive tags in {self.analysis_mode.value} mode")
            
            # Výpočet jednotlivých metrík
            consciousness_coherence = self.calculate_consciousness_coherence_rate(cognitive_tags)
            complexity_index = self.calculate_cognitive_complexity_index(cognitive_tags)
            stability_factor = self.calculate_mental_stability_factor(cognitive_tags)
            resonance_depth = self.calculate_emotional_resonance_depth(cognitive_tags)
            temporal_awareness = self.calculate_temporal_awareness_level(cognitive_tags)
            introspective_clarity = self.calculate_introspective_clarity_score(cognitive_tags)
            
            # Výpočet celkového kognitívneho zdravia
            overall_health = self._calculate_overall_cognitive_health(
                consciousness_coherence, complexity_index, stability_factor,
                resonance_depth, temporal_awareness, introspective_clarity
            )
            
            # Vytvorenie metrík
            metrics = CognitiveMetrics(
                consciousness_coherence_rate=consciousness_coherence,
                cognitive_complexity_index=complexity_index,
                mental_stability_factor=stability_factor,
                emotional_resonance_depth=resonance_depth,
                temporal_awareness_level=temporal_awareness,
                introspective_clarity_score=introspective_clarity,
                overall_cognitive_health=overall_health,
                analysis_timestamp=datetime.now().isoformat(),
                session_id=self.session_id
            )
            
            # Uloženie do histórie
            self.analysis_history.append(metrics)
            self._update_cognitive_patterns(cognitive_tags, metrics)
            
            logger.info(f"Cognitive analysis completed - Overall health: {overall_health:.3f}")
            return metrics
            
        except Exception as e:
            logger.error(f"Error in cognitive analysis: {str(e)}")
            return self._create_error_metrics(str(e))
    
    def calculate_consciousness_coherence_rate(self, cognitive_tags: List[ASLCognitiveTag]) -> float:
        """
        INTENT: Výpočet miery koherencie vedomia
        ACTION: Analýza konzistencie medzi kognitívnymi komponentmi
        OUTPUT: Normalizovaná miera koherencie (0.0-1.0)
        HOOK: consciousness_coherence_calculated
        """
        if not cognitive_tags:
            return 0.0
        
        coherence_scores = []
        
        for tag in cognitive_tags:
            # Koherencia mentálneho stavu a emócie
            mental_emotion_coherence = self._assess_mental_emotion_coherence(
                tag.mental_state, tag.emotion_tone
            )
            
            # Koherencia kognitívnej záťaže a istoty
            load_certainty_coherence = self._assess_load_certainty_coherence(
                tag.cognitive_load, tag.certainty_level
            )
            
            # Temporálna koherencia
            temporal_coherence = self._assess_temporal_coherence(
                tag.temporal_context, tag.cognitive_load
            )
            
            # Introspektívna koherencia
            introspective_coherence = self._assess_introspective_coherence(tag)
            
            # Váhovaný priemer koherencie
            tag_coherence = (
                mental_emotion_coherence * 0.3 +
                load_certainty_coherence * 0.25 +
                temporal_coherence * 0.25 +
                introspective_coherence * 0.2
            )
            
            coherence_scores.append(tag_coherence)
        
        # Výpočet celkovej koherencie s penalizáciou za variabilnosť
        mean_coherence = statistics.mean(coherence_scores)
        coherence_variance = statistics.variance(coherence_scores) if len(coherence_scores) > 1 else 0
        
        # Penalizácia za vysokú variabilnosť (nekonzistentnosť)
        variance_penalty = min(coherence_variance * 0.5, 0.3)
        
        return max(0.0, min(1.0, mean_coherence - variance_penalty))
    
    def calculate_cognitive_complexity_index(self, cognitive_tags: List[ASLCognitiveTag]) -> float:
        """
        INTENT: Výpočet indexu kognitívnej komplexnosti
        ACTION: Analýza komplexnosti myšlienkových procesov
        OUTPUT: Index komplexnosti (0.0-1.0)
        HOOK: cognitive_complexity_calculated
        """
        if not cognitive_tags:
            return 0.0
        
        complexity_factors = []
        
        for tag in cognitive_tags:
            # Komplexnosť kognitívnej záťaže
            load_complexity = min(tag.cognitive_load / 10.0, 1.0)
            
            # Komplexnosť na základe mentálneho stavu
            mental_complexity = self._get_mental_state_complexity(tag.mental_state)
            
            # Komplexnosť emočného tónu
            emotion_complexity = self._get_emotion_complexity(tag.emotion_tone)
            
            # Temporálna komplexnosť
            temporal_complexity = self._get_temporal_complexity(tag.temporal_context)
            
            # Nejistota ako faktor komplexnosti
            uncertainty_factor = 1.0 - tag.certainty_level
            
            tag_complexity = (
                load_complexity * 0.3 +
                mental_complexity * 0.25 +
                emotion_complexity * 0.2 +
                temporal_complexity * 0.15 +
                uncertainty_factor * 0.1
            )
            
            complexity_factors.append(tag_complexity)
        
        # Aplikácia scaling faktora pre pokročilé analýzy
        raw_complexity = statistics.mean(complexity_factors)
        scaled_complexity = raw_complexity * self.complexity_scaling_factor
        
        return min(1.0, scaled_complexity)
    
    def calculate_mental_stability_factor(self, cognitive_tags: List[ASLCognitiveTag]) -> float:
        """
        INTENT: Výpočet faktora mentálnej stability
        ACTION: Analýza konzistencie mentálnych stavov
        OUTPUT: Faktor stability (0.0-1.0)
        HOOK: mental_stability_calculated
        """
        if not cognitive_tags:
            return 0.5  # Neutrálna stabilita
        
        # Sledovanie prechodov medzi mentálnymi stavmi
        mental_states = [tag.mental_state for tag in cognitive_tags]
        
        if len(set(mental_states)) == 1:
            # Úplná konzistencia - vysoká stabilita
            base_stability = 0.9
        else:
            # Výpočet stability na základe prechodov
            transitions = self._count_mental_state_transitions(mental_states)
            max_possible_transitions = len(mental_states) - 1
            
            if max_possible_transitions > 0:
                transition_ratio = transitions / max_possible_transitions
                base_stability = 1.0 - (transition_ratio * 0.6)
            else:
                base_stability = 0.9
        
        # Úprava na základe kognitívnej záťaže
        avg_load = statistics.mean([tag.cognitive_load for tag in cognitive_tags])
        load_factor = 1.0 - min(avg_load / 15.0, 0.3)  # Vysoká záťaž znižuje stabilitu
        
        # Úprava na základe istoty
        avg_certainty = statistics.mean([tag.certainty_level for tag in cognitive_tags])
        certainty_factor = avg_certainty * 0.2 + 0.8  # Istota zvyšuje stabilitu
        
        final_stability = base_stability * load_factor * certainty_factor
        return max(0.0, min(1.0, final_stability))
    
    def calculate_emotional_resonance_depth(self, cognitive_tags: List[ASLCognitiveTag]) -> float:
        """
        INTENT: Výpočet hĺbky emočnej rezonancie
        ACTION: Analýza emočnej intenzity a konzistencie
        OUTPUT: Hĺbka emočnej rezonancie (0.0-1.0)
        HOOK: emotional_resonance_calculated
        """
        if not cognitive_tags:
            return 0.0
        
        emotion_scores = []
        
        for tag in cognitive_tags:
            # Základná emočná intenzita
            emotion_intensity = self._get_emotion_intensity(tag.emotion_tone)
            
            # Súlad s mentálnym stavom
            mental_emotion_alignment = self._assess_mental_emotion_coherence(
                tag.mental_state, tag.emotion_tone
            )
            
            # Emočná konzistencia s istotou
            certainty_emotion_alignment = self._assess_certainty_emotion_alignment(
                tag.certainty_level, tag.emotion_tone
            )
            
            tag_resonance = (
                emotion_intensity * 0.4 +
                mental_emotion_alignment * 0.4 +
                certainty_emotion_alignment * 0.2
            )
            
            emotion_scores.append(tag_resonance)
        
        # Výpočet hĺbky s ohľadom na emočnú variabilnosť
        mean_resonance = statistics.mean(emotion_scores)
        
        # Bonifikácia za emočnú hĺbku (nie len intenzitu)
        emotion_variety = len(set(tag.emotion_tone for tag in cognitive_tags))
        variety_bonus = min(emotion_variety * 0.1, 0.2)
        
        return min(1.0, mean_resonance + variety_bonus)
    
    def calculate_temporal_awareness_level(self, cognitive_tags: List[ASLCognitiveTag]) -> float:
        """
        INTENT: Výpočet úrovne temporálneho vedomia
        ACTION: Analýza časového kontextu a sekvencií
        OUTPUT: Úroveň temporálneho vedomia (0.0-1.0)
        HOOK: temporal_awareness_calculated
        """
        if not cognitive_tags:
            return 0.0
        
        temporal_scores = []
        
        for i, tag in enumerate(cognitive_tags):
            # Základná temporálna orientácia
            temporal_orientation = self._get_temporal_orientation_score(tag.temporal_context)
            
            # Temporálna kontinuita (ak máme predchádzajúce tagy)
            if i > 0:
                continuity = self._assess_temporal_continuity(
                    cognitive_tags[i-1], tag
                )
            else:
                continuity = 0.8  # Prvý tag má dobrú kontinuitu
            
            # Temporálna koherencia s kognitívnou záťažou
            load_temporal_coherence = self._assess_load_temporal_coherence(
                tag.cognitive_load, tag.temporal_context
            )
            
            tag_temporal_score = (
                temporal_orientation * 0.4 +
                continuity * 0.3 +
                load_temporal_coherence * 0.3
            )
            
            # Aplikácia váhového rozkladu pre starší kontext
            weight = self.temporal_weight_decay ** i
            temporal_scores.append(tag_temporal_score * weight)
        
        return statistics.mean(temporal_scores) if temporal_scores else 0.0
    
    def calculate_introspective_clarity_score(self, cognitive_tags: List[ASLCognitiveTag]) -> float:
        """
        INTENT: Výpočet skóre introspektívnej jasnosti
        ACTION: Analýza kvality sebapoznania a reflexie
        OUTPUT: Skóre introspektívnej jasnosti (0.0-1.0)
        HOOK: introspective_clarity_calculated
        """
        if not cognitive_tags:
            return 0.0
        
        clarity_scores = []
        
        for tag in cognitive_tags:
            # Jasnosť sebapoznania na základe istoty
            self_awareness_clarity = tag.certainty_level
            
            # Jasnosť mentálnej reflexie
            mental_clarity = self._assess_mental_clarity(tag.mental_state)
            
            # Emočná jasnosť
            emotional_clarity = self._assess_emotional_clarity(tag.emotion_tone)
            
            # Temporálna jasnosť
            temporal_clarity = self._assess_temporal_clarity(tag.temporal_context)
            
            # Kognitívna jasnosť (inverzne úmerná záťaži)
            cognitive_clarity = max(0.0, 1.0 - (tag.cognitive_load / 12.0))
            
            tag_clarity = (
                self_awareness_clarity * 0.25 +
                mental_clarity * 0.25 +
                emotional_clarity * 0.2 +
                temporal_clarity * 0.15 +
                cognitive_clarity * 0.15
            )
            
            clarity_scores.append(tag_clarity)
        
        # Bonus za konzistentnú jasnosť
        clarity_variance = statistics.variance(clarity_scores) if len(clarity_scores) > 1 else 0
        consistency_bonus = max(0.0, 0.1 - clarity_variance)
        
        mean_clarity = statistics.mean(clarity_scores)
        return min(1.0, mean_clarity + consistency_bonus)
    
    
    # =================================================================
    # PRIVATE HELPER METHODS - KOGNITÍVNE HODNOTENIE
    # =================================================================
    
    def _assess_mental_emotion_coherence(self, mental_state: MentalStateEnum, emotion_tone: EmotionToneEnum) -> float:
        """Hodnotenie koherencie medzi mentálnym stavom a emočným tónom"""
        coherence_matrix = {
            MentalStateEnum.CALM: {
                EmotionToneEnum.NEUTRAL: 1.0,
                EmotionToneEnum.POSITIVE: 0.9,
                EmotionToneEnum.EMPATHETIC: 0.9,
                EmotionToneEnum.ANALYTICAL: 0.7,
                EmotionToneEnum.CRITICAL: 0.4,
                EmotionToneEnum.NEGATIVE: 0.2
            },
            MentalStateEnum.FOCUSED: {
                EmotionToneEnum.ANALYTICAL: 1.0,
                EmotionToneEnum.NEUTRAL: 0.9,
                EmotionToneEnum.CRITICAL: 0.8,
                EmotionToneEnum.POSITIVE: 0.7,
                EmotionToneEnum.EMPATHETIC: 0.5,
                EmotionToneEnum.NEGATIVE: 0.3
            },
            MentalStateEnum.CONTEMPLATIVE: {
                EmotionToneEnum.NEUTRAL: 1.0,
                EmotionToneEnum.ANALYTICAL: 0.9,
                EmotionToneEnum.EMPATHETIC: 0.8,
                EmotionToneEnum.CRITICAL: 0.7,
                EmotionToneEnum.POSITIVE: 0.6,
                EmotionToneEnum.NEGATIVE: 0.4
            },
            MentalStateEnum.CONFUSED: {
                EmotionToneEnum.NEGATIVE: 0.8,
                EmotionToneEnum.NEUTRAL: 0.7,
                EmotionToneEnum.CRITICAL: 0.6,
                EmotionToneEnum.ANALYTICAL: 0.5,
                EmotionToneEnum.EMPATHETIC: 0.4,
                EmotionToneEnum.POSITIVE: 0.2
            }
        }
        return coherence_matrix.get(mental_state, {}).get(emotion_tone, 0.5)
    
    def _assess_load_certainty_coherence(self, cognitive_load: int, certainty_level: float) -> float:
        """Hodnotenie koherencie medzi kognitívnou záťažou a úrovňou istoty"""
        # Vysoká záťaž by mala korelovať s nižšou istotou
        expected_certainty = max(0.1, 1.0 - (cognitive_load / 12.0))
        certainty_difference = abs(certainty_level - expected_certainty)
        return max(0.0, 1.0 - certainty_difference)
    
    def _assess_temporal_coherence(self, temporal_context: TemporalContextEnum, cognitive_load: int) -> float:
        """Hodnotenie temporálnej koherencie"""
        temporal_load_coherence = {
            TemporalContextEnum.IMMEDIATE: {
                "low_load": (0, 4, 0.9),
                "medium_load": (4, 8, 0.8),
                "high_load": (8, 12, 0.6)
            },
            TemporalContextEnum.SHORT_TERM: {
                "low_load": (0, 6, 0.8),
                "medium_load": (6, 10, 0.9),
                "high_load": (10, 12, 0.7)
            },
            TemporalContextEnum.LONG_TERM: {
                "low_load": (0, 5, 0.7),
                "medium_load": (5, 9, 0.8),
                "high_load": (9, 12, 0.9)
            }
        }
        
        context_mapping = temporal_load_coherence.get(temporal_context, {})
        for load_category, (min_load, max_load, coherence) in context_mapping.items():
            if min_load <= cognitive_load <= max_load:
                return coherence
        return 0.5
    
    def _assess_introspective_coherence(self, tag: ASLCognitiveTag) -> float:
        """Hodnotenie introspektívnej koherencie tagu"""
        # Komplexná analýza vnútornej konzistencie
        factors = []
        
        # Súlad istoty s komplexnosťou úlohy
        complexity_certainty_coherence = self._assess_complexity_certainty_alignment(tag)
        factors.append(complexity_certainty_coherence)
        
        # Emočná autenticita
        emotional_authenticity = self._assess_emotional_authenticity(tag)
        factors.append(emotional_authenticity)
        
        # Temporálna realistickosť
        temporal_realism = self._assess_temporal_realism(tag)
        factors.append(temporal_realism)
        
        return statistics.mean(factors) if factors else 0.5
    
    def _get_mental_state_complexity(self, mental_state: MentalStateEnum) -> float:
        """Získanie komplexnosti mentálneho stavu"""
        complexity_mapping = {
            MentalStateEnum.CALM: 0.2,
            MentalStateEnum.FOCUSED: 0.6,
            MentalStateEnum.CONTEMPLATIVE: 0.8,
            MentalStateEnum.CONFUSED: 0.9
        }
        return complexity_mapping.get(mental_state, 0.5)
    
    def _get_emotion_complexity(self, emotion_tone: EmotionToneEnum) -> float:
        """Získanie komplexnosti emočného tónu"""
        complexity_mapping = {
            EmotionToneEnum.NEUTRAL: 0.1,
            EmotionToneEnum.POSITIVE: 0.3,
            EmotionToneEnum.NEGATIVE: 0.4,
            EmotionToneEnum.ANALYTICAL: 0.7,
            EmotionToneEnum.CRITICAL: 0.8,
            EmotionToneEnum.EMPATHETIC: 0.9
        }
        return complexity_mapping.get(emotion_tone, 0.5)
    
    def _get_temporal_complexity(self, temporal_context: TemporalContextEnum) -> float:
        """Získanie temporálnej komplexnosti"""
        complexity_mapping = {
            TemporalContextEnum.IMMEDIATE: 0.3,
            TemporalContextEnum.SHORT_TERM: 0.6,
            TemporalContextEnum.LONG_TERM: 0.9
        }
        return complexity_mapping.get(temporal_context, 0.5)
    
    def _count_mental_state_transitions(self, mental_states: List[MentalStateEnum]) -> int:
        """Počítanie prechodov medzi mentálnymi stavmi"""
        transitions = 0
        for i in range(1, len(mental_states)):
            if mental_states[i] != mental_states[i-1]:
                transitions += 1
        return transitions
    
    def _get_emotion_intensity(self, emotion_tone: EmotionToneEnum) -> float:
        """Získanie intenzity emócie"""
        intensity_mapping = {
            EmotionToneEnum.NEUTRAL: 0.1,
            EmotionToneEnum.POSITIVE: 0.7,
            EmotionToneEnum.NEGATIVE: 0.8,
            EmotionToneEnum.ANALYTICAL: 0.5,
            EmotionToneEnum.CRITICAL: 0.9,
            EmotionToneEnum.EMPATHETIC: 0.8
        }
        return intensity_mapping.get(emotion_tone, 0.5)
    
    def _assess_certainty_emotion_alignment(self, certainty_level: float, emotion_tone: EmotionToneEnum) -> float:
        """Hodnotenie súladu istoty s emóciou"""
        # Vysoká istota by mala korelovať s pozitívnymi/neutrálnymi emóciami
        if emotion_tone in [EmotionToneEnum.POSITIVE, EmotionToneEnum.NEUTRAL]:
            return certainty_level
        elif emotion_tone == EmotionToneEnum.NEGATIVE:
            return 1.0 - certainty_level  # Nízka istota súladí s negatívnymi emóciami
        else:
            return 0.7  # Analytické/kritické/empatické emócie sú nezávislé od istoty
    
    def _get_temporal_orientation_score(self, temporal_context: TemporalContextEnum) -> float:
        """Získanie skóre temporálnej orientácie"""
        orientation_mapping = {
            TemporalContextEnum.IMMEDIATE: 0.9,  # Vysoká orientácia v prítomnosti
            TemporalContextEnum.SHORT_TERM: 0.7,  # Dobrá orientácia v blízkej budúcnosti
            TemporalContextEnum.LONG_TERM: 0.6   # Stredná orientácia v dlhodobom kontexte
        }
        return orientation_mapping.get(temporal_context, 0.5)
    
    def _assess_temporal_continuity(self, prev_tag: ASLCognitiveTag, current_tag: ASLCognitiveTag) -> float:
        """Hodnotenie temporálnej kontinuity medzi tagmi"""
        # Logické následnosti v temporálnom kontexte
        continuity_scores = []
        
        # Kontinuita mentálneho stavu
        if prev_tag.mental_state == current_tag.mental_state:
            continuity_scores.append(0.9)
        else:
            # Penalizácia za náhle zmeny
            continuity_scores.append(0.6)
        
        # Kontinuita kognitívnej záťaže
        load_difference = abs(prev_tag.cognitive_load - current_tag.cognitive_load)
        load_continuity = max(0.0, 1.0 - (load_difference / 10.0))
        continuity_scores.append(load_continuity)
        
        # Kontinuita istoty
        certainty_difference = abs(prev_tag.certainty_level - current_tag.certainty_level)
        certainty_continuity = max(0.0, 1.0 - certainty_difference)
        continuity_scores.append(certainty_continuity)
        
        return statistics.mean(continuity_scores) if continuity_scores else 0.5
    
    def _assess_load_temporal_coherence(self, cognitive_load: int, temporal_context: TemporalContextEnum) -> float:
        """Hodnotenie koherencie záťaže s temporálnym kontextom"""
        # Dlhodobé úlohy môžu mať vyššiu záťaž
        if temporal_context == TemporalContextEnum.LONG_TERM:
            return min(1.0, (cognitive_load / 10.0) + 0.3)
        elif temporal_context == TemporalContextEnum.SHORT_TERM:
            return max(0.3, 1.0 - abs(cognitive_load - 6) / 8.0)
        else:  # IMMEDIATE
            return max(0.2, 1.0 - (cognitive_load / 12.0))
    
    def _assess_mental_clarity(self, mental_state: MentalStateEnum) -> float:
        """Hodnotenie jasnosti mentálneho stavu"""
        clarity_mapping = {
            MentalStateEnum.FOCUSED: 0.9,
            MentalStateEnum.CALM: 0.8,
            MentalStateEnum.CONTEMPLATIVE: 0.7,
            MentalStateEnum.CONFUSED: 0.2
        }
        return clarity_mapping.get(mental_state, 0.5)
    
    def _assess_emotional_clarity(self, emotion_tone: EmotionToneEnum) -> float:
        """Hodnotenie emočnej jasnosti"""
        clarity_mapping = {
            EmotionToneEnum.NEUTRAL: 0.9,
            EmotionToneEnum.ANALYTICAL: 0.8,
            EmotionToneEnum.POSITIVE: 0.7,
            EmotionToneEnum.EMPATHETIC: 0.7,
            EmotionToneEnum.CRITICAL: 0.6,
            EmotionToneEnum.NEGATIVE: 0.4
        }
        return clarity_mapping.get(emotion_tone, 0.5)
    
    def _assess_temporal_clarity(self, temporal_context: TemporalContextEnum) -> float:
        """Hodnotenie temporálnej jasnosti"""
        clarity_mapping = {
            TemporalContextEnum.IMMEDIATE: 0.9,
            TemporalContextEnum.SHORT_TERM: 0.7,
            TemporalContextEnum.LONG_TERM: 0.5
        }
        return clarity_mapping.get(temporal_context, 0.5)
    
    # =================================================================
    # POKROČILÉ ANALYTICKÉ METÓDY
    # =================================================================
    
    def _calculate_overall_cognitive_health(self, consciousness_coherence: float, 
                                          complexity_index: float, stability_factor: float,
                                          resonance_depth: float, temporal_awareness: float, 
                                          introspective_clarity: float) -> float:
        """Výpočet celkového kognitívneho zdravia"""
        # Vážené skóre s dôrazom na koherenciu a stabilitu
        weights = {
            'coherence': 0.25,
            'complexity': 0.15,
            'stability': 0.25, 
            'resonance': 0.15,
            'temporal': 0.1,
            'clarity': 0.1
        }
        
        weighted_score = (
            consciousness_coherence * weights['coherence'] +
            complexity_index * weights['complexity'] +
            stability_factor * weights['stability'] +
            resonance_depth * weights['resonance'] +
            temporal_awareness * weights['temporal'] +
            introspective_clarity * weights['clarity']
        )
        
        # Bonus za vyvážené skóre (žiadny extrém)
        scores = [consciousness_coherence, complexity_index, stability_factor, 
                 resonance_depth, temporal_awareness, introspective_clarity]
        score_variance = statistics.variance(scores) if len(scores) > 1 else 0
        balance_bonus = max(0.0, 0.05 - score_variance * 0.1)
        
        return min(1.0, weighted_score + balance_bonus)
    
    def _update_cognitive_patterns(self, cognitive_tags: List[ASLCognitiveTag], metrics: CognitiveMetrics):
        """Aktualizácia kognitívnych vzorov pre dlhodobú analýzu"""
        pattern = {
            'timestamp': metrics.analysis_timestamp,
            'tag_count': len(cognitive_tags),
            'dominant_mental_state': self._get_dominant_mental_state(cognitive_tags),
            'dominant_emotion': self._get_dominant_emotion(cognitive_tags),
            'avg_cognitive_load': statistics.mean([tag.cognitive_load for tag in cognitive_tags]),
            'avg_certainty': statistics.mean([tag.certainty_level for tag in cognitive_tags]),
            'overall_health': metrics.overall_cognitive_health
        }
        
        self.cognitive_flow_patterns.append(pattern)
        
        # Udržiavanie histórie (max 100 vzorov)
        if len(self.cognitive_flow_patterns) > 100:
            self.cognitive_flow_patterns.pop(0)
    
    def _get_dominant_mental_state(self, cognitive_tags: List[ASLCognitiveTag]) -> str:
        """Získanie dominantného mentálneho stavu"""
        if not cognitive_tags:
            return "unknown"
        
        state_counts = {}
        for tag in cognitive_tags:
            state = tag.mental_state.value
            state_counts[state] = state_counts.get(state, 0) + 1
        
        return max(state_counts, key=state_counts.get)
    
    def _get_dominant_emotion(self, cognitive_tags: List[ASLCognitiveTag]) -> str:
        """Získanie dominantnej emócie"""
        if not cognitive_tags:
            return "unknown"
        
        emotion_counts = {}
        for tag in cognitive_tags:
            emotion = tag.emotion_tone.value
            emotion_counts[emotion] = emotion_counts.get(emotion, 0) + 1
        
        return max(emotion_counts, key=emotion_counts.get)
    
    # =================================================================
    # PODPORNÉ METÓDY PRE PRODUKČNÉ PROSTREDIE
    # =================================================================
    
    def _create_empty_metrics(self) -> CognitiveMetrics:
        """Vytvorenie prázdnych metrík pre edge cases"""
        return CognitiveMetrics(
            consciousness_coherence_rate=0.0,
            cognitive_complexity_index=0.0,
            mental_stability_factor=0.5,
            emotional_resonance_depth=0.0,
            temporal_awareness_level=0.0,
            introspective_clarity_score=0.0,
            overall_cognitive_health=0.0,
            analysis_timestamp=datetime.now().isoformat(),
            session_id=self.session_id
        )
    
    def _create_error_metrics(self, error_message: str) -> CognitiveMetrics:
        """Vytvorenie error metrík pri zlyhaní analýzy"""
        return CognitiveMetrics(
            consciousness_coherence_rate=0.0,
            cognitive_complexity_index=0.0,
            mental_stability_factor=0.0,
            emotional_resonance_depth=0.0,
            temporal_awareness_level=0.0,
            introspective_clarity_score=0.0,
            overall_cognitive_health=0.0,
            analysis_timestamp=datetime.now().isoformat(),
            session_id=f"error_{self.session_id}"
        )
    
    def _assess_complexity_certainty_alignment(self, tag: ASLCognitiveTag) -> float:
        """Hodnotenie súladu komplexnosti s istotou"""
        # Vysoká komplexnosť by mala korelovať s nižšou istotou
        complexity_score = (
            self._get_mental_state_complexity(tag.mental_state) * 0.4 +
            self._get_emotion_complexity(tag.emotion_tone) * 0.3 +
            min(tag.cognitive_load / 10.0, 1.0) * 0.3
        )
        
        expected_certainty = max(0.1, 1.0 - complexity_score * 0.7)
        certainty_difference = abs(tag.certainty_level - expected_certainty)
        return max(0.0, 1.0 - certainty_difference)
    
    def _assess_emotional_authenticity(self, tag: ASLCognitiveTag) -> float:
        """Hodnotenie emočnej autenticity"""
        # Autenticita na základe konzistencie emócie s ostatnými faktormi
        mental_emotion_coherence = self._assess_mental_emotion_coherence(
            tag.mental_state, tag.emotion_tone
        )
        
        certainty_emotion_coherence = self._assess_certainty_emotion_alignment(
            tag.certainty_level, tag.emotion_tone
        )
        
        return (mental_emotion_coherence + certainty_emotion_coherence) / 2.0
    
    def _assess_temporal_realism(self, tag: ASLCognitiveTag) -> float:
        """Hodnotenie temporálnej realistickosti"""
        # Realistickosť kombinácií temporálneho kontextu s ostatnými faktormi
        temporal_complexity = self._get_temporal_complexity(tag.temporal_context)
        cognitive_complexity = min(tag.cognitive_load / 10.0, 1.0)
        
        # Dlhodobé úlohy môžu byť komplexnejšie
        complexity_difference = abs(temporal_complexity - cognitive_complexity)
        return max(0.3, 1.0 - complexity_difference)
    
    # =================================================================
    # PUBLIC API PRE POKROČILÉ FUNKCIE
    # =================================================================
    
    def get_cognitive_trends(self) -> Dict[str, Any]:
        """
        INTENT: Získanie trendov kognitívneho zdravia
        ACTION: Analýza historických dát
        OUTPUT: Trendy a insights
        HOOK: cognitive_trends_analyzed
        """
        if len(self.analysis_history) < 2:
            return {"message": "Insufficient data for trend analysis"}
        
        recent_metrics = self.analysis_history[-5:]  # Posledných 5 analýz
        
        trends = {
            "coherence_trend": self._calculate_trend([m.consciousness_coherence_rate for m in recent_metrics]),
            "stability_trend": self._calculate_trend([m.mental_stability_factor for m in recent_metrics]),
            "complexity_trend": self._calculate_trend([m.cognitive_complexity_index for m in recent_metrics]),
            "overall_health_trend": self._calculate_trend([m.overall_cognitive_health for m in recent_metrics]),
            "session_count": len(self.analysis_history),
            "average_health": statistics.mean([m.overall_cognitive_health for m in self.analysis_history])
        }
        
        return trends
    
    def _calculate_trend(self, values: List[float]) -> str:
        """Výpočet trendu hodnôt"""
        if len(values) < 2:
            return "stable"
        
        differences = [values[i] - values[i-1] for i in range(1, len(values))]
        avg_change = statistics.mean(differences)
        
        if avg_change > 0.05:
            return "improving"
        elif avg_change < -0.05:
            return "declining"
        else:
            return "stable"
    
    def export_session_data(self) -> Dict[str, Any]:
        """
        INTENT: Export kompletných dát session
        ACTION: Serializácia všetkých dát analyzátora
        OUTPUT: JSON-serializable dictionary
        HOOK: session_data_exported
        """
        return {
            "session_id": self.session_id,
            "analysis_mode": self.analysis_mode.value,
            "analysis_history": [metrics.to_dict() for metrics in self.analysis_history],
            "cognitive_flow_patterns": self.cognitive_flow_patterns,
            "session_summary": {
                "total_analyses": len(self.analysis_history),
                "session_duration": self._calculate_session_duration(),
                "average_metrics": self._calculate_average_metrics()
            }
        }
    
    def _calculate_session_duration(self) -> str:
        """Výpočet dĺžky session"""
        if not self.analysis_history:
            return "0 minutes"
        
        start_time = datetime.fromisoformat(self.analysis_history[0].analysis_timestamp)
        end_time = datetime.fromisoformat(self.analysis_history[-1].analysis_timestamp)
        duration = end_time - start_time
        
        return f"{duration.total_seconds() / 60:.1f} minutes"
    
    def _calculate_average_metrics(self) -> Dict[str, float]:
        """Výpočet priemerných metrík session"""
        if not self.analysis_history:
            return {}
        
        return {
            "avg_consciousness_coherence": statistics.mean([m.consciousness_coherence_rate for m in self.analysis_history]),
            "avg_cognitive_complexity": statistics.mean([m.cognitive_complexity_index for m in self.analysis_history]),
            "avg_mental_stability": statistics.mean([m.mental_stability_factor for m in self.analysis_history]),
            "avg_emotional_resonance": statistics.mean([m.emotional_resonance_depth for m in self.analysis_history]),
            "avg_temporal_awareness": statistics.mean([m.temporal_awareness_level for m in self.analysis_history]),
            "avg_introspective_clarity": statistics.mean([m.introspective_clarity_score for m in self.analysis_history]),
            "avg_overall_health": statistics.mean([m.overall_cognitive_health for m in self.analysis_history])
        }


# =================================================================
# KOMPATIBILNÁ WRAPPING FUNKCIA PRE SPÄTNÝ CHOD
# =================================================================

class CognitiveMetricsAnalyzer:
    """
    DEPRECATED: Legacy wrapper pre spätný chod
    Použite AetheroCognitiveAnalyzer pre nové implementácie
    """
    
    def __init__(self):
        logger.warning("CognitiveMetricsAnalyzer is deprecated. Use AetheroCognitiveAnalyzer instead.")
        self._analyzer = AetheroCognitiveAnalyzer(CognitiveAnalysisMode.STANDARD)
    
    def calculate_consciousness_coherence_rate(self, cognitive_tags: List[ASLCognitiveTag]) -> float:
        """Legacy metóda - deleguje na nový analyzátor"""
        return self._analyzer.calculate_consciousness_coherence_rate(cognitive_tags)
    
    def analyze_cognitive_tags(self, cognitive_tags: List[ASLCognitiveTag]) -> Dict[str, Any]:
        """Legacy metóda - deleguje na nový analyzátor a konvertuje výstup"""
        metrics = self._analyzer.analyze_cognitive_tags(cognitive_tags)
        return metrics.to_dict()


# =================================================================
# FACTORY FUNKCIE PRE JEDNODUCHÉ POUŽITIE
# =================================================================

def create_standard_analyzer() -> AetheroCognitiveAnalyzer:
    """Vytvorenie štandardného analyzátora"""
    return AetheroCognitiveAnalyzer(CognitiveAnalysisMode.STANDARD)

def create_deep_analyzer() -> AetheroCognitiveAnalyzer:
    """Vytvorenie analyzátora pre hlbokú introspekciu"""
    return AetheroCognitiveAnalyzer(CognitiveAnalysisMode.DEEP_INTROSPECTION)

def create_realtime_analyzer() -> AetheroCognitiveAnalyzer:
    """Vytvorenie analyzátora pre real-time analýzu"""
    return AetheroCognitiveAnalyzer(CognitiveAnalysisMode.REAL_TIME)

def analyze_tags_simple(cognitive_tags: List[ASLCognitiveTag]) -> Dict[str, float]:
    """
    Jednoduchá funkcia pre rýchlu analýzu tagov
    
    Args:
        cognitive_tags: Zoznam ASL kognitívnych tagov
        
    Returns:
        Dictionary s kľúčovými metrikami
    """
    analyzer = create_standard_analyzer()
    metrics = analyzer.analyze_cognitive_tags(cognitive_tags)
    
    return {
        "coherence": metrics.consciousness_coherence_rate,
        "complexity": metrics.cognitive_complexity_index,
        "stability": metrics.mental_stability_factor,
        "overall_health": metrics.overall_cognitive_health
    }
        # Vysoká kognitívna záťaž by mala korešpondovať s vysokou alebo nízkou istotou
        # (vysoká istota = dobre pochopený zložitý problém, nízka istota = nejasný zložitý problém)
        
        if cognitive_load >= 8:
            # Vysoká záťaž - istota môže byť extrémna
            if certainty_level >= 0.8 or certainty_level <= 0.3:
                return 1.0
            else:
                return 0.6
        elif cognitive_load <= 3:
            # Nízka záťaž - mierka istota je vhodná
            if 0.4 <= certainty_level <= 0.8:
                return 1.0
            else:
                return 0.5
        else:
            # Stredná záťaž - stredná istota
            if 0.3 <= certainty_level <= 0.9:
                return 1.0
            else:
                return 0.7
    
    def _assess_temporal_coherence(self, temporal_context, cognitive_load: int) -> float:
        """Hodnotenie temporálnej koherencie"""
        # Súčasné a okamžité kontexty vyžadujú vyššiu kognitívnu záťaž
        immediate_contexts = [TemporalContextEnum.PRESENT]
        
        if temporal_context in immediate_contexts:
            return 1.0 if cognitive_load >= 5 else 0.7
        else:
            return 1.0 if cognitive_load <= 7 else 0.8
    
    def analyze_cognitive_evolution(self, cognitive_tags: List[ASLCognitiveTag]) -> Dict[str, Any]:
        """
        Analýza evolúcie kognitívnych procesov v čase
        
        Args:
            cognitive_tags: Chronologicky usporiadané kognitívne tagy
            
        Returns:
            Analýza kognitívnej evolúcie
        """
        if len(cognitive_tags) < 2:
            return {"insufficient_data": True}
        
        # Analýza trendov v kognitívnej záťaži
        load_trend = self._calculate_trend([tag.cognitive_load for tag in cognitive_tags])
        
        # Analýza trendov v istote
        certainty_trend = self._calculate_trend([tag.certainty_level for tag in cognitive_tags])
        
        # Analýza stability mentálneho stavu
        mental_state_stability = self._calculate_stability([tag.mental_state.value for tag in cognitive_tags])
        
        # Analýza emocionálnej stability
        emotion_stability = self._calculate_stability([tag.emotion_tone.value for tag in cognitive_tags])
        
        return {
            "cognitive_load_trend": load_trend,
            "certainty_trend": certainty_trend,
            "mental_state_stability": mental_state_stability,
            "emotion_stability": emotion_stability,
            "overall_cognitive_evolution": self._assess_overall_evolution(
                load_trend, certainty_trend, mental_state_stability, emotion_stability
            ),
            "analysis_timestamp": datetime.now().isoformat()
        }
    
    def _calculate_trend(self, values: List[float]) -> Dict[str, Any]:
        """Výpočet trendu v číselných hodnotách"""
        if len(values) < 2:
            return {"trend": "insufficient_data"}
        
        # Jednoduchá lineárna regresia
        n = len(values)
        x_values = list(range(n))
        
        sum_x = sum(x_values)
        sum_y = sum(values)
        sum_xy = sum(x * y for x, y in zip(x_values, values))
        sum_x2 = sum(x * x for x in x_values)
        
        slope = (n * sum_xy - sum_x * sum_y) / (n * sum_x2 - sum_x * sum_x)
        
        if slope > 0.1:
            trend = "increasing"
        elif slope < -0.1:
            trend = "decreasing"
        else:
            trend = "stable"
        
        return {
            "trend": trend,
            "slope": slope,
            "values": values,
            "variance": statistics.variance(values) if len(values) > 1 else 0
        }
    
    def _calculate_stability(self, values: List[str]) -> Dict[str, Any]:
        """Výpočet stability kategorických hodnôt"""
        if not values:
            return {"stability": 0.0}
        
        unique_values = len(set(values))
        total_values = len(values)
        
        stability_score = 1.0 - (unique_values - 1) / max(1, total_values - 1)
        
        return {
            "stability_score": stability_score,
            "unique_values": unique_values,
            "total_values": total_values,
            "most_frequent": max(set(values), key=values.count) if values else None
        }
    
    def _assess_overall_evolution(self, load_trend, certainty_trend, mental_stability, emotion_stability) -> str:
        """Celkové hodnotenie kognitívnej evolúcie"""
        if (load_trend["trend"] == "increasing" and 
            certainty_trend["trend"] == "increasing" and 
            mental_stability["stability_score"] > 0.7):
            return "positive_cognitive_growth"
        
        elif (load_trend["trend"] == "decreasing" and 
              certainty_trend["trend"] == "decreasing"):
            return "cognitive_simplification"
        
        elif (mental_stability["stability_score"] < 0.5 or 
              emotion_stability["stability_score"] < 0.5):
            return "cognitive_instability"
        
        else:
            return "stable_cognitive_state"

    def generate_introspective_report(self, cognitive_tags: List[ASLCognitiveTag]) -> Dict[str, Any]:
        """
        Generovanie komplexného introspektívneho reportu
        
        Args:
            cognitive_tags: Zoznam kognitívnych tagov na analýzu
            
        Returns:
            Komplexný introspektívny report
        """
        consciousness_coherence = self.calculate_consciousness_coherence_rate(cognitive_tags)
        cognitive_evolution = self.analyze_cognitive_evolution(cognitive_tags)
        
        # Štatistiky kognitívnej záťaže
        cognitive_loads = [tag.cognitive_load for tag in cognitive_tags]
        load_stats = {
            "mean": statistics.mean(cognitive_loads) if cognitive_loads else 0,
            "median": statistics.median(cognitive_loads) if cognitive_loads else 0,
            "stdev": statistics.stdev(cognitive_loads) if len(cognitive_loads) > 1 else 0,
            "min": min(cognitive_loads) if cognitive_loads else 0,
            "max": max(cognitive_loads) if cognitive_loads else 0
        }
        
        # Štatistiky istoty
        certainty_levels = [tag.certainty_level for tag in cognitive_tags]
        certainty_stats = {
            "mean": statistics.mean(certainty_levels) if certainty_levels else 0,
            "median": statistics.median(certainty_levels) if certainty_levels else 0,
            "stdev": statistics.stdev(certainty_levels) if len(certainty_levels) > 1 else 0,
            "min": min(certainty_levels) if certainty_levels else 0,
            "max": max(certainty_levels) if certainty_levels else 0
        }
        
        return {
            "session_id": self.analysis_session_id,
            "total_tags_analyzed": len(cognitive_tags),
            "consciousness_coherence_rate": consciousness_coherence,
            "cognitive_evolution_analysis": cognitive_evolution,
            "cognitive_load_statistics": load_stats,
            "certainty_level_statistics": certainty_stats,
            "introspective_insights": self._generate_introspective_insights(
                consciousness_coherence, cognitive_evolution, load_stats, certainty_stats
            ),
            "aethero_constitutional_compliance": self._assess_constitutional_compliance(cognitive_tags),
            "report_generation_timestamp": datetime.now().isoformat()
        }
    
    def _generate_introspective_insights(self, coherence_rate, evolution, load_stats, certainty_stats) -> List[str]:
        """Generovanie introspektívnych pozorovaní"""
        insights = []
        
        if coherence_rate > 0.8:
            insights.append("Vysoká miera koherencie vedomia - systém vykazuje konštantnú introspektívnu kvalitu")
        elif coherence_rate < 0.5:
            insights.append("Nízka koherencia vedomia - potreba hlbšieji introspektívnej analýzy")
        
        if load_stats["mean"] > 7:
            insights.append("Vysoká priemerná kognitívna záťaž - systém spracováva komplexné myšlienky")
        elif load_stats["mean"] < 3:
            insights.append("Nízka kognitívna záťaž - možnosť pre hlbšiu analýzu")
        
        if certainty_stats["stdev"] > 0.3:
            insights.append("Vysoká variabilita istoty - systém prechádza rôznymi úrovňami kognitívnej istoty")
        
        if evolution.get("overall_cognitive_evolution") == "positive_cognitive_growth":
            insights.append("Pozitívny kognitívny rast - systém sa vyvíja smerom k vyššej introspektívnej kvalite")
        
        return insights
    
    def _assess_constitutional_compliance(self, cognitive_tags: List[ASLCognitiveTag]) -> Dict[str, Any]:
        """Hodnotenie súladu s ústavnými princípmi Aethero"""
        compliance_factors = {
            "transparency": all(tag.consciousness_level >= 0.3 for tag in cognitive_tags),
            "introspective_depth": all(tag.introspective_depth >= 0.3 for tag in cognitive_tags),
            "constitutional_law_references": all(bool(tag.constitutional_law) for tag in cognitive_tags),
            "memory_linkage": all(bool(tag.aeth_mem_link) for tag in cognitive_tags)
        }
        
        compliance_score = sum(compliance_factors.values()) / len(compliance_factors)
        
        return {
            "overall_compliance_score": compliance_score,
            "compliance_factors": compliance_factors,
            "constitutional_status": "compliant" if compliance_score >= 0.8 else "needs_improvement"
        }


# Zachovanie spätnej kompatibility
def calculate_success_rate(validated_blocks: int, total_blocks: int) -> float:
    """Legacy function - calculate the success rate of parsing."""
    if total_blocks == 0:
        return 0.0
    return validated_blocks / total_blocks

def analyze_cognitive_load(tags: list) -> dict:
    """Legacy function - analyze cognitive load from a list of ASL tags."""
    loads = [tag.get("cognitive_load", 0) for tag in tags]
    return {
        "average_load": sum(loads) / len(loads) if loads else 0,
        "max_load": max(loads, default=0),
        "min_load": min(loads, default=0),
    }

def generate_introspection_report(tags: list) -> dict:
    """Legacy function - generate a report based on introspective tags."""
    return {
        "certainty_levels": [tag.get("certainty_level", 0.0) for tag in tags],
        "memory_links": [tag.get("aeth_mem_link", "") for tag in tags],
    }