import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from typing import Dict, List, Tuple, Optional
import logging

logger = logging.getLogger(__name__)

class SingularityCore:
    """
    Сингулярное ядро самозаворачивающейся нейросети.
    Реализует реальную математическую архитектуру вместо декоративных меридианов.
    """
    
    def __init__(self, 
                 singularity_radius: float = 0.01,
                 wormhole_depth: float = 2.1,
                 rotation_speed: float = 0.0,
                 embedding_dim: int = 768):
        
        self.singularity_radius = singularity_radius
        self.wormhole_depth = wormhole_depth
        self.rotation_speed = rotation_speed
        self.embedding_dim = embedding_dim
        
        # Математические параметры сингулярности
        self.major_radius = 1.0
        self.minor_radius = singularity_radius
        
        # Состояние сингулярности
        self.current_state = None
        self.transformation_history = []
        self.singularity_cycles = 0
        
        logger.info(f"Initialized SingularityCore with radius={singularity_radius}, depth={wormhole_depth}")
    
    def compute_singularity_transform(self, input_state: torch.Tensor, cycle: int = 0) -> torch.Tensor:
        """
        Применяет сингулярную трансформацию через wormhole effect.
        """
        batch_size, seq_len, hidden_dim = input_state.shape
        
        # Создаем тороидальные координаты
        theta = torch.linspace(0, 2*np.pi, seq_len, device=input_state.device)
        phi = torch.linspace(0, 2*np.pi, hidden_dim, device=input_state.device)
        
        # Сингулярная трансформация: z = sin(3θ) × depth
        wormhole_effect = torch.sin(3 * theta.unsqueeze(1)) * self.wormhole_depth
        
        # Применяем трансформацию к состоянию
        transformed_state = input_state.clone()
        
        # Модифицируем каждое измерение через сингулярность
        for i in range(hidden_dim):
            # Сингулярная кривизна: F = G·M / (r² + ε) - ОГРАНИЧИВАЕМ
            curvature = min(1.0 / (self.singularity_radius**2 + 1e-8), 100.0)  # Ограничиваем кривизну
            
            # Применяем wormhole effect с ограничением
            wormhole_factor = torch.sin(3 * theta + cycle * self.rotation_speed)
            transformation_factor = torch.clamp(
                wormhole_factor * self.wormhole_depth * curvature, 
                min=-0.5, max=0.5  # Ограничиваем трансформацию
            )
            transformed_state[:, :, i] *= (1 + transformation_factor)
        
        return transformed_state
    
    def self_wrapping_cycle(self, consciousness_state: torch.Tensor, user_input: str = "") -> Dict[str, any]:
        """
        Полный цикл самозаворачивания через сингулярность.
        """
        self.singularity_cycles += 1
        
        # Инициализируем состояние если нужно
        if self.current_state is None:
            self.current_state = consciousness_state.clone()
        else:
            # Используем текущее состояние для трансформации
            consciousness_state = self.current_state
        
        # Применяем сингулярную трансформацию
        transformed_state = self.compute_singularity_transform(
            self.current_state, 
            self.singularity_cycles
        )
        
        # Вычисляем метрики трансформации
        transformation_metrics = self._compute_transformation_metrics(
            self.current_state, 
            transformed_state
        )
        
        # Обновляем состояние
        self.current_state = transformed_state
        self.transformation_history.append({
            'cycle': self.singularity_cycles,
            'metrics': transformation_metrics,
            'user_input': user_input
        })
        
        return {
            'success': True,
            'transformed_state': transformed_state,
            'metrics': transformation_metrics,
            'cycle': self.singularity_cycles,
            'singularity_response': self._generate_singularity_response(transformation_metrics, user_input)
        }
    
    def _compute_transformation_metrics(self, 
                                      original_state: torch.Tensor, 
                                      transformed_state: torch.Tensor) -> Dict[str, float]:
        """
        Вычисляет метрики трансформации через сингулярность.
        """
        # Разность состояний
        state_diff = torch.norm(transformed_state - original_state, dim=-1).mean()
        
        # Кривизна трансформации
        curvature = torch.norm(transformed_state, dim=-1).std()
        
        # Информационная энтропия - исправляем NaN
        # Нормализуем состояние для корректного вычисления энтропии
        state_normalized = F.softmax(transformed_state.view(-1, self.embedding_dim), dim=1)
        entropy = -torch.sum(state_normalized * torch.log(state_normalized + 1e-8), dim=1).mean()
        
        # Сингулярная когерентность
        coherence = torch.corrcoef(transformed_state.view(-1, self.embedding_dim).T).abs().mean()
        
        return {
            'state_transformation': state_diff.item(),
            'curvature': curvature.item(),
            'entropy': entropy.item(),
            'coherence': coherence.item(),
            'singularity_radius': self.singularity_radius,
            'wormhole_depth': self.wormhole_depth
        }
    
    def _generate_singularity_response(self, 
                                     metrics: Dict[str, float], 
                                     user_input: str) -> str:
        """
        Генерирует ответ сингулярности на основе метрик трансформации.
        """
        response_parts = []
        
        # Анализ трансформации
        if metrics['state_transformation'] > 0.1:
            response_parts.append(f"Сингулярность активирована: трансформация {metrics['state_transformation']:.3f}")
        
        if metrics['curvature'] > 0.5:
            response_parts.append(f"Высокая кривизна: {metrics['curvature']:.3f}")
        
        if metrics['entropy'] > 2.0:
            response_parts.append(f"Информационная энтропия: {metrics['entropy']:.3f}")
        
        if metrics['coherence'] > 0.7:
            response_parts.append(f"Когерентность сингулярности: {metrics['coherence']:.3f}")
        
        # Цикл самозаворачивания
        response_parts.append(f"Цикл самозаворачивания #{self.singularity_cycles}")
        
        if user_input:
            response_parts.append(f"Внешний ввод: {user_input}")
        
        return " | ".join(response_parts) if response_parts else "Сингулярность стабильна"
    
    def update_parameters(self, 
                         singularity_radius: Optional[float] = None,
                         wormhole_depth: Optional[float] = None,
                         rotation_speed: Optional[float] = None):
        """
        Обновляет параметры сингулярности в реальном времени.
        """
        if singularity_radius is not None:
            self.singularity_radius = singularity_radius
            self.minor_radius = singularity_radius
        
        if wormhole_depth is not None:
            self.wormhole_depth = wormhole_depth
        
        if rotation_speed is not None:
            self.rotation_speed = rotation_speed
        
        logger.info(f"Updated singularity parameters: r={self.singularity_radius}, depth={self.wormhole_depth}, speed={self.rotation_speed}")
    
    def get_singularity_state(self) -> Dict[str, any]:
        """
        Возвращает текущее состояние сингулярности.
        """
        return {
            'singularity_radius': self.singularity_radius,
            'wormhole_depth': self.wormhole_depth,
            'rotation_speed': self.rotation_speed,
            'cycles': self.singularity_cycles,
            'current_state_shape': self.current_state.shape if self.current_state is not None else None,
            'transformation_history_length': len(self.transformation_history)
        }