import datetime
from django.utils import timezone
from django.db.models import Q
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from rest_framework.pagination import PageNumberPagination

from core.exceptions import format_error_response
from core.permissions import IsStaffModerator, IsAdminRole
from accounts.models import User
from messaging.models import Inbox, AnonymousMessage, DirectMessage
from core.models import AuditLog
from core.security_serializers import StaffUserListSerializer, StaffUserDetailSerializer, AuditLogSerializer
from core.security_services import log_audit

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

class StaffDashboardView(APIView):
    permission_classes = [IsStaffModerator]

    def get(self, request):
        now = timezone.now()
        seven_days_ago = now - datetime.timedelta(days=7)
        one_day_ago = now - datetime.timedelta(hours=24)

        total_users = User.objects.count()
        new_users_7d = User.objects.filter(date_joined__gte=seven_days_ago).count()
        anon_messages_24h = AnonymousMessage.objects.filter(created_at__gte=one_day_ago).count()
        direct_messages_24h = DirectMessage.objects.filter(created_at__gte=one_day_ago).count()
        inboxes_enabled = Inbox.objects.filter(anonymous_enabled=True).count()

        from moderation.services import count_open_reports, count_held
        from core.security_services import count_events, count_suspicious

        open_reports = count_open_reports()
        held_messages = count_held()
        security_events_24h = count_events(since=one_day_ago)
        suspicious_count = count_suspicious()

        return Response({
            "total_users": total_users,
            "new_users_7d": new_users_7d,
            "anon_messages_24h": anon_messages_24h,
            "direct_messages_24h": direct_messages_24h,
            "inboxes_enabled": inboxes_enabled,
            "open_reports": open_reports,
            "held_messages": held_messages,
            "security_events_24h": security_events_24h,
            "suspicious_count": suspicious_count,
        })

class StaffUsersView(APIView):
    def get_permissions(self):
        if self.request.method == 'POST':
            return [IsAdminRole()]
        return [IsStaffModerator()]

    def get(self, request):
        qs = User.objects.all().order_by('-date_joined')
        
        search = request.query_params.get('search', '').strip()
        if search:
            qs = qs.filter(Q(username__icontains=search) | Q(email__icontains=search))

        role = request.query_params.get('role')
        if role in ('user', 'moderator', 'admin'):
            qs = qs.filter(role=role)

        suspended = request.query_params.get('suspended')
        if suspended is not None:
            if suspended.lower() in ('true', '1'):
                qs = qs.filter(is_suspended=True)
            elif suspended.lower() in ('false', '0'):
                qs = qs.filter(is_suspended=False)

        paginator = StaffPagination()
        page = paginator.paginate_queryset(qs, request)
        serializer = StaffUserListSerializer(page, many=True)
        return paginator.get_paginated_response(serializer.data)

    def post(self, request):
        username = (request.data.get('username') or '').strip().lower()
        email = (request.data.get('email') or '').strip().lower()
        password = request.data.get('password') or ''
        role = request.data.get('role', 'user')

        errors = {}
        if not username:
            errors['username'] = 'Username is required.'
        elif len(username) < 3 or len(username) > 30:
            errors['username'] = 'Username must be between 3 and 30 characters.'
        elif User.objects.filter(username=username).exists():
            errors['username'] = 'Username already exists.'

        if not email:
            errors['email'] = 'Email is required.'
        elif User.objects.filter(email=email).exists():
            errors['email'] = 'Email already registered.'

        if not password or len(password) < 8:
            errors['password'] = 'Password must be at least 8 characters long.'

        if role not in ('user', 'moderator', 'admin'):
            errors['role'] = 'Invalid role specified.'

        if errors:
            return format_error_response("validation_error", "Validation failed.", fields=errors)

        user = User.objects.create_user(
            username=username,
            email=email,
            password=password,
            role=role,
            is_staff=(role in ('moderator', 'admin')),
            is_superuser=(role == 'admin'),
            email_verified=True
        )

        from accounts.models import Profile
        Profile.objects.get_or_create(user=user, defaults={'display_name': username})
        from messaging.models import Inbox
        Inbox.objects.get_or_create(owner=user, defaults={'slug': username})

        log_audit(
            actor=request.user,
            action="create_user",
            target_type="User",
            target_id=user.id,
            summary=f"Created user @{user.username} with role {role}."
        )

        serializer = StaffUserDetailSerializer(user)
        return Response(serializer.data, status=status.HTTP_201_CREATED)

class StaffUserDetailView(APIView):
    permission_classes = [IsStaffModerator]

    def get(self, request, pk):
        user = User.objects.filter(id=pk).select_related('profile', 'inbox').first()
        if not user:
            return format_error_response("user_not_found", "User not found.", status_code=status.HTTP_404_NOT_FOUND)
        serializer = StaffUserDetailSerializer(user)
        return Response(serializer.data)

class StaffSuspendUserView(APIView):
    permission_classes = [IsAdminRole]

    def post(self, request, pk):
        user = User.objects.filter(id=pk).first()
        if not user:
            return format_error_response("user_not_found", "User not found.", status_code=status.HTTP_404_NOT_FOUND)

        reason = (request.data.get('reason') or '').strip()
        if not reason:
            return format_error_response("validation_error", "Suspension reason is required.", fields={"reason": "Reason is required."})
        if len(reason) > 300:
            return format_error_response("validation_error", "Suspension reason cannot exceed 300 characters.", fields={"reason": "Max length 300."})

        suspended_until = request.data.get('suspended_until')

        user.is_suspended = True
        user.suspension_reason = reason
        user.suspended_until = suspended_until
        user.save(update_fields=['is_suspended', 'suspension_reason', 'suspended_until'])

        log_audit(
            actor=request.user,
            action="suspend_user",
            target_type="User",
            target_id=user.id,
            summary=f"Suspended user @{user.username}. Reason: {reason}"
        )

        return Response({"message": f"User @{user.username} has been suspended."})

class StaffUnsuspendUserView(APIView):
    permission_classes = [IsAdminRole]

    def post(self, request, pk):
        user = User.objects.filter(id=pk).first()
        if not user:
            return format_error_response("user_not_found", "User not found.", status_code=status.HTTP_404_NOT_FOUND)

        reason = (request.data.get('reason') or '').strip()
        if not reason:
            return format_error_response("validation_error", "Unsuspension reason is required.", fields={"reason": "Reason is required."})

        user.is_suspended = False
        user.suspension_reason = None
        user.suspended_until = None
        user.save(update_fields=['is_suspended', 'suspension_reason', 'suspended_until'])

        log_audit(
            actor=request.user,
            action="unsuspend_user",
            target_type="User",
            target_id=user.id,
            summary=f"Unsuspended user @{user.username}. Reason: {reason}"
        )

        return Response({"message": f"User @{user.username} has been unsuspended."})

class StaffChangeRoleView(APIView):
    permission_classes = [IsAdminRole]

    def post(self, request, pk):
        user = User.objects.filter(id=pk).first()
        if not user:
            return format_error_response("user_not_found", "User not found.", status_code=status.HTTP_404_NOT_FOUND)

        new_role = request.data.get('role')
        if new_role not in ('user', 'moderator', 'admin'):
            return format_error_response("validation_error", "Invalid role specified.", fields={"role": "Must be user, moderator, or admin."})

        # F8 Acceptance Criteria 42: The last remaining admin cannot demote themselves
        if user.id == request.user.id and new_role != 'admin':
            admin_count = User.objects.filter(role='admin', is_active=True).count()
            if admin_count <= 1:
                return format_error_response("last_admin_demotion", "The last remaining admin cannot demote themselves.", status_code=status.HTTP_400_BAD_REQUEST)

        old_role = user.role
        user.role = new_role
        user.is_staff = (new_role in ('admin', 'moderator'))
        user.is_superuser = (new_role == 'admin')
        user.save(update_fields=['role', 'is_staff', 'is_superuser'])

        log_audit(
            actor=request.user,
            action="change_role",
            target_type="User",
            target_id=user.id,
            summary=f"Changed role for @{user.username} from {old_role} to {new_role}."
        )

        return Response({"message": f"User @{user.username} role changed to {new_role}."})

class StaffDeleteUserView(APIView):
    permission_classes = [IsAdminRole]

    def post(self, request, pk):
        user = User.objects.filter(id=pk).first()
        if not user:
            return format_error_response("user_not_found", "User not found.", status_code=status.HTTP_404_NOT_FOUND)

        # Safeguard: Last remaining active admin cannot be deleted
        if user.role == 'admin':
            admin_count = User.objects.filter(role='admin', is_active=True).count()
            if admin_count <= 1:
                return format_error_response(
                    "last_admin_demotion",
                    "The last remaining admin account cannot be deleted.",
                    status_code=status.HTTP_400_BAD_REQUEST
                )

        reason = (request.data.get('reason') or '').strip()
        summary = f"Deleted user @{user.username} (ID: {user.id})."
        if reason:
            summary += f" Reason: {reason}"

        # Write audit log before deleting user record
        log_audit(
            actor=request.user,
            action="delete_user",
            target_type="User",
            target_id=user.id,
            summary=summary[:500]
        )

        # Invalidate target user's sessions
        user_id_str = str(user.id)
        from django.contrib.sessions.models import Session
        for session in Session.objects.all():
            try:
                data = session.get_decoded()
                if str(data.get('_auth_user_id')) == user_id_str:
                    session.delete()
            except Exception:
                pass

        username_deleted = user.username
        user.delete()

        return Response({"message": f"User @{username_deleted} has been permanently deleted."})

class StaffAuditLogView(APIView):
    permission_classes = [IsStaffModerator]

    def get(self, request):
        qs = AuditLog.objects.all().select_related('actor').order_by('-created_at')

        actor_username = request.query_params.get('actor')
        if actor_username:
            qs = qs.filter(actor__username__iexact=actor_username)

        action = request.query_params.get('action')
        if action:
            qs = qs.filter(action=action)

        start_date = request.query_params.get('start_date')
        if start_date:
            qs = qs.filter(created_at__gte=start_date)

        end_date = request.query_params.get('end_date')
        if end_date:
            qs = qs.filter(created_at__lte=end_date)

        paginator = StaffPagination()
        page = paginator.paginate_queryset(qs, request)
        serializer = AuditLogSerializer(page, many=True)
        return paginator.get_paginated_response(serializer.data)

    def put(self, request, *args, **kwargs):
        return format_error_response("method_not_allowed", "Audit log is append-only and cannot be modified.", status_code=status.HTTP_405_METHOD_NOT_ALLOWED)

    def patch(self, request, *args, **kwargs):
        return format_error_response("method_not_allowed", "Audit log is append-only and cannot be modified.", status_code=status.HTTP_405_METHOD_NOT_ALLOWED)

    def delete(self, request, *args, **kwargs):
        return format_error_response("method_not_allowed", "Audit log is append-only and cannot be deleted.", status_code=status.HTTP_405_METHOD_NOT_ALLOWED)


# ==========================================
# Phase 2 Security Views
# ==========================================

from django.http import HttpResponse
from core.models import SecurityEvent, Setting
from core.security_serializers import SecurityEventSerializer, SettingSerializer
from core.security_services import (
    get_setting, set_setting, verify_chain, export_audit_csv, export_security_csv
)


class StaffSecurityEventsView(APIView):
    """
    GET /staff/security/
    Filter by type and date, 50 per page.
    """
    permission_classes = [IsStaffModerator]

    def get(self, request):
        qs = SecurityEvent.objects.all().select_related('user').order_by('-created_at')

        event_type = request.query_params.get('event_type')
        if event_type:
            qs = qs.filter(event_type=event_type)

        from_date = request.query_params.get('from_date')
        if from_date:
            qs = qs.filter(created_at__gte=from_date)

        to_date = request.query_params.get('to_date')
        if to_date:
            qs = qs.filter(created_at__lte=to_date)

        paginator = PageNumberPagination()
        paginator.page_size = 50
        page = paginator.paginate_queryset(qs, request)
        serializer = SecurityEventSerializer(page, many=True)
        return paginator.get_paginated_response(serializer.data)


class StaffSecurityEventsExportView(APIView):
    """
    GET /staff/security/export/
    Admin only CSV export.
    """
    permission_classes = [IsAdminRole]

    def get(self, request):
        from_date = request.query_params.get('from_date')
        to_date = request.query_params.get('to_date')
        event_type = request.query_params.get('event_type')

        csv_content = export_security_csv(from_date=from_date, to_date=to_date, event_type=event_type, actor=request.user)
        response = HttpResponse(csv_content, content_type='text/csv')
        response['Content-Disposition'] = 'attachment; filename="security_events.csv"'
        return response


class StaffSettingsView(APIView):
    """
    GET, PATCH /staff/settings/
    Admin only.
    """
    permission_classes = [IsAdminRole]

    def get(self, request):
        settings_qs = Setting.objects.all().order_by('key')
        serializer = SettingSerializer(settings_qs, many=True)
        return Response({'results': serializer.data})

    def patch(self, request):
        key = request.data.get('key')
        value = request.data.get('value')
        if not key or value is None:
            return format_error_response("validation_error", "Key and value are required.", fields={'key': 'required', 'value': 'required'}, status_code=status.HTTP_400_BAD_REQUEST)

        obj = set_setting(actor=request.user, key=key, value=str(value))
        return Response(SettingSerializer(obj).data)


class StaffAuditLogExportView(APIView):
    """
    GET /staff/audit-log/export/
    Admin only.
    """
    permission_classes = [IsAdminRole]

    def get(self, request):
        from_date = request.query_params.get('from_date')
        to_date = request.query_params.get('to_date')

        csv_content = export_audit_csv(from_date=from_date, to_date=to_date, actor=request.user)
        response = HttpResponse(csv_content, content_type='text/csv')
        response['Content-Disposition'] = 'attachment; filename="audit_log.csv"'
        return response


class StaffAuditChainVerifyView(APIView):
    """
    POST /staff/audit-log/verify/
    Admin only.
    """
    permission_classes = [IsAdminRole]

    def post(self, request):
        broken_id = verify_chain()
        if broken_id is None:
            return Response({'valid': True, 'message': "Audit hash chain is valid."})
        return Response({'valid': False, 'broken_row_id': broken_id, 'message': f"Hash chain broken at row ID {broken_id}."}, status=status.HTTP_400_BAD_REQUEST)


# ───────────────────────────────────────────
# Legal Documents (Policies CRUD)
# ───────────────────────────────────────────

def _doc_to_dict(doc):
    return {
        'id': doc.id,
        'doc_type': doc.doc_type,
        'version': doc.version,
        'title': doc.title,
        'effective_date': doc.effective_date.isoformat() if doc.effective_date else None,
        'intro': doc.intro,
        'sections': doc.sections,
        'status': doc.status,
        'change_note': doc.change_note,
        'published_at': doc.published_at.isoformat() if doc.published_at else None,
        'created_by': doc.created_by.username if doc.created_by else None,
        'created_at': doc.created_at.isoformat(),
        'updated_at': doc.updated_at.isoformat(),
    }


class PublicLegalDocumentView(APIView):
    """GET /policies/documents/public/?doc_type=privacy|terms — no auth required."""
    permission_classes = []

    def get(self, request):
        doc_type = request.query_params.get('doc_type')
        if doc_type not in ('privacy', 'terms'):
            return Response({'error': {'code': 'invalid_doc_type', 'message': 'doc_type must be privacy or terms'}}, status=400)
        from core.models import LegalDocument
        doc = LegalDocument.objects.filter(doc_type=doc_type, status='published').order_by('-published_at').first()
        if not doc:
            return Response({'detail': 'No published document found.'}, status=404)
        return Response(_doc_to_dict(doc))


class StaffLegalDocumentListView(APIView):
    """
    GET  /staff/policies/documents/?doc_type=privacy|terms — returns all docs for a type
    POST /staff/policies/documents/ — create a draft
    """
    permission_classes = [IsStaffModerator]

    def get(self, request):
        from core.models import LegalDocument
        doc_type = request.query_params.get('doc_type')
        qs = LegalDocument.objects.all()
        if doc_type in ('privacy', 'terms'):
            qs = qs.filter(doc_type=doc_type)
        return Response({'results': [_doc_to_dict(d) for d in qs]})

    def post(self, request):
        from core.models import LegalDocument
        data = request.data
        doc_type = data.get('doc_type')
        if doc_type not in ('privacy', 'terms'):
            return Response({'error': {'code': 'invalid_doc_type', 'message': 'doc_type must be privacy or terms'}}, status=400)
        # Compute next version
        last = LegalDocument.objects.filter(doc_type=doc_type).order_by('-created_at').first()
        if last:
            try:
                maj, minor = last.version.split('.')
                next_version = f"{maj}.{int(minor)+1}"
            except Exception:
                next_version = '1.0'
        else:
            next_version = '1.0'
        doc = LegalDocument.objects.create(
            doc_type=doc_type,
            version=next_version,
            title=data.get('title', ''),
            effective_date=data.get('effective_date') or None,
            intro=data.get('intro', ''),
            sections=data.get('sections', []),
            status='draft',
            change_note=data.get('change_note', ''),
            created_by=request.user,
        )
        log_audit(actor=request.user, action='legal_doc_draft_created',
                  target_type='LegalDocument', target_id=str(doc.id),
                  summary=f"Draft {doc_type} v{doc.version} created")
        return Response(_doc_to_dict(doc), status=201)


class StaffLegalDocumentDetailView(APIView):
    """
    GET    /staff/policies/documents/<id>/
    PATCH  /staff/policies/documents/<id>/  — update draft fields
    DELETE /staff/policies/documents/<id>/  — delete draft (not published)
    """
    permission_classes = [IsStaffModerator]

    def _get_doc(self, pk):
        from core.models import LegalDocument
        try:
            return LegalDocument.objects.get(pk=pk)
        except LegalDocument.DoesNotExist:
            return None

    def get(self, request, pk):
        doc = self._get_doc(pk)
        if not doc:
            return Response({'error': {'code': 'not_found', 'message': 'Document not found'}}, status=404)
        return Response(_doc_to_dict(doc))

    def patch(self, request, pk):
        doc = self._get_doc(pk)
        if not doc:
            return Response({'error': {'code': 'not_found', 'message': 'Document not found'}}, status=404)
        data = request.data
        for field in ('title', 'intro', 'sections', 'change_note'):
            if field in data:
                setattr(doc, field, data[field])
        if 'effective_date' in data:
            doc.effective_date = data['effective_date'] or None
        doc.save()
        log_audit(actor=request.user, action='legal_doc_draft_updated',
                  target_type='LegalDocument', target_id=str(doc.id),
                  summary=f"Draft {doc.doc_type} v{doc.version} updated")
        return Response(_doc_to_dict(doc))

    def delete(self, request, pk):
        doc = self._get_doc(pk)
        if not doc:
            return Response({'error': {'code': 'not_found', 'message': 'Document not found'}}, status=404)
        if doc.status == 'published':
            return Response({'error': {'code': 'cannot_delete_published', 'message': 'Published documents cannot be deleted'}}, status=400)
        doc_type = doc.doc_type
        version = doc.version
        doc.delete()
        log_audit(actor=request.user, action='legal_doc_draft_deleted',
                  target_type='LegalDocument', target_id=str(pk),
                  summary=f"Draft {doc_type} v{version} deleted")
        return Response(status=204)


class StaffLegalDocumentPublishView(APIView):
    """POST /staff/policies/documents/<id>/publish/ — publish a draft"""
    permission_classes = [IsAdminRole]

    def post(self, request, pk):
        from core.models import LegalDocument
        try:
            doc = LegalDocument.objects.get(pk=pk)
        except LegalDocument.DoesNotExist:
            return Response({'error': {'code': 'not_found', 'message': 'Document not found'}}, status=404)
        if doc.status == 'published':
            return Response({'error': {'code': 'already_published', 'message': 'Already published'}}, status=400)
        change_note = request.data.get('change_note', doc.change_note)
        doc.status = 'published'
        doc.change_note = change_note
        doc.published_at = timezone.now()
        doc.save()
        log_audit(actor=request.user, action='legal_doc_published',
                  target_type='LegalDocument', target_id=str(doc.id),
                  summary=f"Published {doc.doc_type} v{doc.version}")
        return Response(_doc_to_dict(doc))

