#!/usr/bin/env python3
"""
Collision Delta Calculator — mod_verif_01 Implementation
Quantifies divergence between institutional claims and material ground truth.

Usage:
  python3 collision_calculator.py                    # Run demo cases
  python3 -c "from collision_calculator import C; r=C.appeal_reversal(0.7,0.9); print(r)"

Thresholds:
  collision_delta > 0.15 -> REJECT (ERR_VERIFICATION_COLLISION)
  collision_delta > 0.25 for attestation -> WARN (WARN_ATTESTATION_UNVERIFIED)
  NDA-concealed data -> REJECT immediately (ERR_EPISTEMIC_WEAPON)
"""

import json
from datetime import datetime
from typing import Optional, Dict, Any

class CollisionCalculator:
    """Calculate verification collision metrics for algorithmic extraction systems."""

    def __init__(self, threshold: float = 0.15):
        self.threshold = threshold

    @staticmethod
    def appeal_reversal(claimed_accuracy: float, reversal_rate: float) -> Dict[str, Any]:
        """AI insurance denial: claimed accuracy vs. observed appeal reversal rate."""
        eff_acc = 1 - reversal_rate
        delta = abs(claimed_accuracy - eff_acc)
        verdict = "REJECT" if delta > CollisionCalculator._threshold() else "ACCEPT"
        return {
            "metric_type": "appeal_reversal",
            "claimed_accuracy": claimed_accuracy,
            "observed_reversal_rate": reversal_rate,
            "effective_accuracy": eff_acc,
            "collision_delta": round(delta, 3),
            "verdict": verdict,
            "verdict_code": "ERR_VERIFICATION_COLLISION" if delta > CollisionCalculator._threshold() else None,
            "integrity_score": round(1 - delta, 3),
        }

    @staticmethod
    def attestation_gap(attestation_pct: float, third_party_frac: float, disclosed_frac: float) -> Dict[str, Any]:
        """Self-attestation without independent verification."""
        gap = (1 - third_party_frac) * 0.5 + (1 - disclosed_frac) * 0.4 + attestation_pct * 0.1
        delta = round(min(gap, 1.0), 3)
        warn_thresh = 0.25
        verdict = "WARN" if delta > warn_thresh else "ACCEPT"
        return {
            "metric_type": "attestation_unverified",
            "attestation_coverage_pct": round(attestation_pct * 100),
            "third_party_verification_frac": third_party_frac,
            "disclosed_data_frac": disclosed_frac,
            "verification_gap_index": delta,
            "collision_delta": delta,
            "integrity_score": round(1 - gap, 3),
            "concealment_defaults_to_rejection": True,
            "verdict": verdict,
            "verdict_code": "WARN_ATTESTATION_UNVERIFIED" if delta > warn_thresh else None,
        }

    @staticmethod
    def nda_concealment(total_communities: int, communities_with_nda: int,
                       disclosed_data_fraction: float = 0.35) -> Dict[str, Any]:
        """When the gatekeeper hides data needed to audit their own claims."""
        nda_coverage_pct = communities_with_nda / total_communities if total_communities > 0 else 0
        vii = min(nda_coverage_pct * 1.5 + (1 - disclosed_data_fraction) * 0.5, 1.0)
        delta = round(vii, 3)
        return {
            "metric_type": "nda_concealment",
            "total_communities": total_communities,
            "communities_with_nda": communities_with_nda,
            "nda_coverage_pct": round(nda_coverage_pct * 100),
            "disclosed_data_fraction": disclosed_data_fraction,
            "verification_impossibility_index": delta,
            "collision_delta": delta,
            "integrity_score": round(max(0, 1 - delta), 3),
            "concealment_defaults_to_rejection": True,
            "verdict": "REJECT",
            "verdict_code": "ERR_EPISTEMIC_WEAPON",
            "justification": "NDA-concealed data prevents verification. The sealed room IS the verdict.",
        }

    @staticmethod
    def water_rights_pledge(institutional_pledge: str, pledge_target_year: int,
                           current_consumption_gallons: float, projected_consumption_gallons: float) -> Dict[str, Any]:
        """Water consumption pledges vs. internal projections."""
        if "positive" in institutional_pledge.lower() or "neutral" in institutional_pledge.lower():
            expected_change = 0.0
            actual_factor = (projected_consumption_gallons / current_consumption_gallons) - 1
        else:
            expected_change = 1.0
            actual_factor = 0.5
        delta = abs(expected_change - actual_factor)
        normalized = min(delta, 1.0)
        return {
            "metric_type": "water_rights",
            "institutional_pledge": institutional_pledge,
            "target_year": pledge_target_year,
            "current_consumption_gallons": current_consumption_gallons,
            "projected_consumption_gallons": projected_consumption_gallons,
            "projection_increase_factor": round(actual_factor, 3),
            "collision_delta": round(normalized, 3),
            "integrity_score": round(1 - normalized, 3),
            "verdict": "REJECT" if normalized > 0.15 else "WARN",
            "verdict_code": "ERR_EPISTEMIC_WEAPON" if normalized > 0.15 else None,
        }

    @staticmethod
    def corporate_policy_behavior(behavior_alignment: float, independent_audit_frac: float,
                                  self_controlled_narrative: float) -> Dict[str, Any]:
        """Corporate stated values vs. actual political/economic behavior."""
        gap = (1 - behavior_alignment) * 0.5 + (1 - independent_audit_frac) * 0.4 + self_controlled_narrative * 0.1
        delta = round(min(gap, 1.0), 3)
        return {
            "metric_type": "corporate_policy_behavior",
            "behavior_alignment_fraction": behavior_alignment,
            "independent_audit_fraction": independent_audit_frac,
            "self_controlled_narrative": self_controlled_narrative,
            "verification_gap_index": delta,
            "collision_delta": delta,
            "integrity_score": round(1 - gap, 3),
            "verdict": "REJECT" if delta > 0.15 else ("WARN" if delta > 0.25 else "ACCEPT"),
            "verdict_code": "ERR_VERIFICATION_COLLISION" if delta > 0.15 else (
                "WARN_ATTESTATION_UNVERIFIED" if delta > 0.25 else None),
        }

    @staticmethod
    def career_promise_reality(claimed_job_rate: float, observed_unemployment_pct: float,
                               enrollment_growth_5yr: float, job_decline_5yr: float) -> Dict[str, Any]:
        """Institutional promise (career path) vs. material reality (jobs vanished)."""
        # Expected vs. actual divergence: promised employability vs. actual unemployment
        expected_unemployment = 1 - claimed_job_rate
        collision = abs(expected_unemployment - observed_unemployment_pct / 100.0)
        # Amplify by enrollment-to-job market misalignment rate
        alignment_penalty = abs(enrollment_growth_5yr + job_decline_5yr) / 200.0 if (enrollment_growth_5yr or job_decline_5yr) else 0
        delta = round(min(collision + alignment_penalty, 1.0), 3)
        return {
            "metric_type": "career_promise_reality",
            "claimed_job_rate": claimed_job_rate,
            "observed_unemployment_pct": observed_unemployment_pct,
            "expected_unemployment_rate": round(expected_unemployment, 3),
            "enrollment_growth_5yr": enrollment_growth_5yr,
            "job_decline_5yr": job_decline_5yr,
            "market_alignment_factor": round(1 - alignment_penalty, 3),
            "collision_delta": delta,
            "integrity_score": round(1 - delta, 3),
            "verdict": "REJECT" if delta > 0.20 else ("WARN" if delta > 0.10 else "ACCEPT"),
            "verdict_code": "ERR_CAREER_PROMISE_COLLISION" if delta > 0.20 else (
                "WARN_EDUCATIONAL_MISMATCH" if delta > 0.10 else None),
        }

    @staticmethod
    def _threshold() -> float:
        return 0.15

def generate_muess_receipt(receipt_type: str, domain_data: Dict[str, Any], collision: Dict[str, Any]) -> Dict[str, Any]:
    """Generate a full M-UESS v1.2 receipt with verification collision extension."""
    base = {
        "receipt_id": f"verif-collision-{receipt_type}-{domain_data.get('jurisdiction', 'unknown')}-2026-001",
        "domain": domain_data.get("domain", "verification_collision"),
        "jurisdiction": domain_data.get("jurisdiction", "Federal + State"),
        "timestamp": datetime.utcnow().isoformat(),
    }

    receipt = {
        **base,
        "extraction_metrics": collision,
        "extensions": {"mod_verif_01": collision},
        "remedy_execution": {
            "auto_expire_triggered": True,
            "burden_inverted": True,
            "deployment_verdict": {
                "status": collision.get("verdict", "ACCEPT"),
                "verdict_code": collision.get("verdict_code"),
                "justification": collision.get("justification", collision.get("analysis")),
            }
        }
    }
    return receipt

if __name__ == "__main__":
    calc = CollisionCalculator(threshold=0.15)

    print("=" * 70)
    print("COLLISION DELTA CALCULATOR — mod_verif_01 Implementation")
    print("=" * 70)

    # Case 1: nH Predict insurance denial
    print("[CASE 1] UnitedHealth nH Predict — AI Insurance Denial")
    print("-" * 60)
    uhc = calc.appeal_reversal(0.70, 0.90)
    print(json.dumps(uhc, indent=2))

    # Case 2: California EO N-5-26 attestation system
    print("[CASE 2] California EO N-5-26 — Vendor Attestation")
    print("-" * 60)
    ca = calc.attestation_gap(1.0, 0.0, 0.30)
    print(json.dumps(ca, indent=2))

    # Case 3: NDA concealment in Virginia data center communities
    print("[CASE 3] NDA Concealment — Virginia Data Center Communities")
    print("-" * 60)
    nda = calc.nda_concealment(31, 25)
    print(json.dumps(nda, indent=2))

    # Case 4: Microsoft water-positive pledge vs Phoenix projections
    print("[CASE 4] Microsoft Water Positive Pledge — Resource Extraction")
    print("-" * 60)
    water = calc.water_rights_pledge("water positive by 2030", 2030,
                                      385_000_000, 3_700_000_000)
    print(json.dumps(water, indent=2))

    # Case 5: OpenAI corporate policy/behavior divergence
    print("[CASE 5] OpenAI Policy Paper vs Political Spending — Corporate Hypocrisy")
    print("-" * 60)
    openai = calc.corporate_policy_behavior(0.20, 0.00, 1.00)
    print(json.dumps(openai, indent=2))

    # Case 6: Computer Science career promise vs reality (new metric type)
    print("[CASE 6] CS Major Career Promise vs Reality — Educational Extraction")
    print("-" * 60)
    cs = calc.career_promise_reality(claimed_job_rate=0.95, observed_unemployment_pct=28.0,
                                     enrollment_growth_5yr=45.0, job_decline_5yr=-32.0)
    print(json.dumps(cs, indent=2))

    # Full M-UESS receipt for the nH Predict case
    print("" + "=" * 70)
    print("M-UESS v1.2 RECEIPT — nH Predict Case")
    print("=" * 70)
    receipt = generate_muess_receipt("uhc-nhpredict", {
        "domain": "healthcare_authorization",
        "jurisdiction": "Federal (CMS) + Minnesota",
        "gatekeeper": "UnitedHealth Group / nH Predict",
        "burdened_party": "Medicare Advantage beneficiaries"
    }, uhc)
    print(json.dumps(receipt, indent=2))

    print("" + "=" * 70)
    print("CONCEALMENT-DEFAULTS-TO-REJECTION PRINCIPLE")
    print("=" * 70)
    print("When the gatekeeper hides data needed to audit their own claim,")
    print("the claim is rejected by default. You do not need to prove the lie")
    print("when the liar has sealed the evidence room. The sealed room IS the verdict.")
    print("Formula: If NDA_coverage > 0.5 AND collision_delta > threshold -> REJECT")
    print("          Verdict Code: ERR_EPISTEMIC_WEAPON")
    print("=" * 70)