"""
Module Registry Serializers - API serialization for modules and features.
"""
from rest_framework import serializers

from .models import Module, TenantModule, Feature, TenantFeatureOverride, LicenseType


class ModuleSerializer(serializers.ModelSerializer):
    """Serializer for Module model."""
    
    status_display = serializers.CharField(source='get_status_display', read_only=True)
    features_count = serializers.SerializerMethodField()
    
    class Meta:
        model = Module
        fields = [
            'id',
            'name',
            'display_name',
            'code',
            'is_core',
            'description',
            'version',
            'status',
            'status_display',
            'module_category',
            'category',
            'tags',
            'icon',
            'color',
            'api_prefix',
            'supported_api_versions',
            'features_count',
            'created_at',
            'updated_at',
        ]
        read_only_fields = ['created_at', 'updated_at']
    
    def get_features_count(self, obj):
        """Get count of features for this module."""
        return obj.features.count()


class ModuleDetailSerializer(ModuleSerializer):
    """Detailed serializer for Module with features."""
    
    features = serializers.SerializerMethodField()
    dependencies = serializers.SerializerMethodField()
    
    class Meta(ModuleSerializer.Meta):
        fields = ModuleSerializer.Meta.fields + [
            'default_settings',
            'features',
            'dependencies',
            'published_events',
            'consumed_events',
        ]
    
    def get_features(self, obj):
        """Get list of features."""
        features = obj.features.filter(is_enabled=True)
        return FeatureSerializer(features, many=True).data
    
    def get_dependencies(self, obj):
        """Get list of dependencies."""
        return [
            {
                'name': dep.name,
                'display_name': dep.display_name,
                'status': dep.status,
            }
            for dep in obj.dependencies.all()
        ]


class FeatureSerializer(serializers.ModelSerializer):
    """Serializer for Feature model."""
    
    class Meta:
        model = Feature
        fields = [
            'id',
            'name',
            'display_name',
            'description',
            'is_enabled',
            'minimum_license',
            'rollout_percentage',
            'created_at',
        ]
        read_only_fields = ['created_at']


class TenantModuleSerializer(serializers.ModelSerializer):
    """Serializer for TenantModule."""
    
    module_name = serializers.CharField(source='module.name', read_only=True)
    module_display_name = serializers.CharField(source='module.display_name', read_only=True)
    license_type_display = serializers.CharField(source='get_license_type_display', read_only=True)
    is_active = serializers.SerializerMethodField()
    days_remaining = serializers.SerializerMethodField()
    
    class Meta:
        model = TenantModule
        fields = [
            'id',
            'module',
            'module_name',
            'module_display_name',
            'is_enabled',
            'license_type',
            'license_type_display',
            'license_key',
            'expires_at',
            'is_active',
            'days_remaining',
            'enabled_features',
            'disabled_features',
            'settings',
            'config_override',
            'license_limit',
            'usage_stats',
            'created_at',
            'updated_at',
        ]
        read_only_fields = ['created_at', 'updated_at']
    
    def get_is_active(self, obj):
        """Check if module license is active."""
        return obj.is_active()
    
    def get_days_remaining(self, obj):
        """Get days remaining on license."""
        return obj.days_remaining()


class TenantModuleEnableSerializer(serializers.Serializer):
    """Serializer for enabling a module for a tenant."""
    
    module_name = serializers.CharField()
    license_type = serializers.ChoiceField(
        choices=LicenseType.choices,
        default=LicenseType.TRIAL
    )
    license_key = serializers.CharField(required=False, allow_blank=True)
    expires_at = serializers.DateTimeField(required=False, allow_null=True)
    enabled_features = serializers.ListField(
        child=serializers.CharField(),
        required=False,
        default=list
    )
    settings = serializers.DictField(required=False, default=dict)
    
    def validate_module_name(self, value):
        """Validate module exists."""
        if not Module.objects.filter(name=value, status='active').exists():
            raise serializers.ValidationError(f"Module '{value}' not found or not active.")
        return value


class TenantFeatureOverrideSerializer(serializers.ModelSerializer):
    """Serializer for TenantFeatureOverride."""
    
    feature_name = serializers.CharField(source='feature.name', read_only=True)
    feature_display_name = serializers.CharField(source='feature.display_name', read_only=True)
    
    class Meta:
        model = TenantFeatureOverride
        fields = [
            'id',
            'feature',
            'feature_name',
            'feature_display_name',
            'is_enabled',
            'reason',
            'expires_at',
            'created_at',
        ]
        read_only_fields = ['created_at']


class FeatureToggleSerializer(serializers.Serializer):
    """Serializer for toggling a feature."""
    
    module_name = serializers.CharField()
    feature_name = serializers.CharField()
    is_enabled = serializers.BooleanField()
    reason = serializers.CharField(required=False, allow_blank=True, default='')
    expires_at = serializers.DateTimeField(required=False, allow_null=True)
    
    def validate(self, data):
        """Validate feature exists."""
        if not Feature.objects.filter(
            module__name=data['module_name'],
            name=data['feature_name']
        ).exists():
            raise serializers.ValidationError({
                'feature_name': f"Feature '{data['feature_name']}' not found in module '{data['module_name']}'."
            })
        return data


class ModuleStatusSerializer(serializers.Serializer):
    """Serializer for module status response."""
    
    module = ModuleSerializer()
    tenant_module = TenantModuleSerializer(allow_null=True)
    enabled_features = serializers.ListField(child=serializers.CharField())
    is_accessible = serializers.BooleanField()