"""
Plugin System Database Models
Defines the database schema for the isolated plugin architecture
"""
from sqlalchemy import Column, Integer, String, Text, DateTime, Boolean, JSON, ForeignKey, Index
from sqlalchemy.dialects.postgresql import UUID
from sqlalchemy.orm import relationship
from sqlalchemy.sql import func
import uuid

from app.db.database import Base


class Plugin(Base):
    """Plugin registry - tracks all installed plugins"""
    __tablename__ = "plugins"
    
    # Primary identification
    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
    name = Column(String(100), unique=True, nullable=False, index=True)
    slug = Column(String(100), unique=True, nullable=False, index=True)  # URL-safe identifier
    
    # Metadata
    display_name = Column(String(200), nullable=False)
    description = Column(Text)
    version = Column(String(50), nullable=False)
    author = Column(String(200))
    homepage = Column(String(500))
    repository = Column(String(500))
    
    # Plugin file information
    package_path = Column(String(500), nullable=False)  # Path to plugin package
    manifest_hash = Column(String(64), nullable=False)  # SHA256 of manifest file
    package_hash = Column(String(64), nullable=False)   # SHA256 of plugin package
    
    # Status and lifecycle
    status = Column(String(20), nullable=False, default="installed", index=True)
    # Statuses: installing, installed, enabled, disabled, error, uninstalling
    enabled = Column(Boolean, default=False, nullable=False, index=True)
    auto_enable = Column(Boolean, default=False, nullable=False)
    
    # Installation tracking
    installed_at = Column(DateTime, nullable=False, default=func.now())
    enabled_at = Column(DateTime)
    last_updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
    installed_by_user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
    
    # Configuration and requirements
    manifest_data = Column(JSON)  # Complete plugin.yaml content
    config_schema = Column(JSON)  # JSON schema for plugin configuration
    default_config = Column(JSON)  # Default configuration values
    
    # Security and permissions
    required_permissions = Column(JSON)  # List of required permission scopes
    api_scopes = Column(JSON)  # Required API access scopes
    resource_limits = Column(JSON)  # Memory, CPU, storage limits
    
    # Database isolation
    database_name = Column(String(100), unique=True)  # Isolated database name
    database_url = Column(String(1000))  # Connection string for plugin database
    
    # Error tracking
    last_error = Column(Text)
    error_count = Column(Integer, default=0)
    last_error_at = Column(DateTime)
    
    # Relationships
    installed_by_user = relationship("User", back_populates="installed_plugins")
    configurations = relationship("PluginConfiguration", back_populates="plugin", cascade="all, delete-orphan")
    instances = relationship("PluginInstance", back_populates="plugin", cascade="all, delete-orphan")
    audit_logs = relationship("PluginAuditLog", back_populates="plugin", cascade="all, delete-orphan")
    cron_jobs = relationship("PluginCronJob", back_populates="plugin", cascade="all, delete-orphan")
    
    # Indexes for performance
    __table_args__ = (
        Index('idx_plugin_status_enabled', 'status', 'enabled'),
        Index('idx_plugin_user_status', 'installed_by_user_id', 'status'),
    )


class PluginConfiguration(Base):
    """Plugin configuration instances - per user/environment configs"""
    __tablename__ = "plugin_configurations"
    
    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
    plugin_id = Column(UUID(as_uuid=True), ForeignKey("plugins.id"), nullable=False)
    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
    
    # Configuration data
    name = Column(String(200), nullable=False)  # Human-readable config name
    description = Column(Text)
    config_data = Column(JSON, nullable=False)  # Non-sensitive configuration values
    encrypted_data = Column(Text)  # Encrypted sensitive fields (JSON string)
    schema_version = Column(String(50))  # Schema version for migration support
    is_active = Column(Boolean, default=False, nullable=False)
    is_default = Column(Boolean, default=False, nullable=False)
    
    # Metadata
    created_at = Column(DateTime, nullable=False, default=func.now())
    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
    created_by_user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
    
    # Relationships
    plugin = relationship("Plugin", back_populates="configurations")
    user = relationship("User", foreign_keys=[user_id])
    created_by_user = relationship("User", foreign_keys=[created_by_user_id])
    
    # Constraints
    __table_args__ = (
        Index('idx_plugin_config_user_active', 'plugin_id', 'user_id', 'is_active'),
    )


class PluginInstance(Base):
    """Plugin runtime instances - tracks running plugin processes"""
    __tablename__ = "plugin_instances"
    
    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
    plugin_id = Column(UUID(as_uuid=True), ForeignKey("plugins.id"), nullable=False)
    configuration_id = Column(UUID(as_uuid=True), ForeignKey("plugin_configurations.id"))
    
    # Runtime information
    instance_name = Column(String(200), nullable=False)
    process_id = Column(String(100))  # Docker container ID or process ID
    status = Column(String(20), nullable=False, default="starting", index=True)
    # Statuses: starting, running, stopping, stopped, error, crashed
    
    # Performance tracking
    start_time = Column(DateTime, nullable=False, default=func.now())
    last_heartbeat = Column(DateTime, default=func.now())
    stop_time = Column(DateTime)
    restart_count = Column(Integer, default=0)
    
    # Resource usage
    memory_usage_mb = Column(Integer)
    cpu_usage_percent = Column(Integer)
    
    # Health monitoring
    health_status = Column(String(20), default="unknown")  # healthy, warning, critical
    health_message = Column(Text)
    last_health_check = Column(DateTime)
    
    # Error tracking
    last_error = Column(Text)
    error_count = Column(Integer, default=0)
    
    # Relationships
    plugin = relationship("Plugin", back_populates="instances")
    configuration = relationship("PluginConfiguration")
    
    __table_args__ = (
        Index('idx_plugin_instance_status', 'plugin_id', 'status'),
    )


class PluginAuditLog(Base):
    """Audit logging for all plugin activities"""
    __tablename__ = "plugin_audit_logs"
    
    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
    plugin_id = Column(UUID(as_uuid=True), ForeignKey("plugins.id"), nullable=False)
    instance_id = Column(UUID(as_uuid=True), ForeignKey("plugin_instances.id"))
    
    # Event details
    event_type = Column(String(50), nullable=False, index=True)  # api_call, config_change, error, etc.
    action = Column(String(100), nullable=False)
    resource = Column(String(200))  # Resource being accessed
    
    # Context information
    user_id = Column(Integer, ForeignKey("users.id"))
    api_key_id = Column(Integer, ForeignKey("api_keys.id"))
    ip_address = Column(String(45))  # IPv4 or IPv6
    user_agent = Column(String(500))
    
    # Request/response data
    request_data = Column(JSON)  # Sanitized request data
    response_status = Column(Integer)
    response_data = Column(JSON)  # Sanitized response data
    
    # Performance metrics
    duration_ms = Column(Integer)
    
    # Status and errors
    success = Column(Boolean, nullable=False, index=True)
    error_message = Column(Text)
    
    # Timestamps
    timestamp = Column(DateTime, nullable=False, default=func.now(), index=True)
    
    # Relationships
    plugin = relationship("Plugin", back_populates="audit_logs")
    instance = relationship("PluginInstance")
    user = relationship("User")
    api_key = relationship("APIKey")
    
    __table_args__ = (
        Index('idx_plugin_audit_plugin_time', 'plugin_id', 'timestamp'),
        Index('idx_plugin_audit_user_time', 'user_id', 'timestamp'),
        Index('idx_plugin_audit_event_type', 'event_type', 'timestamp'),
    )


class PluginCronJob(Base):
    """Plugin scheduled jobs and cron tasks"""
    __tablename__ = "plugin_cron_jobs"
    
    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
    plugin_id = Column(UUID(as_uuid=True), ForeignKey("plugins.id"), nullable=False)
    
    # Job identification
    job_name = Column(String(200), nullable=False)
    job_id = Column(String(100), nullable=False, unique=True, index=True)  # Unique scheduler ID
    
    # Schedule configuration
    schedule = Column(String(100), nullable=False)  # Cron expression
    timezone = Column(String(50), default="UTC")
    enabled = Column(Boolean, default=True, nullable=False, index=True)
    
    # Job details
    description = Column(Text)
    function_name = Column(String(200), nullable=False)  # Plugin function to call
    job_data = Column(JSON)  # Parameters for the job function
    
    # Execution tracking
    last_run_at = Column(DateTime)
    next_run_at = Column(DateTime, index=True)
    last_duration_ms = Column(Integer)
    run_count = Column(Integer, default=0)
    success_count = Column(Integer, default=0)
    error_count = Column(Integer, default=0)
    
    # Error handling
    last_error = Column(Text)
    last_error_at = Column(DateTime)
    max_retries = Column(Integer, default=3)
    retry_delay_seconds = Column(Integer, default=60)
    
    # Lifecycle
    created_at = Column(DateTime, nullable=False, default=func.now())
    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
    created_by_user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
    
    # Relationships
    plugin = relationship("Plugin", back_populates="cron_jobs")
    created_by_user = relationship("User")
    
    __table_args__ = (
        Index('idx_plugin_cron_next_run', 'enabled', 'next_run_at'),
        Index('idx_plugin_cron_plugin', 'plugin_id', 'enabled'),
    )


class PluginAPIGateway(Base):
    """API gateway configuration for plugin routing"""
    __tablename__ = "plugin_api_gateways"
    
    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
    plugin_id = Column(UUID(as_uuid=True), ForeignKey("plugins.id"), nullable=False, unique=True)
    
    # API routing configuration
    base_path = Column(String(200), nullable=False, unique=True)  # /api/v1/plugins/zammad
    internal_url = Column(String(500), nullable=False)  # http://plugin-zammad:8000
    
    # Security settings
    require_authentication = Column(Boolean, default=True, nullable=False)
    allowed_methods = Column(JSON, default=["GET", "POST", "PUT", "DELETE"])  # HTTP methods
    rate_limit_per_minute = Column(Integer, default=60)
    rate_limit_per_hour = Column(Integer, default=1000)
    
    # CORS settings
    cors_enabled = Column(Boolean, default=True, nullable=False)
    cors_origins = Column(JSON, default=["*"])
    cors_methods = Column(JSON, default=["GET", "POST", "PUT", "DELETE", "OPTIONS"])
    cors_headers = Column(JSON, default=["*"])
    
    # Circuit breaker settings
    circuit_breaker_enabled = Column(Boolean, default=True, nullable=False)
    failure_threshold = Column(Integer, default=5)
    recovery_timeout_seconds = Column(Integer, default=60)
    
    # Monitoring
    enabled = Column(Boolean, default=True, nullable=False, index=True)
    last_health_check = Column(DateTime)
    health_status = Column(String(20), default="unknown")  # healthy, unhealthy, timeout
    
    # Timestamps
    created_at = Column(DateTime, nullable=False, default=func.now())
    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
    
    # Relationships
    plugin = relationship("Plugin")


# Add relationships to existing User model (import this in user.py)
"""
Add to User model:
    installed_plugins = relationship("Plugin", back_populates="installed_by_user")
"""

# Add relationships to existing APIKey model (import this in api_key.py)
"""
Add to APIKey model:
    plugin_audit_logs = relationship("PluginAuditLog", back_populates="api_key")
"""

class PluginPermission(Base):
    """Plugin permission grants - tracks user permissions for plugins"""
    __tablename__ = "plugin_permissions"
    
    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
    plugin_id = Column(UUID(as_uuid=True), ForeignKey("plugins.id"), nullable=False)
    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
    
    # Permission details
    permission_name = Column(String(200), nullable=False)  # e.g., 'chatbot:invoke', 'rag:query'
    granted = Column(Boolean, default=True, nullable=False)  # True=granted, False=revoked
    
    # Grant/revoke tracking
    granted_at = Column(DateTime, nullable=False, default=func.now())
    granted_by_user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
    revoked_at = Column(DateTime)
    revoked_by_user_id = Column(Integer, ForeignKey("users.id"))
    
    # Metadata
    reason = Column(Text)  # Reason for grant/revocation
    expires_at = Column(DateTime)  # Optional expiration time
    
    # Relationships
    plugin = relationship("Plugin")
    user = relationship("User", foreign_keys=[user_id])
    granted_by_user = relationship("User", foreign_keys=[granted_by_user_id])
    revoked_by_user = relationship("User", foreign_keys=[revoked_by_user_id])
    
    __table_args__ = (
        Index('idx_plugin_permission_user_plugin', 'user_id', 'plugin_id'),
        Index('idx_plugin_permission_plugin_name', 'plugin_id', 'permission_name'),
        Index('idx_plugin_permission_active', 'plugin_id', 'user_id', 'granted'),
    )