from __future__ import annotations
"""
moderation/services.py - Moderation services.
Enforces content rules, reporting flow, auto-hide, moderation actions, and appeals.
Moderation NEVER imports inbox or messaging directly; uses moderation.registry instead.
"""
import re
import time
import logging
from datetime import timedelta
from django.utils import timezone
from django.core.cache import cache
from django.db import transaction

from moderation.models import Report, ModerationAction, Appeal, ContentRule
from moderation import registry
from core.security_services import log_audit, log_security_event

logger = logging.getLogger(__name__)


def _check_nested_quantifiers(pattern: str) -> bool:
    """
    Check if a regex pattern contains nested quantifiers like (a+)+ or (.*)*.
    Helps prevent ReDoS attacks.
    """
    # Regex detecting nested quantifiers e.g. (...+)+ or (..*)* or (..{1,2})+
    nested_re = re.compile(r'\([^)]*[+*]\)[+*]|\([^)]*\{[0-9]+,[0-9]*\}\)[+*]|\([^)]*[+*]\)\{[0-9]+,[0-9]*\}')
    if nested_re.search(pattern):
        return True
    return False


def validate_rule_pattern(rule_type: str, pattern: str) -> None:
    """Validate content rule pattern upon save/creation."""
    if rule_type == 'safe_regex':
        if _check_nested_quantifiers(pattern):
            raise ValueError("Regex contains nested quantifiers which may lead to catastrophic backtracking.")
        try:
            re.compile(pattern)
        except re.error as e:
            raise ValueError(f"Invalid regex: {e}")


def evaluate_content(text: str) -> str | None:
    """
    Evaluate content text against active ContentRules.
    Rules evaluated in creation order.
    Budget: 50 ms per evaluation. Exceeding it counts as no match and logs 'suspicious_payload'.
    Returns: None, 'hold', or 'reject'.
    """
    if not text:
        return None

    rules = ContentRule.objects.filter(enabled=True).order_by('created_at', 'id')
    start_time = time.perf_counter()

    for rule in rules:
        elapsed_ms = (time.perf_counter() - start_time) * 1000
        if elapsed_ms > 50:
            # Exceeded budget!
            log_security_event(
                event_type='suspicious_payload',
                meta={'reason': 'content_eval_timeout', 'elapsed_ms': round(elapsed_ms, 2)}
            )
            return None

        matched = False
        if rule.rule_type == 'exact_word':
            # Word boundary match, case-insensitive
            pattern = rf'\b{re.escape(rule.pattern)}\b'
            try:
                if re.search(pattern, text, flags=re.IGNORECASE):
                    matched = True
            except Exception:
                pass
        elif rule.rule_type == 'phrase':
            # Case-insensitive substring
            if rule.pattern.lower() in text.lower():
                matched = True
        elif rule.rule_type == 'safe_regex':
            try:
                if re.search(rule.pattern, text, flags=re.IGNORECASE):
                    matched = True
            except Exception:
                pass

        if matched:
            return rule.action  # 'hold' or 'reject'

    return None


def create_content_rule(actor, pattern: str, rule_type: str, action: str, enabled: bool = True) -> ContentRule:
    validate_rule_pattern(rule_type, pattern)
    rule = ContentRule.objects.create(
        pattern=pattern,
        rule_type=rule_type,
        action=action,
        enabled=enabled
    )
    log_audit(
        actor=actor,
        action='create_content_rule',
        target_type='content_rule',
        target_id=str(rule.id),
        details={'pattern': pattern, 'rule_type': rule_type, 'action': action, 'enabled': enabled}
    )
    return rule


def update_content_rule(actor, rule_id: int, **kwargs) -> ContentRule:
    rule = ContentRule.objects.get(id=rule_id)
    old_details = {
        'pattern': rule.pattern,
        'rule_type': rule.rule_type,
        'action': rule.action,
        'enabled': rule.enabled
    }
    
    new_type = kwargs.get('rule_type', rule.rule_type)
    new_pattern = kwargs.get('pattern', rule.pattern)
    if 'pattern' in kwargs or 'rule_type' in kwargs:
        validate_rule_pattern(new_type, new_pattern)

    for field, val in kwargs.items():
        if hasattr(rule, field):
            setattr(rule, field, val)
    rule.save()

    log_audit(
        actor=actor,
        action='update_content_rule',
        target_type='content_rule',
        target_id=str(rule.id),
        details={'old': old_details, 'new': kwargs}
    )
    return rule


def _is_reliable_reporter(user) -> bool:
    """
    A reporter whose last 3 reports were dismissed in the past 30 days is not reliable.
    """
    thirty_days_ago = timezone.now() - timedelta(days=30)
    recent_reports = Report.objects.filter(
        reporter=user,
        created_at__gte=thirty_days_ago,
        status__in=['dismissed', 'actioned']
    ).order_by('-created_at')[:3]

    if len(recent_reports) == 3 and all(r.status == 'dismissed' for r in recent_reports):
        return False
    return True


def create_report(reporter, target_type: str, target_id: str, reason: str, note: str = '') -> tuple[Report, bool]:
    """
    Create an abuse report for a target.
    Reporter must be verified.
    Duplicate returns already_reported.
    Auto-hide at 3 distinct reliable reporters.
    """
    # Verify target exists and reporter has access / is recipient
    if not registry.exists(target_type, target_id):
        raise ValueError(f"Target {target_type}:{target_id} not found.")

    owner = registry.owner_of(target_type, target_id)
    if owner and owner.id != reporter.id and not reporter.is_staff:
        # Only the recipient / owner of the received message can report it
        raise PermissionError("Only the recipient of a message can report it.")

    existing = Report.objects.filter(reporter=reporter, target_type=target_type, target_id=target_id).first()
    if existing:
        return existing, False

    report = Report.objects.create(
        reporter=reporter,
        target_type=target_type,
        target_id=target_id,
        reason=reason,
        note=note,
        status='open'
    )

    # Check auto-hide rule: 3 distinct reliable reporters
    reports_for_target = Report.objects.filter(
        target_type=target_type,
        target_id=target_id
    ).select_related('reporter')

    reliable_reporters = set()
    for r in reports_for_target:
        if _is_reliable_reporter(r.reporter):
            reliable_reporters.add(r.reporter_id)

    if len(reliable_reporters) >= 3:
        # Auto-hide message!
        registry.set_status(target_type, target_id, 'hidden')
        Report.objects.filter(target_type=target_type, target_id=target_id, status='open').update(
            status='auto_hidden'
        )
        report.refresh_from_db()

    return report, True


def resolve_report(actor, report: Report, action: str, note: str = '') -> ModerationAction:
    """
    Resolve a report. Actions: dismiss, hide, remove, warn, suspend.
    Moderator can dismiss, hide, remove, warn.
    Suspend requires admin (is_staff and is_superuser or role == 'admin').
    """
    if action == 'suspend':
        # Must be admin
        is_admin = actor.is_superuser or getattr(actor, 'role', '') == 'admin'
        if not is_admin:
            raise PermissionError("Only administrators can suspend users.")

    with transaction.atomic():
        if action == 'dismiss':
            report.status = 'dismissed'
        elif action in ('hide', 'remove'):
            report.status = 'actioned'
            target_status = 'hidden' if action == 'hide' else 'removed'
            registry.set_status(report.target_type, report.target_id, target_status)
        elif action == 'restore':
            registry.set_status(report.target_type, report.target_id, 'visible')
        elif action == 'warn':
            report.status = 'actioned'
            # Find owner/author or recipient
            from accounts.services import warn_user
            owner = registry.owner_of(report.target_type, report.target_id)
            if owner:
                warn_user(owner, note or "You have received an official moderation warning regarding content guidelines.")
        elif action == 'suspend':
            report.status = 'actioned'
            from accounts.services import suspend_user
            owner = registry.owner_of(report.target_type, report.target_id)
            if owner:
                suspend_user(actor=actor, user=owner, reason=note or "Violation of community standards")

        report.resolved_by = actor
        report.resolved_at = timezone.now()
        report.save()

        mod_action = ModerationAction.objects.create(
            report=report,
            actor=actor,
            action=action,
            target_type=report.target_type,
            target_id=report.target_id,
            note=note
        )

        log_audit(
            actor=actor,
            action=f"moderation_{action}",
            target_type=report.target_type,
            target_id=str(report.target_id),
            details={'report_id': report.id, 'note': note, 'action': action}
        )

    return mod_action


def hide(target_type: str, target_id: str) -> bool:
    return registry.set_status(target_type, target_id, 'hidden')


def remove(target_type: str, target_id: str) -> bool:
    return registry.set_status(target_type, target_id, 'removed')


def restore(target_type: str, target_id: str) -> bool:
    return registry.set_status(target_type, target_id, 'visible')


def count_open_reports() -> int:
    return Report.objects.filter(status='open').count()


def count_held() -> int:
    try:
        adapter = registry.get_adapter('anonymous_message')
        if hasattr(adapter, 'count_held'):
            return adapter.count_held()
    except Exception:
        pass
    return 0


def list_held(page: int = 1, page_size: int = 20):
    try:
        adapter = registry.get_adapter('anonymous_message')
        if hasattr(adapter, 'list_held'):
            return adapter.list_held(page, page_size)
    except Exception:
        pass
    return {'items': [], 'total': 0, 'page': page, 'page_size': page_size}


def release_held(actor, target_type: str, target_id: str):
    """Release a held message back to visible status."""
    registry.set_status(target_type, target_id, 'visible')
    log_audit(
        actor=actor,
        action='release_held',
        target_type=target_type,
        target_id=str(target_id),
        details={'released_by': actor.username}
    )


def submit_appeal(user, text: str, suspension_audit_id: int = None) -> Appeal:
    """Submit an appeal against an account suspension."""
    if not user.is_suspended:
        raise ValueError("Only suspended users can submit an appeal.")

    from core.models import AuditLog
    if suspension_audit_id is None:
        last_suspension = AuditLog.objects.filter(
            target_type='user',
            target_id=str(user.id),
            action__icontains='suspend'
        ).order_by('-id').first()
        if not last_suspension:
            # Fallback
            suspension_audit_id = 0
        else:
            suspension_audit_id = last_suspension.id

    existing = Appeal.objects.filter(user=user, suspension_audit_id=suspension_audit_id).first()
    if existing:
        raise ValueError("An appeal has already been submitted for this suspension.")

    appeal = Appeal.objects.create(
        user=user,
        suspension_audit_id=suspension_audit_id,
        text=text,
        status='open'
    )
    return appeal


def decide_appeal(actor, appeal: Appeal, outcome: str) -> Appeal:
    """
    Decide an appeal (outcome: 'upheld' or 'overturned').
    Decider must not be the actor who suspended the user.
    """
    from core.models import AuditLog
    if appeal.suspension_audit_id:
        suspend_audit = AuditLog.objects.filter(id=appeal.suspension_audit_id).first()
        if suspend_audit and suspend_audit.actor_id == actor.id:
            raise PermissionError("The administrator who suspended the user cannot decide this appeal.")

    if outcome not in ('upheld', 'overturned'):
        raise ValueError("Invalid outcome; must be 'upheld' or 'overturned'.")

    appeal.status = outcome
    appeal.decided_by = actor
    appeal.decided_at = timezone.now()
    appeal.save()

    if outcome == 'overturned':
        from accounts.services import unsuspend_user
        unsuspend_user(actor=actor, user=appeal.user, reason="Appeal granted")

    log_audit(
        actor=actor,
        action=f"appeal_{outcome}",
        target_type='appeal',
        target_id=str(appeal.id),
        details={'outcome': outcome, 'user_id': appeal.user_id}
    )
    return appeal
