Quantity Limit & Days Supply Validation

from __future__ import annotations
import re
import logging
from dataclasses import dataclass, field
from decimal import Decimal, ROUND_HALF_UP
from enum import Enum
from typing import Dict, Optional, Tuple
from datetime import datetime

# NCPDP Reject Code Mappings (D.0 Standard)
class NCPDPRejectCode(str, Enum):
    QUANTITY_LIMIT_EXCEEDED = "75"
    DAYS_SUPPLY_EXCEEDED = "76"
    PRIOR_AUTH_REQUIRED = "89"
    SUCCESS = "00"

@dataclass(frozen=True)
class UOMConversion:
    """Maps manufacturer UOM to CMS-standard dispensing units."""
    to_tablet: Decimal = Decimal("1.0")
    to_milliliter: Decimal = Decimal("1.0")
    to_gram: Decimal = Decimal("1.0")

@dataclass
class ClaimPayload:
    """Simulated NCPDP D.0 claim fields."""
    ndc: str
    gpi: str
    dispensed_qty: Decimal
    dispensed_uom: str
    days_supply: int
    sig_code: str
    plan_ql_max: Decimal
    plan_ds_max: int
    is_maintenance: bool

@dataclass
class ValidationResult:
    status: NCPDPRejectCode
    adjusted_qty: Decimal
    adjusted_days_supply: int
    ncpdp_field_map: Dict[str, str] = field(default_factory=dict)
    routing_flags: list[str] = field(default_factory=list)
    audit_message: str = ""

# Pre-compiled SIG parser for common dosing frequencies
SIG_PATTERN = re.compile(
    r"(?:take|apply|instill)\s+(\d+)\s*(?:tablet|capsule|drop|puff|ml|mg)?\s*"
    r"(?:every|q)\s*(\d+)\s*(hour|hr|h|day|d|week|wk)?",
    re.IGNORECASE
)

# Convert a parsed SIG interval unit to hours for a common time base.
_INTERVAL_UNIT_HOURS = {
    "hour": 1, "hr": 1, "h": 1,
    "day": 24, "d": 24,
    "week": 168, "wk": 168,
}

class QLDSValidator:
    """Deterministic QL/DS validation engine for PBM adjudication."""
    
    UOM_MATRIX: Dict[str, UOMConversion] = {
        "TAB": UOMConversion(to_tablet=Decimal("1")),
        "ML": UOMConversion(to_milliliter=Decimal("1")),
        "GM": UOMConversion(to_gram=Decimal("1")),
        "EA": UOMConversion(to_tablet=Decimal("1")),
    }

    @classmethod
    def _normalize_uom(cls, qty: Decimal, uom: str) -> Decimal:
        """Convert manufacturer UOM to CMS-standard dispensing units."""
        conv = cls.UOM_MATRIX.get(uom.upper())
        if not conv:
            raise ValueError(f"Unsupported UOM: {uom}")
        # Simplified normalization; real-world requires NDC package size lookup
        return (qty * conv.to_tablet).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)

    @classmethod
    def _derive_days_supply(cls, sig: str, qty: Decimal) -> int:
        """Parse SIG code to calculate clinically implied days supply."""
        match = SIG_PATTERN.search(sig)
        if not match:
            # Fallback to plan-provided days supply if SIG is unstructured
            return 0
        dose_per_admin = int(match.group(1))
        interval_value = int(match.group(2))
        if interval_value == 0:
            return 0
        unit = (match.group(3) or "hour").lower()
        interval_hours = interval_value * _INTERVAL_UNIT_HOURS.get(unit, 1)
        administrations_per_day = Decimal("24") / Decimal(interval_hours)
        daily_consumption = administrations_per_day * dose_per_admin
        if daily_consumption <= 0:
            return 0
        implied_days = qty / daily_consumption
        return int(implied_days.quantize(Decimal("1"), rounding=ROUND_HALF_UP))

    @classmethod
    def validate(cls, claim: ClaimPayload) -> ValidationResult:
        """Execute deterministic QL/DS validation against plan limits."""
        try:
            normalized_qty = cls._normalize_uom(claim.dispensed_qty, claim.dispensed_uom)
            implied_ds = cls._derive_days_supply(claim.sig_code, normalized_qty)
            effective_ds = implied_ds if implied_ds > 0 else claim.days_supply

            routing_flags = []
            audit_msgs = []

            # QL Validation
            if normalized_qty > claim.plan_ql_max:
                return ValidationResult(
                    status=NCPDPRejectCode.QUANTITY_LIMIT_EXCEEDED,
                    adjusted_qty=claim.plan_ql_max,
                    adjusted_days_supply=effective_ds,
                    ncpdp_field_map={"440-QU": str(claim.plan_ql_max)},
                    audit_message=f"QL exceeded: dispensed {normalized_qty} > max {claim.plan_ql_max}"
                )

            # DS Validation
            if effective_ds > claim.plan_ds_max:
                return ValidationResult(
                    status=NCPDPRejectCode.DAYS_SUPPLY_EXCEEDED,
                    adjusted_qty=normalized_qty,
                    adjusted_days_supply=claim.plan_ds_max,
                    ncpdp_field_map={"442-DP": str(claim.plan_ds_max)},
                    audit_message=f"DS exceeded: implied {effective_ds} > max {claim.plan_ds_max}"
                )

            # Override/PA routing logic
            if normalized_qty > (claim.plan_ql_max * Decimal("0.8")) and claim.is_maintenance:
                routing_flags.append("MAINTENANCE_ESCALATION")
                audit_msgs.append("High-volume maintenance fill flagged for tier review")

            return ValidationResult(
                status=NCPDPRejectCode.SUCCESS,
                adjusted_qty=normalized_qty,
                adjusted_days_supply=effective_ds,
                ncpdp_field_map={"440-QU": str(normalized_qty), "442-DP": str(effective_ds)},
                routing_flags=routing_flags,
                audit_message="; ".join(audit_msgs) if audit_msgs else "Validation passed"
            )
        except Exception as e:
            logging.error(f"QL/DS validation failure for NDC {claim.ndc}: {e}")
            return ValidationResult(
                status=NCPDPRejectCode.PRIOR_AUTH_REQUIRED,
                adjusted_qty=Decimal("0"),
                adjusted_days_supply=0,
                audit_message=f"System exception triggered PA fallback: {str(e)}"
            )