import hashlib
import re
from datetime import timedelta
from django.utils import timezone
from django.db import transaction
from django.db.models import Max, Q
from django.contrib.auth import get_user_model
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from rest_framework.permissions import AllowAny
from rest_framework.pagination import PageNumberPagination

from core.exceptions import format_error_response
from core.permissions import IsVerified
from .models import Inbox, AnonymousMessage, Conversation, DirectMessage, ConversationReadState
from .serializers import (
    PublicInboxSerializer, AnonymousMessageSubmitSerializer,
    OwnerMessageSerializer, InboxSettingsSerializer,
    ConversationDetailSerializer, DirectMessageSerializer, SendDirectMessageSerializer,
)
from core.security_services import rate_limit, verify_captcha, ip_hash, log_security_event, RetryAfter, CaptchaUnavailable
from moderation.services import evaluate_content

User = get_user_model()


# ---------------------------------------------------------------------------
# Public Inbox Views
# ---------------------------------------------------------------------------

class PublicInboxView(APIView):
    permission_classes = [AllowAny]

    def get(self, request, slug):
        inbox = Inbox.objects.filter(slug__iexact=slug).select_related('owner', 'owner__profile').first()
        if not inbox:
            return format_error_response("inbox_not_found", "Inbox not found.", status_code=status.HTTP_404_NOT_FOUND)

        if inbox.owner.is_suspended:
            return format_error_response("inbox_unavailable", "This inbox is unavailable.", status_code=status.HTTP_404_NOT_FOUND)

        serializer = PublicInboxSerializer(inbox, context={'request': request})
        return Response(serializer.data)


class PublicInboxSubmitMessageView(APIView):
    permission_classes = [AllowAny]

    def post(self, request, slug):
        inbox = Inbox.objects.filter(slug__iexact=slug).select_related('owner').first()
        if not inbox:
            return format_error_response("inbox_not_found", "Inbox not found.", status_code=status.HTTP_404_NOT_FOUND)

        if inbox.owner.is_suspended:
            return format_error_response("inbox_unavailable", "This inbox is unavailable.", status_code=status.HTTP_404_NOT_FOUND)

        serializer = AnonymousMessageSubmitSerializer(data=request.data)
        if not serializer.is_valid():
            fields = {k: v[0] if isinstance(v, list) else str(v) for k, v in serializer.errors.items()}
            return format_error_response("validation_error", "Validation failed.", fields=fields, status_code=status.HTTP_400_BAD_REQUEST)

        # 1. Honeypot check
        honeypot = serializer.validated_data.get('website', '').strip()
        if honeypot:
            log_security_event('honeypot_hit', request=request, meta={'target_slug': slug})
            return Response({"message": "Message submitted."}, status=status.HTTP_201_CREATED)

        client_ip_hash = ip_hash(request)

        # 2. Rate limits (per IP hash: 5 per 10 min; per inbox: 20 per day)
        try:
            rate_limit(f"anon_submit_ip:{client_ip_hash}", limit=5, window_seconds=600)
            rate_limit(f"anon_submit_inbox:{inbox.id}", limit=20, window_seconds=86400)
        except RetryAfter as e:
            log_security_event('rate_limited', request=request, meta={'scope': 'anon_submit', 'retry_after': e.retry_after})
            resp = format_error_response("rate_limited", f"Rate limit exceeded. Try again in {e.retry_after} seconds.", status_code=status.HTTP_429_TOO_MANY_REQUESTS)
            resp['Retry-After'] = str(e.retry_after)
            return resp

        # 3. CAPTCHA verification (fails closed)
        captcha_token = request.data.get('captcha_token', '')
        try:
            if not verify_captcha(captcha_token, remote_hash=client_ip_hash):
                log_security_event('captcha_failed', request=request, meta={'scope': 'anon_submit'})
                return format_error_response("captcha_invalid", "Invalid CAPTCHA token.", status_code=status.HTTP_400_BAD_REQUEST)
        except CaptchaUnavailable:
            log_security_event('captcha_unavailable', request=request, meta={'scope': 'anon_submit'})
            return format_error_response("captcha_unavailable", "CAPTCHA provider is unavailable. Please try again later.", status_code=status.HTTP_503_SERVICE_UNAVAILABLE)

        # 4. Length check (already enforced by serializer max 500)
        raw_body = serializer.validated_data['body']

        # 5. Submissions enabled check
        if not inbox.anonymous_enabled:
            return format_error_response("submissions_disabled", "Submissions are currently disabled for this inbox.", status_code=status.HTTP_403_FORBIDDEN)

        # 6. Duplicate check: normalized body from same IP hash to same inbox in 24h
        normalized_body = re.sub(r'\s+', ' ', raw_body.strip().lower())
        computed_body_hash = hashlib.sha256(normalized_body.encode('utf-8')).hexdigest()

        twenty_four_hours_ago = timezone.now() - timedelta(hours=24)
        duplicate_exists = AnonymousMessage.objects.filter(
            inbox=inbox,
            sender_ip_hash=client_ip_hash,
            body_hash=computed_body_hash,
            created_at__gte=twenty_four_hours_ago
        ).exists()

        if duplicate_exists:
            return format_error_response("duplicate_message", "Duplicate message detected.", status_code=status.HTTP_409_CONFLICT)

        # 7. Content check
        action = evaluate_content(raw_body)
        if action == 'reject':
            return format_error_response("content_not_allowed", "Message contains content that is not allowed.", status_code=status.HTTP_400_BAD_REQUEST)

        msg_status = 'held' if action == 'hold' else 'visible'

        # 8. Store message
        created_msg = AnonymousMessage.objects.create(
            inbox=inbox,
            body=raw_body,
            status=msg_status,
            sender_ip_hash=client_ip_hash,
            sender_ip_salt_date=timezone.now().date(),
            body_hash=computed_body_hash
        )

        # 9. Trigger notification for inbox owner if message is visible
        if msg_status == 'visible':
            try:
                from notifications.services import create_notification
                create_notification(
                    user=inbox.owner,
                    notification_type='anonymous_message',
                    title='New Chithie',
                    body=raw_body[:100],
                    target_url='/messages/anon'
                )
            except Exception:
                pass

        return Response({"message": "Message submitted successfully."}, status=status.HTTP_201_CREATED)


# ---------------------------------------------------------------------------
# Owner Inbox Views
# ---------------------------------------------------------------------------

class OwnerInboxSettingsView(APIView):
    permission_classes = [IsVerified]

    def get(self, request):
        inbox, _ = Inbox.objects.get_or_create(owner=request.user, defaults={'slug': request.user.username})
        return Response(InboxSettingsSerializer(inbox).data)

    def patch(self, request):
        inbox, _ = Inbox.objects.get_or_create(owner=request.user, defaults={'slug': request.user.username})
        serializer = InboxSettingsSerializer(inbox, data=request.data, partial=True)
        if not serializer.is_valid():
            fields = {k: v[0] if isinstance(v, list) else str(v) for k, v in serializer.errors.items()}
            return format_error_response("validation_error", "Invalid data.", fields=fields, status_code=status.HTTP_400_BAD_REQUEST)
        serializer.save()
        return Response(InboxSettingsSerializer(inbox).data)


class OwnerInboxMessagePagination(PageNumberPagination):
    page_size = 20
    page_size_query_param = 'page_size'
    max_page_size = 50


class OwnerInboxMessagesView(APIView):
    permission_classes = [IsVerified]

    def get(self, request):
        inbox = Inbox.objects.filter(owner=request.user).first()
        if not inbox:
            return Response({"count": 0, "unread_count": 0, "results": []})

        queryset = AnonymousMessage.objects.filter(inbox=inbox, status='visible').order_by('-created_at')
        unread_count = AnonymousMessage.objects.filter(inbox=inbox, status='visible', is_read=False).count()

        paginator = OwnerInboxMessagePagination()
        page = paginator.paginate_queryset(queryset, request)
        serializer = OwnerMessageSerializer(page, many=True)
        resp = paginator.get_paginated_response(serializer.data)
        resp.data['unread_count'] = unread_count
        return resp

    def post(self, request):
        """
        Mark messages in the owner's inbox as read.
        If 'message_ids' provided, marks specific messages read.
        If empty or omitted, marks all visible unread messages in this inbox as read.
        """
        inbox = Inbox.objects.filter(owner=request.user).first()
        if not inbox:
            return Response({"message": "No inbox found.", "marked_count": 0})

        message_ids = request.data.get('message_ids')
        qs = AnonymousMessage.objects.filter(inbox=inbox, status='visible', is_read=False)
        if message_ids and isinstance(message_ids, list):
            qs = qs.filter(id__in=message_ids)

        updated_count = qs.update(is_read=True)
        return Response({"message": "Messages marked as read.", "marked_count": updated_count})

    def patch(self, request):
        """
        Mark specific messages as unread.
        Requires 'message_ids' (list of ids) in the request body.
        """
        inbox = Inbox.objects.filter(owner=request.user).first()
        if not inbox:
            return Response({"message": "No inbox found.", "marked_count": 0})

        message_ids = request.data.get('message_ids')
        if not message_ids or not isinstance(message_ids, list):
            return format_error_response(
                "validation_error", "message_ids (list) is required.",
                status_code=status.HTTP_400_BAD_REQUEST
            )

        updated_count = AnonymousMessage.objects.filter(
            inbox=inbox, id__in=message_ids, status='visible'
        ).update(is_read=False)
        return Response({"message": "Messages marked as unread.", "marked_count": updated_count})


class OwnerInboxMessageDetailView(APIView):
    permission_classes = [IsVerified]

    def get_message(self, request, pk):
        msg = AnonymousMessage.objects.filter(id=pk, status='visible').select_related('inbox').first()
        if not msg:
            return None, format_error_response("message_not_found", "Message not found.", status_code=status.HTTP_404_NOT_FOUND)
        if msg.inbox.owner_id != request.user.id:
            return None, format_error_response("permission_denied", "You do not have permission to view this message.", status_code=status.HTTP_403_FORBIDDEN)
        return msg, None

    def get(self, request, pk):
        msg, err = self.get_message(request, pk)
        if err:
            return err

        if not msg.is_read:
            msg.is_read = True
            msg.save(update_fields=['is_read'])

        return Response(OwnerMessageSerializer(msg).data)

    def delete(self, request, pk):
        msg, err = self.get_message(request, pk)
        if err:
            return err

        # Soft delete: set status to hidden
        msg.status = 'hidden'
        msg.save(update_fields=['status'])
        return Response({"message": "Message deleted."})


# ---------------------------------------------------------------------------
# Direct Messaging Views
# ---------------------------------------------------------------------------

class ConversationPagination(PageNumberPagination):
    page_size = 20
    page_size_query_param = 'page_size'
    max_page_size = 50


class ConversationListView(APIView):
    permission_classes = [IsVerified]

    def get(self, request):
        user = request.user
        conversations = Conversation.objects.filter(
            Q(user_low=user) | Q(user_high=user)
        ).annotate(
            latest_msg_time=Max('messages__created_at')
        ).order_by('-latest_msg_time', '-created_at')

        paginator = ConversationPagination()
        page = paginator.paginate_queryset(conversations, request)
        serializer = ConversationDetailSerializer(page, many=True, context={'request': request})
        return paginator.get_paginated_response(serializer.data)

    def post(self, request):
        target_username = request.data.get('username', '').strip().lower()
        if not target_username:
            return format_error_response("validation_error", "Username is required.", fields={"username": "Username is required."})

        target_user = User.objects.filter(username__iexact=target_username).first()
        if not target_user:
            return format_error_response("user_not_found", "User not found.", status_code=status.HTTP_404_NOT_FOUND)

        if target_user.id == request.user.id:
            return format_error_response("invalid_recipient", "Cannot start a conversation with yourself.", status_code=status.HTTP_400_BAD_REQUEST)

        with transaction.atomic():
            conv, _ = Conversation.get_or_create_for_users(request.user, target_user)

        serializer = ConversationDetailSerializer(conv, context={'request': request})
        return Response(serializer.data, status=status.HTTP_200_OK)


class ConversationMessageListView(APIView):
    permission_classes = [IsVerified]

    def get_conversation(self, request, pk):
        conv = Conversation.objects.filter(id=pk).select_related('user_low', 'user_high').first()
        if not conv:
            return None, format_error_response("conversation_not_found", "Conversation not found.", status_code=status.HTTP_404_NOT_FOUND)
        if request.user.id != conv.user_low_id and request.user.id != conv.user_high_id:
            return None, format_error_response("permission_denied", "You are not a participant in this conversation.", status_code=status.HTTP_403_FORBIDDEN)
        return conv, None

    def get(self, request, pk):
        conv, err = self.get_conversation(request, pk)
        if err:
            return err

        user = request.user
        after_id = request.query_params.get('after')

        qs = DirectMessage.objects.filter(conversation=conv).order_by('id')
        if user.id == conv.user_low_id:
            qs = qs.exclude(deleted_by_sender=True, sender=user).exclude(deleted_by_recipient=True, sender=conv.user_high)
        else:
            qs = qs.exclude(deleted_by_sender=True, sender=user).exclude(deleted_by_recipient=True, sender=conv.user_low)

        if after_id and after_id.isdigit():
            qs = qs.filter(id__gt=int(after_id))

        messages = list(qs[:50])
        serializer = DirectMessageSerializer(messages, many=True)

        other_user = conv.get_other_user(user)
        is_other_suspended = other_user.is_suspended if other_user else False

        return Response({
            "results": serializer.data,
            "read_only": is_other_suspended,
            "notice": "This participant's account is suspended. The conversation is read-only." if is_other_suspended else ""
        })

    def post(self, request, pk):
        # 30 messages per minute per user send limit
        try:
            rate_limit(f"dm_send:{request.user.id}", limit=30, window_seconds=60)
        except RetryAfter as e:
            log_security_event('rate_limited', request=request, user=request.user, meta={'scope': 'dm_send', 'retry_after': e.retry_after})
            resp = format_error_response("rate_limited", f"Rate limit exceeded. Try again in {e.retry_after} seconds.", status_code=status.HTTP_429_TOO_MANY_REQUESTS)
            resp['Retry-After'] = str(e.retry_after)
            return resp

        conv, err = self.get_conversation(request, pk)
        if err:
            return err

        other_user = conv.get_other_user(request.user)
        if other_user and other_user.is_suspended:
            return format_error_response("conversation_read_only", "Cannot send messages to a suspended user.", status_code=status.HTTP_400_BAD_REQUEST)

        serializer = SendDirectMessageSerializer(data=request.data)
        if not serializer.is_valid():
            fields = {k: v[0] if isinstance(v, list) else str(v) for k, v in serializer.errors.items()}
            return format_error_response("validation_error", "Validation failed.", fields=fields, status_code=status.HTTP_400_BAD_REQUEST)

        msg = DirectMessage.objects.create(
            conversation=conv,
            sender=request.user,
            body=serializer.validated_data['body']
        )
        ConversationReadState.objects.update_or_create(
            conversation=conv,
            user=request.user,
            defaults={'last_read_message_id': msg.id}
        )

        # Trigger notification for the recipient
        if other_user and not other_user.is_suspended:
            try:
                from notifications.services import create_notification
                sender_name = getattr(request.user, 'username', 'Someone')
                create_notification(
                    user=other_user,
                    notification_type='direct_message',
                    title=f"New message from @{sender_name}",
                    body=serializer.validated_data['body'][:100],
                    target_url=f"/messages/{conv.id}"
                )
            except Exception:
                pass

        return Response(DirectMessageSerializer(msg).data, status=status.HTTP_201_CREATED)


class DeleteDirectMessageView(APIView):
    permission_classes = [IsVerified]

    def delete(self, request, pk, mid):
        conv = Conversation.objects.filter(id=pk).first()
        if not conv:
            return format_error_response("conversation_not_found", "Conversation not found.", status_code=status.HTTP_404_NOT_FOUND)
        if request.user.id != conv.user_low_id and request.user.id != conv.user_high_id:
            return format_error_response("permission_denied", "You are not a participant in this conversation.", status_code=status.HTTP_403_FORBIDDEN)

        msg = DirectMessage.objects.filter(id=mid, conversation=conv).first()
        if not msg:
            return format_error_response("message_not_found", "Message not found.", status_code=status.HTTP_404_NOT_FOUND)

        msg.mark_deleted_for(request.user)
        return Response({"message": "Message deleted for you."})


class UpdateReadStateView(APIView):
    permission_classes = [IsVerified]

    def post(self, request, pk):
        conv = Conversation.objects.filter(id=pk).first()
        if not conv:
            return format_error_response("conversation_not_found", "Conversation not found.", status_code=status.HTTP_404_NOT_FOUND)
        if request.user.id != conv.user_low_id and request.user.id != conv.user_high_id:
            return format_error_response("permission_denied", "You are not a participant in this conversation.", status_code=status.HTTP_403_FORBIDDEN)

        message_id = request.data.get('message_id')
        if not message_id:
            last_msg = conv.messages.order_by('-id').first()
            message_id = last_msg.id if last_msg else None

        read_state, _ = ConversationReadState.objects.get_or_create(conversation=conv, user=request.user)
        if message_id:
            read_state.last_read_message_id = max(read_state.last_read_message_id or 0, int(message_id))
            read_state.save(update_fields=['last_read_message_id'])

        return Response({"message": "Read state updated.", "last_read_message_id": read_state.last_read_message_id})
