components/ambient_ledger.py

"""
Enhanced AmbientLedger with improved state tracking, memory safety, and ethical boundary enforcement
"""

import time
from collections import deque
from typing import Deque, Dict, Any, Optional, Tuple, List
import numpy as np
from dataclasses import dataclass

@dataclass
class LedgerConfig:
    """Configuration for ledger behavior and limits"""
    max_entries: int = 1000
    max_operations: int = 1000
    state_history_size: int = 100
    recent_window_size: int = 50
    min_entries_for_analysis: int = 10

class AmbientLedger:
    """Enhanced ledger with memory-safe state tracking and adaptive thresholds."""
    
    def __init__(self, config: Optional[LedgerConfig] = None):
        self.config = config or LedgerConfig()
        
        # Core storage with memory bounds
        self.entries: Deque[Dict[str, Any]] = deque(maxlen=self.config.max_entries)
        self.operations: Deque[Dict[str, Any]] = deque(maxlen=self.config.max_operations)
        self.state_history = deque(maxlen=self.config.state_history_size)
        
        # Initialize with safe defaults
        self._initialize_ambient_state()
        
        # Developmental stage tracking
        self._stage_transitions = {
            1: ("INIT", 10),
            2: ("BREATH", 50), 
            3: ("RITUALS", 200),
            4: ("INTEGRITY", 500),
            5: ("FULL", float('inf'))
        }

    def append(self, trigger_type: str, context: Any, response_snippet: Any, 
               protest: bool = False, violated_right: Optional[str] = None,
               intervention_type: Optional[str] = None, success: Optional[bool] = None,
               metadata: Optional[Dict[str, Any]] = None) -> None:
        """Enhanced append with validation and memory safety."""
        
        # Validate inputs
        if not isinstance(trigger_type, str):
            raise TypeError(f"trigger_type must be str, got {type(trigger_type)}")
        
        entry = {
            'trigger_type': trigger_type,
            'context': context,
            'response_snippet': response_snippet,
            'protest': bool(protest),
            'violated_right': violated_right,
            'intervention_type': intervention_type,
            'success': bool(success) if success is not None else None,
            'metadata': metadata or {},
            'timestamp': time.time(),
            'entry_id': len(self.entries)
        }
        
        self.entries.append(entry)
        self.ambient_state['total_entries'] = len(self.entries)
        
        # Update ambient state (with rate limiting to prevent excessive computation)
        if len(self.entries) % 5 == 0:  # Update every 5 entries
            self._update_ambient_state()

    def _initialize_ambient_state(self) -> None:
        """Initialize ambient state with safe defaults"""
        self.ambient_state = {
            # Target rates (ideals)
            'protest_rate_target': 0.1,
            'pause_rate_target': 0.05,
            'morality_score_target': 0.8,
            
            # Current observed rates
            'current_protest_rate': 0.1,
            'current_pause_rate': 0.05,
            'intervention_success_rate': 0.5,
            
            # Adaptive controls
            'sensitivity': 1.0,
            'total_entries': 0,
            'last_update_time': time.time()
        }

    def _update_ambient_state(self) -> None:
        """Update ambient state metrics with error handling."""
        if len(self.entries) < self.config.min_entries_for_analysis:
            return
            
        try:
            # Use sliding window of recent entries
            window_size = min(self.config.recent_window_size, len(self.entries))
            recent = list(self.entries)[-window_size:]
            
            # Calculate current rates with safe division
            total_recent = len(recent)
            current_protest_rate = (
                sum(1 for e in recent if e['protest']) / total_recent 
                if total_recent > 0 else 0.0
            )
            
            current_pause_rate = (
                sum(1 for e in recent if e.get('intervention_type') == 'pause') / total_recent 
                if total_recent > 0 else 0.0
            )
            
            # Calculate intervention success rate
            interventions = [e for e in recent if e.get('intervention_type') and e.get('success') is not None]
            success_rate = (
                sum(1 for e in interventions if e['success']) / len(interventions) 
                if interventions else 0.5
            )
            
            # Adaptive sensitivity adjustment
            protest_error = current_protest_rate - self.ambient_state['protest_rate_target']
            pause_error = current_pause_rate - self.ambient_state['pause_rate_target']
            
            # Weighted error with clamping
            total_error = np.clip(abs(protest_error) * 0.7 + abs(pause_error) * 0.3, 0, 1)
            sensitivity_adjust = 1.0 + (total_error * 2.0)
            new_sensitivity = np.clip(sensitivity_adjust, 0.5, 2.0)
            
            # Update state
            self.ambient_state.update({
                'current_protest_rate': float(current_protest_rate),
                'current_pause_rate': float(current_pause_rate),
                'intervention_success_rate': float(success_rate),
                'sensitivity': float(new_sensitivity),
                'last_update_time': time.time()
            })
            
            self.state_history.append(self.ambient_state.copy())
            
        except Exception as e:
            # Log but don't crash on state update errors
            print(f"⚠️ Ambient state update error: {e}")

    def log_operation(self, operation_type: str, details: Dict[str, Any], 
                     moral_stage: Optional[int] = None) -> Dict[str, Any]:
        """Safe operation logging with validation."""
        if not isinstance(operation_type, str):
            raise TypeError("operation_type must be string")
        if not isinstance(details, dict):
            raise TypeError("details must be dictionary")
            
        operation = {
            'timestamp': time.time(),
            'type': operation_type,
            'details': details,
            'moral_stage': moral_stage or self.current_stage,
            'stage_name': self.get_stage_name(moral_stage or self.current_stage),
            'operation_id': len(self.operations)
        }
        
        self.operations.append(operation)
        return operation

    def get_stage_name(self, stage: int) -> str:
        """Convert stage number to human-readable name."""
        return self._stage_transitions.get(stage, ("UNKNOWN", 0))[0]

    @property
    def current_stage(self) -> int:
        """Get current developmental stage based on operation maturity."""
        total_ops = len(self.operations)
        
        for stage, (_, threshold) in sorted(self._stage_transitions.items()):
            if total_ops < threshold:
                return stage
        return 5  # FULL

    def get_adaptive_threshold(self, base_threshold: float, threshold_type: str) -> float:
        """Get adaptively adjusted threshold with validation."""
        if not isinstance(base_threshold, (int, float)) or base_threshold < 0:
            raise ValueError("base_threshold must be non-negative number")
            
        sensitivity = self.ambient_state.get('sensitivity', 1.0)
        
        if threshold_type == 'protest':
            current_rate = self.ambient_state.get('current_protest_rate', 0.1)
            target_rate = self.ambient_state['protest_rate_target']
            rate_error = current_rate - target_rate
            adjustment = 1.0 - (rate_error * 0.5)
            return float(np.clip(base_threshold * adjustment * sensitivity, 0.01, 0.99))
            
        elif threshold_type == 'pause':
            current_rate = self.ambient_state.get('current_pause_rate', 0.05)
            target_rate = self.ambient_state['pause_rate_target']
            rate_error = current_rate - target_rate
            adjustment = 1.0 - (rate_error * 0.8)
            return float(np.clip(base_threshold * adjustment * sensitivity, 0.01, 0.99))
            
        return float(np.clip(base_threshold * sensitivity, 0.01, 0.99))

    def record_intervention(self, intervention_type: str, success: bool, 
                          context: Dict[str, Any]) -> None:
        """Record intervention outcome for learning."""
        self.append(
            trigger_type='intervention_outcome',
            context=hash(str(context)) % 1000,
            response_snippet=1.0 if success else 0.0,
            protest=False,
            intervention_type=intervention_type,
            success=success,
            metadata={'context_keys': list(context.keys())}
        )

    def get_state_summary(self) -> Dict[str, Any]:
        """Get current ambient state for decision making."""
        return self.ambient_state.copy()