"""
Database models for Lyra's persistent storage.

These models handle storage of conversations, personality evolution,
emotional memories, and knowledge acquisition.
"""

from sqlalchemy import (
    Column, Integer, String, Float, Text, DateTime, Boolean,
    JSON, ForeignKey, Index, UniqueConstraint
)
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship, backref
from sqlalchemy.dialects.postgresql import UUID
from datetime import datetime
import uuid
import json
from typing import Dict, Any, Optional, List

Base = declarative_base()


class UserModel(Base):
    """User information and preferences."""

    __tablename__ = 'users'

    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
    discord_id = Column(String, unique=True, nullable=False, index=True)
    username = Column(String, nullable=False)
    display_name = Column(String)
    first_interaction = Column(DateTime, default=datetime.utcnow)
    last_interaction = Column(DateTime, default=datetime.utcnow)

    # User preferences and relationship data
    preferences = Column(JSON, default=dict)
    relationship_data = Column(JSON, default=dict)
    interaction_count = Column(Integer, default=0)
    satisfaction_ratings = Column(JSON, default=list)

    # Relationships
    conversations = relationship(
        "ConversationModel", back_populates="user", cascade="all, delete-orphan"
    )
    personality_adaptations = relationship(
        "PersonalityAdaptationModel", back_populates="user", cascade="all, delete-orphan"
    )

    def __repr__(self):
        return f"<User(discord_id='{self.discord_id}', username='{self.username}')>"


class ConversationModel(Base):
    """Individual conversation records."""

    __tablename__ = 'conversations'

    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
    user_id = Column(String, ForeignKey('users.id'), nullable=False, index=True)
    channel_id = Column(String, nullable=False, index=True)
    message_id = Column(String, unique=True, nullable=False)

    # Message content
    user_message = Column(Text, nullable=False)
    lyra_response = Column(Text, nullable=False)
    context = Column(JSON, default=dict)

    # Timing information
    timestamp = Column(DateTime, default=datetime.utcnow, index=True)
    response_time = Column(Float)  # Response generation time in seconds

    # Emotional and personality context
    emotional_state = Column(JSON, default=dict)
    personality_state = Column(JSON, default=dict)
    thinking_process = Column(JSON, default=list)

    # Feedback and learning
    user_satisfaction = Column(Float)  # 0.0 to 1.0
    response_quality = Column(Float)   # 0.0 to 1.0
    learned_from = Column(Boolean, default=False)

    # Relationships
    user = relationship("UserModel", back_populates="conversations")

    __table_args__ = (
        Index('idx_conversations_user_timestamp', 'user_id', 'timestamp'),
        Index('idx_conversations_channel_timestamp', 'channel_id', 'timestamp'),
    )

    def __repr__(self):
        return f"<Conversation(user_id='{self.user_id}', timestamp='{self.timestamp}')>"


class PersonalityStateModel(Base):
    """Snapshots of Lyra's personality evolution."""

    __tablename__ = 'personality_states'

    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
    timestamp = Column(DateTime, default=datetime.utcnow, index=True)

    # OCEAN traits
    openness = Column(Float, nullable=False)
    conscientiousness = Column(Float, nullable=False)
    extraversion = Column(Float, nullable=False)
    agreeableness = Column(Float, nullable=False)
    neuroticism = Column(Float, nullable=False)

    # Myers-Briggs type
    myers_briggs_type = Column(String(4), nullable=False)

    # Custom personality traits
    custom_traits = Column(JSON, nullable=False)

    # Evolution metrics
    total_interactions = Column(Integer, default=0)
    adaptation_rate = Column(Float, default=0.01)
    emotional_maturity = Column(Float, default=0.5)

    # Context for this state
    trigger_event = Column(String)
    change_magnitude = Column(Float)

    __table_args__ = (
        Index('idx_personality_timestamp', 'timestamp'),
    )

    def __repr__(self):
        return f"<PersonalityState(timestamp='{self.timestamp}', mb_type='{self.myers_briggs_type}')>"


class PersonalityAdaptationModel(Base):
    """User-specific personality adaptations."""

    __tablename__ = 'personality_adaptations'

    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
    user_id = Column(String, ForeignKey('users.id'), nullable=False, index=True)
    timestamp = Column(DateTime, default=datetime.utcnow)

    # Adaptation details
    trait_adaptations = Column(JSON, nullable=False)  # Which traits were adapted
    adaptation_magnitude = Column(Float, nullable=False)
    success_rating = Column(Float)  # How successful this adaptation was

    # Context
    context_type = Column(String)
    conversation_id = Column(String, ForeignKey('conversations.id'))

    # Relationships
    user = relationship("UserModel", back_populates="personality_adaptations")
    conversation = relationship("ConversationModel")

    __table_args__ = (
        Index('idx_adaptations_user_timestamp', 'user_id', 'timestamp'),
    )

    def __repr__(self):
        return f"<PersonalityAdaptation(user_id='{self.user_id}', timestamp='{self.timestamp}')>"


class EmotionalMemoryModel(Base):
    """Emotional memories and experiences."""

    __tablename__ = 'emotional_memories'

    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
    timestamp = Column(DateTime, default=datetime.utcnow, index=True)

    # Emotional state
    emotional_state = Column(JSON, nullable=False)
    dominant_emotion = Column(String, nullable=False, index=True)
    emotion_intensity = Column(Float, nullable=False)
    emotional_valence = Column(Float, nullable=False)  # Positive/negative

    # Memory details
    context = Column(Text, nullable=False)
    trigger = Column(String)
    impact_score = Column(Float, nullable=False)
    decay_rate = Column(Float, default=0.95)

    # Associated conversation
    conversation_id = Column(String, ForeignKey('conversations.id'))
    user_id = Column(String, ForeignKey('users.id'), index=True)

    # Learning from this memory
    lessons_learned = Column(JSON, default=list)
    influenced_responses = Column(Integer, default=0)

    # Relationships
    conversation = relationship("ConversationModel")
    user = relationship("UserModel")

    __table_args__ = (
        Index('idx_emotional_memories_emotion_intensity', 'dominant_emotion', 'emotion_intensity'),
        Index('idx_emotional_memories_user_timestamp', 'user_id', 'timestamp'),
    )

    def __repr__(self):
        return f"<EmotionalMemory(emotion='{self.dominant_emotion}', intensity={self.emotion_intensity})>"


class KnowledgeModel(Base):
    """Knowledge acquired by Lyra."""

    __tablename__ = 'knowledge'

    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
    timestamp = Column(DateTime, default=datetime.utcnow, index=True)

    # Knowledge content
    title = Column(String, nullable=False)
    content = Column(Text, nullable=False)
    summary = Column(Text)
    category = Column(String, nullable=False, index=True)
    subcategory = Column(String, index=True)

    # Source information
    source_type = Column(String, nullable=False)  # 'gutenberg', 'conversation', 'web', etc.
    source_url = Column(String)
    source_metadata = Column(JSON, default=dict)

    # Knowledge quality and relevance
    quality_score = Column(Float, default=0.5)
    relevance_score = Column(Float, default=0.5)
    usage_count = Column(Integer, default=0)
    last_used = Column(DateTime)

    # Processing information
    embedding_vector = Column(JSON)  # Stored as JSON array
    keywords = Column(JSON, default=list)
    related_concepts = Column(JSON, default=list)

    # Legal and ethical compliance
    is_legal = Column(Boolean, default=True)
    copyright_status = Column(String, default='public_domain')
    ethical_review = Column(Boolean, default=False)

    __table_args__ = (
        Index('idx_knowledge_category_quality', 'category', 'quality_score'),
        Index('idx_knowledge_source_timestamp', 'source_type', 'timestamp'),
    )

    def __repr__(self):
        return f"<Knowledge(title='{self.title}', category='{self.category}')>"


class LearningProgressModel(Base):
    """Track Lyra's learning and evolution progress."""

    __tablename__ = 'learning_progress'

    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
    timestamp = Column(DateTime, default=datetime.utcnow, index=True)

    # Learning metrics
    total_conversations = Column(Integer, nullable=False)
    total_knowledge_items = Column(Integer, nullable=False)
    personality_evolution_count = Column(Integer, nullable=False)
    emotional_memories_count = Column(Integer, nullable=False)

    # Performance metrics
    avg_user_satisfaction = Column(Float, nullable=False)
    avg_response_quality = Column(Float, nullable=False)
    conversation_success_rate = Column(Float, nullable=False)

    # Capability metrics
    knowledge_categories_mastered = Column(JSON, default=list)
    personality_stability = Column(Float, nullable=False)
    emotional_maturity = Column(Float, nullable=False)
    social_adaptation_score = Column(Float, nullable=False)

    # Self-awareness metrics
    self_evolution_events = Column(Integer, default=0)
    conscious_personality_modifications = Column(Integer, default=0)
    meta_learning_instances = Column(Integer, default=0)

    __table_args__ = (
        Index('idx_learning_progress_timestamp', 'timestamp'),
    )

    def __repr__(self):
        return f"<LearningProgress(timestamp='{self.timestamp}', conversations={self.total_conversations})>"


class ThinkingProcessModel(Base):
    """Individual thinking processes and internal dialogue."""

    __tablename__ = 'thinking_processes'

    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
    conversation_id = Column(String, ForeignKey('conversations.id'), nullable=False, index=True)
    timestamp = Column(DateTime, default=datetime.utcnow)

    # Thinking details
    thought_type = Column(String, nullable=False)
    thought_content = Column(Text, nullable=False)
    thought_reasoning = Column(Text, nullable=False)
    confidence = Column(Float, nullable=False)

    # Influences
    emotional_influence = Column(Float, default=0.0)
    personality_influence = Column(Float, default=0.0)
    contextual_influence = Column(Float, default=0.0)

    # Sequence information
    sequence_order = Column(Integer, nullable=False)
    total_thoughts_in_chain = Column(Integer, nullable=False)

    # Outcome
    led_to_response = Column(Boolean, default=False)
    influenced_response = Column(Float, default=0.0)  # How much this thought influenced the final response

    # Relationships
    conversation = relationship("ConversationModel")

    __table_args__ = (
        Index('idx_thinking_conversation_sequence', 'conversation_id', 'sequence_order'),
        Index('idx_thinking_type_confidence', 'thought_type', 'confidence'),
    )

    def __repr__(self):
        return f"<ThinkingProcess(type='{self.thought_type}', confidence={self.confidence})>"


class EvolutionEventModel(Base):
    """Self-evolution and adaptation events."""

    __tablename__ = 'evolution_events'

    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
    timestamp = Column(DateTime, default=datetime.utcnow, index=True)

    # Evolution details
    evolution_type = Column(String, nullable=False)  # 'personality', 'emotional', 'knowledge', 'capability'
    trigger_event = Column(String, nullable=False)
    description = Column(Text, nullable=False)

    # Change metrics
    change_magnitude = Column(Float, nullable=False)
    confidence_in_change = Column(Float, nullable=False)
    reversibility = Column(Float, default=0.5)  # How reversible this change is

    # Context
    associated_conversation_id = Column(String, ForeignKey('conversations.id'))
    user_feedback_score = Column(Float)
    environmental_factors = Column(JSON, default=dict)

    # Before/after states
    state_before = Column(JSON, nullable=False)
    state_after = Column(JSON, nullable=False)
    difference_vector = Column(JSON, nullable=False)

    # Learning from evolution
    success_indicators = Column(JSON, default=list)
    failure_indicators = Column(JSON, default=list)
    lessons_learned = Column(JSON, default=list)

    # Relationships
    conversation = relationship("ConversationModel")

    __table_args__ = (
        Index('idx_evolution_type_timestamp', 'evolution_type', 'timestamp'),
        Index('idx_evolution_magnitude', 'change_magnitude'),
    )

    def __repr__(self):
        return f"<EvolutionEvent(type='{self.evolution_type}', magnitude={self.change_magnitude})>"


class SystemMetricsModel(Base):
    """System-wide metrics and health indicators."""

    __tablename__ = 'system_metrics'

    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
    timestamp = Column(DateTime, default=datetime.utcnow, index=True)

    # Performance metrics
    avg_response_time = Column(Float, nullable=False)
    memory_usage_mb = Column(Float, nullable=False)
    gpu_usage_percent = Column(Float)
    cpu_usage_percent = Column(Float, nullable=False)

    # AI metrics
    model_confidence = Column(Float, nullable=False)
    personality_coherence = Column(Float, nullable=False)
    emotional_stability = Column(Float, nullable=False)
    knowledge_recall_accuracy = Column(Float, nullable=False)

    # User interaction metrics
    active_users_24h = Column(Integer, nullable=False)
    total_conversations_24h = Column(Integer, nullable=False)
    avg_satisfaction_24h = Column(Float, nullable=False)

    # Learning metrics
    new_knowledge_items_24h = Column(Integer, default=0)
    personality_changes_24h = Column(Integer, default=0)
    evolution_events_24h = Column(Integer, default=0)

    # System health
    errors_24h = Column(Integer, default=0)
    warnings_24h = Column(Integer, default=0)
    successful_operations_24h = Column(Integer, nullable=False)

    __table_args__ = (
        Index('idx_system_metrics_timestamp', 'timestamp'),
    )

    def __repr__(self):
        return f"<SystemMetrics(timestamp='{self.timestamp}', confidence={self.model_confidence})>"