from rest_framework import serializers
from .models import Client, ClientContact, ClientDepartment, TicketCategory, TicketSubCategory, ClientEscalationMatrix, ClientConfiguration, ClientDatabase, ClientEmailAccount, ClientNetwork, OutboundEmail


class ClientContactSerializer(serializers.ModelSerializer):
    class Meta:
        model = ClientContact
        fields = '__all__'


class ClientDepartmentSerializer(serializers.ModelSerializer):
    class Meta:
        model = ClientDepartment
        fields = '__all__'


class TicketSubCategorySerializer(serializers.ModelSerializer):
    class Meta:
        model = TicketSubCategory
        fields = '__all__'


class TicketCategorySerializer(serializers.ModelSerializer):
    sub_categories = TicketSubCategorySerializer(many=True, read_only=True)

    class Meta:
        model = TicketCategory
        fields = '__all__'


class EscalationMatrixSerializer(serializers.ModelSerializer):
    class Meta:
        model = ClientEscalationMatrix
        fields = '__all__'


class ClientSerializer(serializers.ModelSerializer):
    contacts = ClientContactSerializer(many=True, read_only=True)
    departments = ClientDepartmentSerializer(many=True, read_only=True)
    ticket_categories = TicketCategorySerializer(many=True, read_only=True)

    class Meta:
        model = Client
        fields = '__all__'


class ClientListSerializer(serializers.ModelSerializer):
    class Meta:
        model = Client
        fields = ['id', 'name', 'code', 'industry', 'website', 'address', 'tier', 'is_active', 'created_at']


class ClientConfigurationSerializer(serializers.ModelSerializer):
    class Meta:
        model = ClientConfiguration
        fields = '__all__'
        # probe_last_seen is written only by the pfSense poll endpoint — it's
        # evidence, so a client must not be able to fake it.
        read_only_fields = ['client', 'updated_at', 'probe_last_seen']


class ClientNetworkSerializer(serializers.ModelSerializer):
    install_command = serializers.SerializerMethodField()

    def validate_gateway_name(self, value):
        """One connection per gateway, per client.

        Two connections claiming the same gateway made the match ambiguous —
        telemetry went to whichever row came back first, with nothing to
        indicate a problem. Reject the duplicate instead.
        """
        gw = (value or '').strip()
        if not gw:
            return ''
        client_id = (self.initial_data.get('client')
                     or getattr(self.instance, 'client_id', None))
        if not client_id:
            return gw
        clash = ClientNetwork.objects.filter(client_id=client_id, gateway_name__iexact=gw)
        if self.instance is not None:
            clash = clash.exclude(pk=self.instance.pk)
        other = clash.first()
        if other:
            raise serializers.ValidationError(
                f'"{other.name}" is already synced to gateway {other.gateway_name}. '
                f'Unlink it there first, or pick a different gateway.')
        return gw

    class Meta:
        model = ClientNetwork
        fields = ['id', 'client', 'name', 'isp', 'static_ip', 'ssh_port',
                  'extra_ping_targets', 'notes', 'is_primary', 'is_active', 'created_at',
                  # Optional pfSense sync, set after the connection exists.
                  'gateway_name', 'monitor_key', 'install_command',
                  # Legacy fields, kept so older records still round-trip.
                  'pfsense_wan_ip', 'pfsense_admin_url', 'pfsense_lan_subnet', 'starlink_ip']
        # monitor_key is generated by the model; editing it would orphan an
        # already-installed pfSense, so it is display-only.
        read_only_fields = ['id', 'created_at', 'monitor_key']

    def get_install_command(self, obj):
        """One-liner to paste into THIS network's pfSense shell."""
        import os
        domain = os.environ.get('DOMAIN', 'altriacallcenter.com')
        host = domain if domain.startswith('crm.') else f'crm.{domain}'
        return (f'curl -s "https://{host}/pfsense-script/'
                f'?secret=YOUR_WEBHOOK_SECRET&key={obj.monitor_key}" '
                f'-o /usr/local/bin/crm_gateway_check.sh && '
                f'chmod +x /usr/local/bin/crm_gateway_check.sh')


class _SecretPreservingMixin:
    """Never echo stored secrets back, and never wipe one by accident.

    Secret fields are write-only, so they are absent from every API response.
    On update, a secret that is omitted OR sent blank is dropped from the
    payload so the stored value survives — the UI can then leave the box empty
    to mean "keep the current password". A companion ``<field>_set`` boolean is
    exposed so the UI can show whether one is stored.
    """
    secret_fields = ()

    def update(self, instance, validated_data):
        for f in self.secret_fields:
            if not (validated_data.get(f) or '').strip():
                validated_data.pop(f, None)
        return super().update(instance, validated_data)


class ClientDatabaseSerializer(_SecretPreservingMixin, serializers.ModelSerializer):
    secret_fields = ('db_pass',)
    db_pass_set = serializers.SerializerMethodField(read_only=True)

    def get_db_pass_set(self, obj):
        return bool(obj.db_pass)

    class Meta:
        model = ClientDatabase
        fields = ['id', 'client', 'name', 'host', 'port', 'db_name', 'db_user',
                  'db_pass', 'db_pass_set', 'created_at']
        read_only_fields = ['id', 'created_at', 'db_pass_set']
        extra_kwargs = {
            'db_pass': {'write_only': True, 'required': False, 'allow_blank': True},
        }


class ClientEmailAccountSerializer(_SecretPreservingMixin, serializers.ModelSerializer):
    secret_fields = ('imap_pass', 'smtp_pass')
    assigned_agent_name = serializers.SerializerMethodField(read_only=True)
    imap_pass_set = serializers.SerializerMethodField(read_only=True)
    smtp_pass_set = serializers.SerializerMethodField(read_only=True)

    def get_assigned_agent_name(self, obj):
        if obj.assigned_agent:
            return obj.assigned_agent.get_full_name() or obj.assigned_agent.username
        return None

    def get_imap_pass_set(self, obj):
        return bool(obj.imap_pass)

    def get_smtp_pass_set(self, obj):
        return bool(obj.smtp_pass)

    class Meta:
        model = ClientEmailAccount
        fields = ['id', 'client', 'name', 'email',
                  'imap_host', 'imap_port', 'imap_user', 'imap_pass', 'imap_pass_set',
                  'imap_ssl', 'imap_folder',
                  'smtp_host', 'smtp_port', 'smtp_user', 'smtp_pass', 'smtp_pass_set',
                  'smtp_tls',
                  'assigned_agent', 'assigned_agent_name',
                  'is_active', 'created_at']
        read_only_fields = ['id', 'created_at', 'assigned_agent_name',
                            'imap_pass_set', 'smtp_pass_set']
        extra_kwargs = {
            'imap_pass': {'write_only': True, 'required': False, 'allow_blank': True},
            'smtp_pass': {'write_only': True, 'required': False, 'allow_blank': True},
        }


class OutboundEmailSerializer(serializers.ModelSerializer):
    """Compose payload in, sent-log row out.

    ``account`` is validated against the caller's own client in the view, not
    here — the serializer has no reliable view of tenant scope.
    """
    sender_name  = serializers.SerializerMethodField(read_only=True)
    account_name = serializers.SerializerMethodField(read_only=True)
    from_email   = serializers.SerializerMethodField(read_only=True)

    class Meta:
        model = OutboundEmail
        fields = ['id', 'client', 'account', 'account_name', 'from_email', 'sender',
                  'sender_name', 'to_emails', 'cc_emails', 'subject', 'body',
                  'ai_assisted', 'status', 'message_id', 'error', 'ticket',
                  'created_at', 'sent_at']
        read_only_fields = ['client', 'sender', 'status', 'message_id', 'error',
                            'created_at', 'sent_at']

    def get_sender_name(self, obj):
        if obj.sender:
            return obj.sender.get_full_name() or obj.sender.username
        return None

    def get_account_name(self, obj):
        return obj.account.name if obj.account else None

    def get_from_email(self, obj):
        return obj.account.email if obj.account else None

    def validate_to_emails(self, value):
        from core.outbound import _addr_list
        addrs = _addr_list(value)
        if not addrs:
            raise serializers.ValidationError('At least one recipient is required.')
        bad = [a for a in addrs if '@' not in a or a.startswith('@') or a.endswith('@')]
        if bad:
            raise serializers.ValidationError(f"Not a valid email address: {', '.join(bad)}")
        return ', '.join(addrs)

    def validate_subject(self, value):
        if not (value or '').strip():
            raise serializers.ValidationError('Subject is required.')
        return value.strip()

    def validate_body(self, value):
        if not (value or '').strip():
            raise serializers.ValidationError('Message body is required.')
        return value
