from rest_framework import views, status, permissions
from rest_framework.response import Response
from django.shortcuts import get_object_or_404
from django.core.paginator import Paginator

from moderation.models import Report, ContentRule, Appeal
from moderation.serializers import ReportSerializer, ContentRuleSerializer, AppealSerializer
from moderation import services, registry
from core.exceptions import format_error_response
from core.permissions import IsStaffModerator, IsAdminRole


class CreateReportView(views.APIView):
    """
    POST /reports/
    Verified users only.
    """
    permission_classes = [permissions.AllowAny]

    def post(self, request):
        if not request.user or not request.user.is_authenticated:
            return format_error_response("not_authenticated", "Authentication credentials were not provided.", status_code=status.HTTP_401_UNAUTHORIZED)

        user = request.user
        if not getattr(user, 'email_verified', False) and not user.is_staff:
            return format_error_response("email_not_verified", "Verified email required to report messages.", status_code=status.HTTP_403_FORBIDDEN)

        target_type = request.data.get('target_type')
        target_id = request.data.get('target_id')
        reason = request.data.get('reason')
        note = request.data.get('note', '')

        if not target_type or not target_id or not reason:
            return format_error_response("validation_error", "Missing required fields.", fields={'target_type': 'required', 'target_id': 'required', 'reason': 'required'}, status_code=status.HTTP_400_BAD_REQUEST)

        try:
            report, created = services.create_report(
                reporter=user,
                target_type=target_type,
                target_id=str(target_id),
                reason=reason,
                note=note
            )
            if not created:
                return format_error_response("already_reported", "You have already reported this item.", status_code=status.HTTP_409_CONFLICT)

            serializer = ReportSerializer(report)
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        except PermissionError as e:
            return format_error_response("permission_denied", str(e), status_code=status.HTTP_403_FORBIDDEN)
        except ValueError as e:
            return format_error_response("not_found", str(e), status_code=status.HTTP_404_NOT_FOUND)
        except Exception as e:
            return format_error_response("server_error", str(e), status_code=status.HTTP_500_INTERNAL_SERVER_ERROR)


class StaffReportsQueueView(views.APIView):
    """
    GET /staff/reports/
    Oldest open first, 20 per page, reporter count, preview for staff only.
    """
    permission_classes = [IsStaffModerator]

    def get(self, request):
        status_filter = request.query_params.get('status', 'open')
        reports_qs = Report.objects.filter(status=status_filter).order_by('created_at')

        page = int(request.query_params.get('page', 1))
        paginator = Paginator(reports_qs, 20)
        page_obj = paginator.get_page(page)

        items = []
        for r in page_obj:
            data = ReportSerializer(r).data
            # Total reports count for this target
            total_reports = Report.objects.filter(target_type=r.target_type, target_id=r.target_id).count()
            data['target_report_count'] = total_reports
            try:
                data['preview'] = registry.preview(r.target_type, r.target_id)
            except Exception:
                data['preview'] = None
            items.append(data)

        return Response({
            'count': paginator.count,
            'num_pages': paginator.num_pages,
            'current_page': page,
            'results': items
        })


class StaffReportDetailView(views.APIView):
    """
    GET /staff/reports/<id>/
    POST /staff/reports/<id>/action/
    """
    permission_classes = [IsStaffModerator]

    def get(self, request, pk):
        report = get_object_or_404(Report, pk=pk)
        data = ReportSerializer(report).data
        try:
            data['preview'] = registry.preview(report.target_type, report.target_id)
        except Exception:
            data['preview'] = None
        data['history'] = [
            {
                'id': a.id,
                'actor': a.actor.username,
                'action': a.action,
                'note': a.note,
                'created_at': a.created_at
            }
            for a in report.actions.order_by('-created_at')
        ]
        return Response(data)

    def post(self, request, pk):
        report = get_object_or_404(Report, pk=pk)
        action = request.data.get('action')
        note = request.data.get('note', '')

        if action not in ('dismiss', 'hide', 'remove', 'restore', 'warn', 'suspend'):
            return format_error_response("invalid_action", f"Unknown action: {action}", status_code=status.HTTP_400_BAD_REQUEST)

        try:
            mod_action = services.resolve_report(actor=request.user, report=report, action=action, note=note)
            return Response({
                'status': 'success',
                'action': mod_action.action,
                'report_status': report.status
            })
        except PermissionError as e:
            return format_error_response("permission_denied", str(e), status_code=status.HTTP_403_FORBIDDEN)
        except Exception as e:
            return format_error_response("action_failed", str(e), status_code=status.HTTP_400_BAD_REQUEST)


class StaffHeldMessagesView(views.APIView):
    """
    GET /staff/held/
    """
    permission_classes = [IsStaffModerator]

    def get(self, request):
        page = int(request.query_params.get('page', 1))
        page_size = int(request.query_params.get('page_size', 20))
        result = services.list_held(page=page, page_size=page_size)
        return Response(result)


class StaffReleaseHeldView(views.APIView):
    """
    POST /staff/held/<id>/release/
    """
    permission_classes = [IsStaffModerator]

    def post(self, request, pk):
        target_type = request.data.get('target_type', 'anonymous_message')
        try:
            services.release_held(actor=request.user, target_type=target_type, target_id=str(pk))
            return Response({'status': 'released', 'target_id': pk})
        except Exception as e:
            return format_error_response("release_failed", str(e), status_code=status.HTTP_400_BAD_REQUEST)


class AppealView(views.APIView):
    """
    POST /appeals/
    For suspended users. One appeal per suspension.
    """
    permission_classes = [permissions.IsAuthenticated]

    def post(self, request):
        text = request.data.get('text', '').strip()
        if not text:
            return format_error_response("validation_error", "Appeal text cannot be empty.", fields={'text': 'required'}, status_code=status.HTTP_400_BAD_REQUEST)

        if len(text) > 1000:
            return format_error_response("validation_error", "Appeal text exceeds 1000 characters limit.", fields={'text': 'too_long'}, status_code=status.HTTP_400_BAD_REQUEST)

        try:
            appeal = services.submit_appeal(user=request.user, text=text)
            return Response(AppealSerializer(appeal).data, status=status.HTTP_201_CREATED)
        except ValueError as e:
            return format_error_response("already_appealed", str(e), status_code=status.HTTP_409_CONFLICT)
        except Exception as e:
            return format_error_response("server_error", str(e), status_code=status.HTTP_500_INTERNAL_SERVER_ERROR)


class StaffAppealsQueueView(views.APIView):
    """
    GET /staff/appeals/
    Admin only.
    """
    permission_classes = [IsAdminRole]

    def get(self, request):
        appeals = Appeal.objects.filter(status='open').order_by('id')
        serializer = AppealSerializer(appeals, many=True)
        return Response({'results': serializer.data})


class StaffAppealDecideView(views.APIView):
    """
    POST /staff/appeals/<id>/decide/
    Admin only, not original actor.
    """
    permission_classes = [IsAdminRole]

    def post(self, request, pk):
        appeal = get_object_or_404(Appeal, pk=pk)
        outcome = request.data.get('outcome')

        if outcome not in ('upheld', 'overturned'):
            return format_error_response("validation_error", "Outcome must be 'upheld' or 'overturned'.", status_code=status.HTTP_400_BAD_REQUEST)

        try:
            services.decide_appeal(actor=request.user, appeal=appeal, outcome=outcome)
            return Response(AppealSerializer(appeal).data)
        except PermissionError as e:
            return format_error_response("permission_denied", str(e), status_code=status.HTTP_403_FORBIDDEN)
        except ValueError as e:
            return format_error_response("bad_request", str(e), status_code=status.HTTP_400_BAD_REQUEST)


class ContentRulesView(views.APIView):
    """
    GET, POST /staff/policies/rules/
    Admin only.
    """
    permission_classes = [IsAdminRole]

    def get(self, request):
        rules = ContentRule.objects.all().order_by('created_at')
        return Response({'results': ContentRuleSerializer(rules, many=True).data})

    def post(self, request):
        pattern = request.data.get('pattern', '').strip()
        rule_type = request.data.get('rule_type')
        action = request.data.get('action')
        enabled = request.data.get('enabled', True)

        if not pattern or not rule_type or not action:
            return format_error_response("validation_error", "Missing fields.", fields={'pattern': 'required', 'rule_type': 'required', 'action': 'required'}, status_code=status.HTTP_400_BAD_REQUEST)

        try:
            rule = services.create_content_rule(actor=request.user, pattern=pattern, rule_type=rule_type, action=action, enabled=enabled)
            return Response(ContentRuleSerializer(rule).data, status=status.HTTP_201_CREATED)
        except ValueError as e:
            return format_error_response("invalid_pattern", str(e), status_code=status.HTTP_400_BAD_REQUEST)


class ContentRuleDetailView(views.APIView):
    """
    PATCH, DELETE /staff/policies/rules/<id>/
    Admin only.
    """
    permission_classes = [IsAdminRole]

    def patch(self, request, pk):
        rule = get_object_or_404(ContentRule, pk=pk)
        try:
            updated = services.update_content_rule(actor=request.user, rule_id=rule.id, **request.data)
            return Response(ContentRuleSerializer(updated).data)
        except ValueError as e:
            return format_error_response("invalid_pattern", str(e), status_code=status.HTTP_400_BAD_REQUEST)

    def delete(self, request, pk):
        rule = get_object_or_404(ContentRule, pk=pk)
        rule.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)
