"""HTTPS Configuration model."""
from datetime import datetime
from typing import Optional

from app.extensions import db


class HTTPSConfig(db.Model):
    """HTTPS configuration model for managing secure connections.
    
    Attributes:
        id: Primary key
        https_enabled: Whether HTTPS is enabled
        hostname: Server hostname (e.g., 'digiserver')
        domain: Full domain name (e.g., 'digiserver.sibiusb.harting.intra')
        ip_address: IP address for direct access
        email: Email address for SSL certificate notifications
        port: HTTPS port (default 443)
        created_at: Creation timestamp
        updated_at: Last update timestamp
        updated_by: User who made the last update
    """
    __tablename__ = 'https_config'
    
    id = db.Column(db.Integer, primary_key=True)
    https_enabled = db.Column(db.Boolean, default=False, nullable=False)
    hostname = db.Column(db.String(255), nullable=True)
    domain = db.Column(db.String(255), nullable=True)
    ip_address = db.Column(db.String(45), nullable=True)  # Support IPv6
    email = db.Column(db.String(255), nullable=True)
    port = db.Column(db.Integer, default=443, nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
    updated_at = db.Column(db.DateTime, default=datetime.utcnow, 
                          onupdate=datetime.utcnow, nullable=False)
    updated_by = db.Column(db.String(255), nullable=True)
    
    def __repr__(self) -> str:
        """String representation of HTTPSConfig."""
        status = 'ENABLED' if self.https_enabled else 'DISABLED'
        return f'<HTTPSConfig [{status}] {self.domain or "N/A"}>'
    
    @classmethod
    def get_config(cls) -> Optional['HTTPSConfig']:
        """Get the current HTTPS configuration.
        
        Returns:
            HTTPSConfig instance or None if not configured
        """
        return cls.query.first()
    
    @classmethod
    def create_or_update(cls, https_enabled: bool, hostname: str = None,
                        domain: str = None, ip_address: str = None,
                        email: str = None, port: int = 443, 
                        updated_by: str = None) -> 'HTTPSConfig':
        """Create or update HTTPS configuration.
        
        Args:
            https_enabled: Whether HTTPS is enabled
            hostname: Server hostname
            domain: Full domain name
            ip_address: IP address
            email: Email for SSL certificates
            port: HTTPS port
            updated_by: Username of who made the update
            
        Returns:
            HTTPSConfig instance
        """
        config = cls.get_config()
        if not config:
            config = cls()
        
        config.https_enabled = https_enabled
        config.hostname = hostname
        config.domain = domain
        config.ip_address = ip_address
        config.email = email
        config.port = port
        config.updated_by = updated_by
        config.updated_at = datetime.utcnow()
        
        db.session.add(config)
        db.session.commit()
        return config
    
    def to_dict(self) -> dict:
        """Convert configuration to dictionary.
        
        Returns:
            Dictionary representation of config
        """
        return {
            'id': self.id,
            'https_enabled': self.https_enabled,
            'hostname': self.hostname,
            'domain': self.domain,
            'ip_address': self.ip_address,
            'email': self.email,
            'port': self.port,
            'created_at': self.created_at.isoformat() if self.created_at else None,
            'updated_at': self.updated_at.isoformat() if self.updated_at else None,
            'updated_by': self.updated_by,
        }