"""Escalation Engine selectors — read-only queries."""

from __future__ import annotations

from django.db.models import Q, QuerySet
from django.utils import timezone

from simorgh.apps.escalation_engine.models import (
    EscalationInstance,
    EscalationLog,
    EscalationRule,
    EscalationStatus,
)


def rules_for_tenant(tenant_id: int) -> QuerySet[EscalationRule]:
    return EscalationRule.objects.filter(tenant_id=tenant_id)


def active_rules(tenant_id: int) -> QuerySet[EscalationRule]:
    return rules_for_tenant(tenant_id).filter(is_active=True)


def rules_by_trigger_type(tenant_id: int, trigger_type: str) -> QuerySet[EscalationRule]:
    return active_rules(tenant_id).filter(trigger_type=trigger_type)


def rule_by_public_id(tenant_id: int, public_id: str) -> EscalationRule:
    return EscalationRule.objects.get(tenant_id=tenant_id, public_id=public_id)


def instances_for_tenant(tenant_id: int) -> QuerySet[EscalationInstance]:
    return EscalationInstance.objects.filter(tenant_id=tenant_id).select_related("rule")


def pending_instances(tenant_id: int) -> QuerySet[EscalationInstance]:
    return instances_for_tenant(tenant_id).filter(
        status__in=(EscalationStatus.PENDING, EscalationStatus.IN_PROGRESS),
    )


def overdue_instances(tenant_id: int) -> QuerySet[EscalationInstance]:
    """Escalation instances triggered but not yet escalated or resolved."""
    return (
        pending_instances(tenant_id)
        .filter(
            triggered_at__lt=timezone.now(),
            escalated_at__isnull=True,
        )
        .order_by("triggered_at")
    )


def resolved_instances(tenant_id: int) -> QuerySet[EscalationInstance]:
    return instances_for_tenant(tenant_id).filter(status=EscalationStatus.RESOLVED)


def instance_by_public_id(tenant_id: int, public_id: str) -> EscalationInstance:
    return EscalationInstance.objects.get(tenant_id=tenant_id, public_id=public_id)


def instances_for_entity(content_type_id: int, object_id: int) -> QuerySet[EscalationInstance]:
    return (
        EscalationInstance.objects.filter(
            source_content_type_id=content_type_id,
            source_object_id=object_id,
        )
        .select_related("rule")
        .order_by("-created_at")
    )


def logs_for_tenant(tenant_id: int) -> QuerySet[EscalationLog]:
    return (
        EscalationLog.objects.filter(tenant_id=tenant_id)
        .select_related("instance", "rule", "actor")
        .order_by("-created_at")
    )


def logs_for_instance(instance_id: int) -> QuerySet[EscalationLog]:
    return EscalationLog.objects.filter(instance_id=instance_id).order_by("-created_at")


def search_rules(tenant_id: int, query: str) -> QuerySet[EscalationRule]:
    return (
        rules_for_tenant(tenant_id)
        .filter(Q(name__icontains=query) | Q(description__icontains=query))
        .distinct()
    )