# -*- coding: utf-8 -*-
"""
Core API Serializers Module

This module contains DRF serializers for core application models.
Provides serialization/deserialization for API endpoints.
"""

from rest_framework import serializers
from django.contrib.auth import get_user_model
from django.utils.translation import gettext_lazy as _
from django.utils import timezone

from apps.core.models import (
    SystemConfiguration,
    ApplicationMetrics,
    AuditLog,
    NotificationTemplate,
    SystemHealth
)
from apps.accounts.models import Role, LoginAttempt, UserSession

User = get_user_model()


class SystemConfigurationSerializer(serializers.ModelSerializer):
    """
    Serializer for SystemConfiguration model.
    
    Provides serialization for system configuration settings
    with appropriate field validation and permissions.
    """
    
    created_by_email = serializers.CharField(
        source='created_by.email',
        read_only=True
    )
    
    updated_by_email = serializers.CharField(
        source='updated_by.email',
        read_only=True
    )
    
    class Meta:
        model = SystemConfiguration
        fields = [
            'id',
            'key',
            'value',
            'description',
            'is_active',
            'created_at',
            'updated_at',
            'created_by_email',
            'updated_by_email'
        ]
        read_only_fields = [
            'id',
            'created_at',
            'updated_at',
            'created_by_email',
            'updated_by_email'
        ]
    
    def validate_key(self, value):
        """
        Validate configuration key format.
        
        Args:
            value: Configuration key value
            
        Returns:
            str: Validated key
            
        Raises:
            ValidationError: If key format is invalid
        """
        if not value.replace('_', '').replace('-', '').isalnum():
            raise serializers.ValidationError(
                _("Configuration key must contain only alphanumeric characters, hyphens, and underscores.")
            )
        return value.upper()
    
    def validate(self, attrs):
        """
        Validate configuration data.
        
        Args:
            attrs: Attribute dictionary
            
        Returns:
            dict: Validated attributes
        """
        # Check for duplicate keys on creation
        if not self.instance:
            key = attrs.get('key')
            if key and SystemConfiguration.objects.filter(key=key).exists():
                raise serializers.ValidationError({
                    'key': _("Configuration with this key already exists.")
                })
        
        return attrs


class ApplicationMetricsSerializer(serializers.ModelSerializer):
    """
    Serializer for ApplicationMetrics model.
    
    Read-only serializer for viewing application metrics data.
    """
    
    class Meta:
        model = ApplicationMetrics
        fields = [
            'metric_name',
            'metric_value',
            'metric_type',
            'tags',
            'timestamp'
        ]
        read_only_fields = '__all__'


class AuditLogSerializer(serializers.ModelSerializer):
    """
    Serializer for AuditLog model.
    
    Read-only serializer for viewing audit log entries.
    """
    
    user_email = serializers.CharField(
        source='user.email',
        read_only=True
    )
    
    user_full_name = serializers.SerializerMethodField()
    
    class Meta:
        model = AuditLog
        fields = [
            'id',
            'user_email',
            'user_full_name',
            'action',
            'resource_type',
            'resource_id',
            'ip_address',
            'user_agent',
            'details',
            'success',
            'created_at'
        ]
        read_only_fields = '__all__'
    
    def get_user_full_name(self, obj):
        """
        Get user's full name for display.
        
        Args:
            obj: AuditLog instance
            
        Returns:
            str: User's full name or 'System'
        """
        if obj.user:
            return f"{obj.user.first_name} {obj.user.last_name}".strip() or obj.user.email
        return "System"


class NotificationTemplateSerializer(serializers.ModelSerializer):
    """
    Serializer for NotificationTemplate model.
    
    Provides serialization for notification templates with
    validation for template variables and content.
    """
    
    created_by_email = serializers.CharField(
        source='created_by.email',
        read_only=True
    )
    
    updated_by_email = serializers.CharField(
        source='updated_by.email',
        read_only=True
    )
    
    class Meta:
        model = NotificationTemplate
        fields = [
            'id',
            'name',
            'subject',
            'body_text',
            'body_html',
            'notification_type',
            'variables',
            'is_active',
            'created_at',
            'updated_at',
            'created_by_email',
            'updated_by_email'
        ]
        read_only_fields = [
            'id',
            'created_at',
            'updated_at',
            'created_by_email',
            'updated_by_email'
        ]
    
    def validate_variables(self, value):
        """
        Validate template variables format.
        
        Args:
            value: Variables list
            
        Returns:
            list: Validated variables
            
        Raises:
            ValidationError: If variables format is invalid
        """
        if not isinstance(value, list):
            raise serializers.ValidationError(
                _("Variables must be a list of strings.")
            )
        
        for var in value:
            if not isinstance(var, str) or not var.strip():
                raise serializers.ValidationError(
                    _("Each variable must be a non-empty string.")
                )
        
        return value
    
    def validate(self, attrs):
        """
        Validate notification template data.
        
        Args:
            attrs: Attribute dictionary
            
        Returns:
            dict: Validated attributes
        """
        # Check for duplicate names on creation
        if not self.instance:
            name = attrs.get('name')
            if name and NotificationTemplate.objects.filter(name=name).exists():
                raise serializers.ValidationError({
                    'name': _("Notification template with this name already exists.")
                })
        
        # Validate that HTML body is provided for email notifications
        notification_type = attrs.get('notification_type', 'email')
        body_html = attrs.get('body_html', '')
        
        if notification_type == 'email' and not body_html.strip():
            attrs['body_html'] = attrs.get('body_text', '')
        
        return attrs


class SystemHealthSerializer(serializers.ModelSerializer):
    """
    Serializer for SystemHealth model.
    
    Read-only serializer for viewing system health metrics.
    """
    
    status_display = serializers.CharField(
        source='get_status_display',
        read_only=True
    )
    
    class Meta:
        model = SystemHealth
        fields = [
            'service_name',
            'status',
            'status_display',
            'response_time',
            'cpu_usage',
            'memory_usage',
            'disk_usage',
            'additional_metrics',
            'created_at'
        ]
        read_only_fields = '__all__'


class SystemHealthSummarySerializer(serializers.Serializer):
    """
    Serializer for system health summary data.
    """
    
    total_services = serializers.IntegerField()
    healthy_services = serializers.IntegerField()
    warning_services = serializers.IntegerField()
    critical_services = serializers.IntegerField()
    unknown_services = serializers.IntegerField()
    overall_status = serializers.CharField()
    last_updated = serializers.DateTimeField()


class DashboardStatsSerializer(serializers.Serializer):
    """
    Serializer for enhanced dashboard statistics.
    """
    
    user_stats = serializers.DictField()
    system_stats = serializers.DictField()
    health_summary = serializers.DictField(allow_null=True)
    recent_activities = serializers.ListField()
    timestamp = serializers.DateTimeField()