OFF_DataQuality/validation/parity_validator.py

"""Back-to-back validation engine for Perl-to-Python rule migration."""
from __future__ import annotations

import argparse
import hashlib
import json
import math
import subprocess
from datetime import datetime, timezone
from pathlib import Path
from statistics import mean
from typing import Dict, List, Mapping, Sequence, Set
from uuid import uuid4

from declarative.check_runners import run_declarative_checks
from data.load_dataset import (
    DB_PATH,
    DEFAULT_OFF_JSONL,
    SAMPLE_FILE,
    create_and_load_dataset,
)
from duckdb_utils.create_tables import count_violations, sample_violations
from extractor.perl_logic_extractor import extract_rules
from migration.llm_converter import convert_rules, repair_conversion_with_counterexamples
from perl_checks.legacy_checks import LEGACY_RULES, get_legacy_rule_map, get_perl_rule_snippets, run_perl_checks
from python_checks.generated_checks import compile_generated_checks
from rulepacks.registry import DEFAULT_PROFILE, SUPPORTED_PROFILES, attach_profile_metadata, get_profile_rule_names, validate_profile
from validation.verification import run_rule_verification

RESULT_PATH = Path(__file__).resolve().parent.parent / "results" / "migration_results.json"
TABLE_NAME = "nutrition_table"


def _sha256_text(text: str) -> str:
    return hashlib.sha256(text.encode("utf-8")).hexdigest()


def _sha256_json(payload: object) -> str:
    normalized = json.dumps(payload, sort_keys=True, default=str, separators=(",", ":"))
    return _sha256_text(normalized)


def _resolve_git_commit() -> str:
    try:
        completed = subprocess.run(
            ["git", "rev-parse", "HEAD"],
            capture_output=True,
            text=True,
            encoding="utf-8",
            errors="replace",
            check=False,
            timeout=5,
        )
        if completed.returncode == 0:
            value = (completed.stdout or "").strip()
            if value:
                return value
    except Exception:
        pass
    return "unknown"


def _dataset_fingerprint_payload(

    products: Sequence[Mapping[str, object]],

    source_path: Path | None,

    dataset_size: int,

    seed: int,

) -> Dict[str, object]:
    normalized_products = [
        {key: product.get(key) for key in sorted(product.keys())}
        for product in sorted(products, key=lambda row: str(row.get("product_id", "")))
    ]
    product_ids = [str(product.get("product_id", "")) for product in normalized_products if product.get("product_id")]
    source_mode = "off_jsonl" if source_path else "synthetic"
    payload = {
        "source_mode": source_mode,
        "source_jsonl": str(source_path) if source_path else "synthetic",
        "requested_size": int(dataset_size),
        "products_tested": len(normalized_products),
        "seed": int(seed) if source_mode == "synthetic" else None,
        "product_id_first": product_ids[0] if product_ids else None,
        "product_id_last": product_ids[-1] if product_ids else None,
        "sha256": _sha256_json(normalized_products),
    }
    return payload


def _rulepack_fingerprint_payload(structured_rules: Sequence[Mapping[str, object]], profile_name: str) -> Dict[str, object]:
    rule_names = sorted(str(rule.get("rule_name", "")) for rule in structured_rules)
    ir_hashes = sorted(str(rule.get("rule_ir_hash", "")) for rule in structured_rules)
    payload = {
        "profile": profile_name,
        "rule_count": len(structured_rules),
        "rule_names_sha256": _sha256_json(rule_names),
        "rule_ir_sha256": _sha256_json(ir_hashes),
    }
    return payload


def _wilson_interval(successes: int, trials: int, z: float = 1.96) -> tuple[float, float]:
    """Return two-sided Wilson score interval for a binomial proportion."""
    if trials <= 0:
        return 0.0, 1.0
    p = successes / trials
    z2 = z * z
    denom = 1.0 + (z2 / trials)
    center = (p + (z2 / (2.0 * trials))) / denom
    margin = (z * (((p * (1.0 - p)) + (z2 / (4.0 * trials))) / trials) ** 0.5) / denom
    lower = max(0.0, center - margin)
    upper = min(1.0, center + margin)
    return lower, upper


def _beta_continued_fraction(a: float, b: float, x: float, max_iter: int = 400, eps: float = 3e-12) -> float:
    """Continued fraction helper for incomplete beta evaluation."""
    qab = a + b
    qap = a + 1.0
    qam = a - 1.0
    c = 1.0
    d = 1.0 - (qab * x / qap)
    if abs(d) < 1e-30:
        d = 1e-30
    d = 1.0 / d
    h = d

    for m in range(1, max_iter + 1):
        m2 = 2 * m
        aa = (m * (b - m) * x) / ((qam + m2) * (a + m2))
        d = 1.0 + aa * d
        if abs(d) < 1e-30:
            d = 1e-30
        c = 1.0 + aa / c
        if abs(c) < 1e-30:
            c = 1e-30
        d = 1.0 / d
        h *= d * c

        aa = (-(a + m) * (qab + m) * x) / ((a + m2) * (qap + m2))
        d = 1.0 + aa * d
        if abs(d) < 1e-30:
            d = 1e-30
        c = 1.0 + aa / c
        if abs(c) < 1e-30:
            c = 1e-30
        d = 1.0 / d
        delta = d * c
        h *= delta
        if abs(delta - 1.0) < eps:
            break

    return h


def _regularized_incomplete_beta(a: float, b: float, x: float) -> float:
    """Regularized incomplete beta I_x(a,b) in [0,1]."""
    if x <= 0.0:
        return 0.0
    if x >= 1.0:
        return 1.0

    bt = math.exp(
        math.lgamma(a + b)
        - math.lgamma(a)
        - math.lgamma(b)
        + a * math.log(x)
        + b * math.log(1.0 - x)
    )

    if x < (a + 1.0) / (a + b + 2.0):
        return bt * _beta_continued_fraction(a, b, x) / a
    return 1.0 - (bt * _beta_continued_fraction(b, a, 1.0 - x) / b)


def _beta_ppf(probability: float, alpha: float, beta: float, tol: float = 1e-7, max_iter: int = 200) -> float:
    """Inverse CDF for Beta(alpha, beta) using monotonic bisection."""
    p = min(1.0, max(0.0, probability))
    lo = 0.0
    hi = 1.0
    for _ in range(max_iter):
        mid = (lo + hi) / 2.0
        cdf_mid = _regularized_incomplete_beta(alpha, beta, mid)
        if abs(cdf_mid - p) < tol:
            return mid
        if cdf_mid < p:
            lo = mid
        else:
            hi = mid
    return (lo + hi) / 2.0


def _run_python_checks(

    products: Sequence[Mapping[str, object]],

    structured_rules: Sequence[Dict[str, object]],

    python_checks: Dict[str, object],

) -> Dict[str, Dict[str, object]]:
    rule_names = [str(rule["rule_name"]) for rule in structured_rules]
    per_rule_products: Dict[str, Set[str]] = {rule_name: set() for rule_name in rule_names}
    per_product_tags: Dict[str, List[str]] = {}

    for product in products:
        product_id = str(product.get("product_id"))
        tags: List[str] = []
        for rule in structured_rules:
            rule_name = str(rule["rule_name"])
            check_fn = python_checks[rule_name]
            tag = check_fn(product)
            if tag:
                tags.append(str(tag))
                per_rule_products[rule_name].add(product_id)
        per_product_tags[product_id] = tags

    return {
        "per_product": per_product_tags,
        "per_rule": {name: sorted(ids) for name, ids in per_rule_products.items()},
    }


def _run_python_verification(

    structured_rules: Sequence[Dict[str, object]],

    python_checks: Mapping[str, object],

    conversion_metadata: Mapping[str, Mapping[str, object]],

    seed: int,

    legacy_rules: Sequence[object],

) -> Dict[str, Dict[str, object]]:
    legacy_map = get_legacy_rule_map(legacy_rules)
    verification_by_rule: Dict[str, Dict[str, object]] = {}
    for rule in structured_rules:
        rule_name = str(rule["rule_name"])
        legacy_rule = legacy_map.get(rule_name)
        if legacy_rule is None:
            verification_by_rule[rule_name] = {
                "equivalence_cases": 0,
                "equivalence_matches": 0,
                "equivalence_mismatches": 0,
                "equivalence_match_rate": 1.0,
                "equivalence_status": "PASS",
                "counterexamples": [],
                "mutation_total": 0,
                "mutation_killed": 0,
                "mutation_survived": 0,
                "mutation_score": 1.0,
                "mutation_survived_mutants": [],
                "verification_score": 1.0,
            }
            continue
        verification_by_rule[rule_name] = run_rule_verification(
            rule=rule,
            perl_evaluator=legacy_rule.evaluator,
            check_fn=python_checks[rule_name],
            python_code=str(conversion_metadata[rule_name]["python_code"]),
            function_name=str(conversion_metadata[rule_name]["function_name"]),
            seed=seed,
        )
    return verification_by_rule


def _build_failed_case_rows(

    mismatch_ids: Sequence[str],

    product_map: Dict[str, Mapping[str, object]],

    perl_ids: Set[str],

    python_ids: Set[str],

    limit: int = 10,

) -> List[Dict[str, object]]:
    rows: List[Dict[str, object]] = []
    for product_id in mismatch_ids[:limit]:
        product = dict(product_map[product_id])
        rows.append(
            {
                "product_id": product_id,
                "perl_triggered": product_id in perl_ids,
                "python_triggered": product_id in python_ids,
                "energy_kj": product.get("energy_kj"),
                "energy_kj_computed": product.get("energy_kj_computed"),
                "energy_kcal": product.get("energy_kcal"),
                "fat": product.get("fat"),
                "saturated_fat": product.get("saturated_fat"),
                "carbohydrates": product.get("carbohydrates"),
                "sugars": product.get("sugars"),
                "starch": product.get("starch"),
                "sodium": product.get("sodium"),
                "ingredients_text_present": product.get("ingredients_text_present"),
                "contains_statement_present": product.get("contains_statement_present"),
                "allergen_evidence_present": product.get("allergen_evidence_present"),
                "fop_threshold_exceeded": product.get("fop_threshold_exceeded"),
                "fop_symbol_present": product.get("fop_symbol_present"),
                "fop_exempt_proxy": product.get("fop_exempt_proxy"),
                "product_is_prepackaged_proxy": product.get("product_is_prepackaged_proxy"),
                "lc": product.get("lc"),
                "lang": product.get("lang"),
                "language_code": product.get("language_code"),
            }
        )
    return rows


def _compute_rule_result(

    rule: Dict[str, object],

    perl_rule_products: Sequence[str],

    python_rule_products: Sequence[str],

    product_map: Dict[str, Mapping[str, object]],

    conversion_meta: Dict[str, object],

    verification_meta: Mapping[str, object] | None = None,

    db_path: Path = DB_PATH,

) -> Dict[str, object]:
    product_ids = set(product_map)
    perl_ids = set(perl_rule_products)
    python_ids = set(python_rule_products)
    supporting_ids = perl_ids | python_ids

    matching_products = {
        product_id
        for product_id in product_ids
        if (product_id in perl_ids) == (product_id in python_ids)
    }
    mismatch_ids = sorted(product_ids - matching_products)
    total_tests = len(product_ids)
    supporting_violations = len(supporting_ids)
    positive_matches = len(perl_ids & python_ids)
    positive_coverage = (supporting_violations / total_tests) if total_tests else 0.0

    parity_confidence = (len(matching_products) / total_tests) if total_tests else 1.0
    parity_ci_lower, parity_ci_upper = _wilson_interval(len(matching_products), total_tests)
    coverage_ci_lower, coverage_ci_upper = _wilson_interval(supporting_violations, total_tests)
    positive_agreement = (positive_matches / supporting_violations) if supporting_violations else 0.5
    evidence_alpha = positive_matches + 1.0
    evidence_beta = (supporting_violations - positive_matches) + 1.0
    # Posterior mean for reference.
    evidence_posterior_mean = evidence_alpha / (evidence_alpha + evidence_beta)
    # Conservative 95% lower credible bound.
    evidence_ci_lower = _beta_ppf(0.05, evidence_alpha, evidence_beta)
    evidence_ci_upper = _beta_ppf(0.95, evidence_alpha, evidence_beta)
    llm_confidence = float(conversion_meta["llm_confidence"])
    overall_confidence = llm_confidence * parity_ci_lower * evidence_ci_lower
    status = "MATCH" if not mismatch_ids else "REVIEW"

    duckdb_condition = str(rule["duckdb_condition"])
    duckdb_error_count = count_violations(duckdb_condition, db_path=db_path)
    duckdb_examples = sample_violations(duckdb_condition, limit=5, db_path=db_path)
    verification = dict(verification_meta or {})

    return {
        "rule_name": rule["rule_name"],
        "tag": rule["tag"],
        "severity": rule["severity"],
        "condition": rule["condition"],
        "jurisdiction": rule.get("jurisdiction", "global"),
        "profile_tags": list(rule.get("profile_tags", [])),
        "regulatory_type": rule.get("regulatory_type", ""),
        "legal_citation": rule.get("legal_citation", ""),
        "source_url": rule.get("source_url", ""),
        "effective_date": rule.get("effective_date", ""),
        "review_status": rule.get("review_status", ""),
        "reviewer": rule.get("reviewer", ""),
        "required_fields": list(rule.get("required_fields", [])),
        "exemption_logic": rule.get("exemption_logic", ""),
        "rule_notes": rule.get("rule_notes", ""),
        "rule_ir": rule.get("rule_ir"),
        "rule_ir_hash": rule.get("rule_ir_hash"),
        "condition_type": rule.get("condition_type", "unknown"),
        "complexity": rule.get("complexity", "unknown"),
        "declarative_friendly": rule.get("declarative_friendly"),
        "products_tested": total_tests,
        "perl_errors": len(perl_ids),
        "python_errors": len(python_ids),
        "supporting_violations": supporting_violations,
        "positive_matches": positive_matches,
        "positive_agreement": round(positive_agreement, 4),
        "positive_coverage": round(positive_coverage, 4),
        "parity_ci_lower": round(parity_ci_lower, 4),
        "parity_ci_upper": round(parity_ci_upper, 4),
        "coverage_ci_lower": round(coverage_ci_lower, 4),
        "coverage_ci_upper": round(coverage_ci_upper, 4),
        "evidence_alpha": round(evidence_alpha, 4),
        "evidence_beta": round(evidence_beta, 4),
        "evidence_posterior_mean": round(evidence_posterior_mean, 4),
        "evidence_ci_lower": round(evidence_ci_lower, 4),
        "evidence_ci_upper": round(evidence_ci_upper, 4),
        # Back-compat alias for old dashboards/scripts.
        "evidence_factor": round(evidence_ci_lower, 4),
        "matches": len(matching_products),
        "mismatches": len(mismatch_ids),
        "confidence": round(parity_confidence, 4),
        "llm_confidence": round(llm_confidence, 4),
        "overall_confidence": round(overall_confidence, 4),
        "overall_method": "llm_confidence * parity_ci_lower_95 * evidence_ci_lower_95_beta_posterior",
        "status": status,
        "duckdb_query": f"SELECT * FROM {TABLE_NAME} WHERE {duckdb_condition}",
        "duckdb_errors": duckdb_error_count,
        "duckdb_condition": duckdb_condition,
        "duckdb_example_rows": duckdb_examples,
        "equivalence_cases": int(verification.get("equivalence_cases", 0)),
        "equivalence_matches": int(verification.get("equivalence_matches", 0)),
        "equivalence_mismatches": int(verification.get("equivalence_mismatches", 0)),
        "equivalence_match_rate": round(float(verification.get("equivalence_match_rate", 1.0)), 4),
        "equivalence_status": verification.get("equivalence_status", "PASS"),
        "equivalence_counterexamples": list(verification.get("counterexamples", [])),
        "mutation_total": int(verification.get("mutation_total", 0)),
        "mutation_killed": int(verification.get("mutation_killed", 0)),
        "mutation_survived": int(verification.get("mutation_survived", 0)),
        "mutation_score": round(float(verification.get("mutation_score", 1.0)), 4),
        "mutation_survived_mutants": list(verification.get("mutation_survived_mutants", [])),
        "verification_score": round(float(verification.get("verification_score", 1.0)), 4),
        "counterexample_repair_attempted": bool(verification.get("counterexample_repair_attempted", False)),
        "counterexample_repair_applied": bool(verification.get("counterexample_repair_applied", False)),
        "counterexample_repair_error": str(verification.get("counterexample_repair_error", "")),
        "mismatch_product_ids": mismatch_ids,
        "failed_test_cases": _build_failed_case_rows(
            mismatch_ids=mismatch_ids,
            product_map=product_map,
            perl_ids=perl_ids,
            python_ids=python_ids,
            limit=10,
        ),
        "perl_logic": rule["perl_logic"],
        "python_conversion": conversion_meta["python_code"],
        "conversion_notes": conversion_meta["conversion_notes"],
        "conversion_provider": conversion_meta.get("provider", "unknown"),
        "conversion_execution_mode": conversion_meta.get("execution_mode", ""),
        "conversion_cloud_connected": bool(conversion_meta.get("cloud_connected", False)),
        "conversion_cloud_scan_id": conversion_meta.get("cloud_scan_id", ""),
        "conversion_cloud_scan_url": conversion_meta.get("cloud_scan_url", ""),
    }


def run_pipeline(

    dataset_size: int = 300,

    seed: int = 17,

    results_path: Path = RESULT_PATH,

    source_jsonl: Path | None = None,

    use_default_off_source: bool = True,

    db_path: Path = DB_PATH,

    llm_provider: str = "groq",

    llm_model: str | None = None,

    perl_rules_dir: Path | None = None,

    execution_engine: str = "python",

    soda_mode: str = "local",

    profile: str = DEFAULT_PROFILE,

) -> Dict[str, object]:
    """Run the full migration prototype pipeline and persist JSON results."""
    if execution_engine not in {"python", "dbt", "soda"}:
        raise ValueError("execution_engine must be one of: python, dbt, soda")

    profile_name = validate_profile(profile)
    selected_rule_names = set(get_profile_rule_names(profile_name, [rule.rule_name for rule in LEGACY_RULES]))
    selected_legacy_rules = [rule for rule in LEGACY_RULES if rule.rule_name in selected_rule_names]
    if not selected_legacy_rules:
        raise ValueError(f"No legacy rules selected for profile `{profile_name}`.")

    source_path = source_jsonl
    if source_path is None and use_default_off_source and DEFAULT_OFF_JSONL.exists():
        source_path = DEFAULT_OFF_JSONL

    products = create_and_load_dataset(size=dataset_size, seed=seed, db_path=db_path, source_jsonl=source_path)
    product_map = {str(product["product_id"]): product for product in products}

    perl_output = run_perl_checks(products, selected_legacy_rules)
    if perl_rules_dir is None:
        structured_rules_raw = extract_rules(get_perl_rule_snippets(selected_legacy_rules, rules_dir=None))
    else:
        all_structured = extract_rules(get_perl_rule_snippets(LEGACY_RULES, rules_dir=perl_rules_dir))
        structured_rules_raw = [rule for rule in all_structured if str(rule["rule_name"]) in selected_rule_names]
    structured_rules = attach_profile_metadata(structured_rules_raw, profile=profile_name)
    if not structured_rules:
        raise ValueError(f"No structured rules extracted for profile `{profile_name}`.")

    engine_run: Dict[str, object] | None = None
    verification_by_rule: Dict[str, Dict[str, object]] = {}

    if execution_engine == "python":
        converted_rules = convert_rules(structured_rules, provider=llm_provider, model=llm_model)
        converted_by_name = {str(item["rule_name"]): dict(item) for item in converted_rules}
        repair_flags: Dict[str, Dict[str, object]] = {
            str(rule["rule_name"]): {
                "counterexample_repair_attempted": False,
                "counterexample_repair_applied": False,
                "counterexample_repair_error": "",
            }
            for rule in structured_rules
        }

        python_checks, conversion_metadata = compile_generated_checks(
            [converted_by_name[str(rule["rule_name"])] for rule in structured_rules]
        )
        initial_verification = _run_python_verification(
            structured_rules=structured_rules,
            python_checks=python_checks,
            conversion_metadata=conversion_metadata,
            seed=seed,
            legacy_rules=selected_legacy_rules,
        )

        if llm_provider == "groq":
            for rule in structured_rules:
                rule_name = str(rule["rule_name"])
                verification = initial_verification.get(rule_name, {})
                provider = str(conversion_metadata[rule_name].get("provider", ""))
                if provider != "groq":
                    continue
                if int(verification.get("equivalence_mismatches", 0)) <= 0:
                    continue

                repair_flags[rule_name]["counterexample_repair_attempted"] = True
                try:
                    repaired = repair_conversion_with_counterexamples(
                        rule=rule,
                        converted_rule=converted_by_name[rule_name],
                        counterexamples=list(verification.get("counterexamples", [])),
                        provider=llm_provider,
                        model=llm_model,
                    )
                    if str(repaired.get("python_code", "")) != str(converted_by_name[rule_name].get("python_code", "")):
                        converted_by_name[rule_name] = repaired
                        repair_flags[rule_name]["counterexample_repair_applied"] = True
                except Exception as exc:  # noqa: BLE001
                    repair_flags[rule_name]["counterexample_repair_error"] = f"{exc.__class__.__name__}: {exc}"

        python_checks, conversion_metadata = compile_generated_checks(
            [converted_by_name[str(rule["rule_name"])] for rule in structured_rules]
        )
        verification_by_rule = _run_python_verification(
            structured_rules=structured_rules,
            python_checks=python_checks,
            conversion_metadata=conversion_metadata,
            seed=seed,
            legacy_rules=selected_legacy_rules,
        )
        for rule in structured_rules:
            rule_name = str(rule["rule_name"])
            verification_by_rule.setdefault(rule_name, {}).update(repair_flags.get(rule_name, {}))

        candidate_output = _run_python_checks(products, structured_rules, python_checks)
    else:
        declarative_result = run_declarative_checks(
            rules=structured_rules,
            products=products,
            db_path=db_path,
            engine=execution_engine,
            soda_mode=soda_mode,
        )
        candidate_output = {
            "per_product": declarative_result["per_product"],
            "per_rule": declarative_result["per_rule"],
        }
        conversion_metadata = declarative_result["conversion_metadata"]
        engine_run = declarative_result["engine_run"]

    rule_results: List[Dict[str, object]] = []
    for rule in structured_rules:
        rule_name = str(rule["rule_name"])
        rule_result = _compute_rule_result(
            rule=rule,
            perl_rule_products=perl_output["per_rule"][rule_name],
            python_rule_products=candidate_output["per_rule"][rule_name],
            product_map=product_map,
            conversion_meta=conversion_metadata[rule_name],
            verification_meta=verification_by_rule.get(rule_name),
            db_path=db_path,
        )
        rule_results.append(rule_result)

    passed_rules = sum(1 for row in rule_results if row["status"] == "MATCH")
    total_rules = len(rule_results)
    avg_confidence = mean([row["overall_confidence"] for row in rule_results]) if rule_results else 0.0
    generated_at_utc = datetime.now(timezone.utc).isoformat()
    dataset_fingerprint = _dataset_fingerprint_payload(
        products=products,
        source_path=source_path,
        dataset_size=dataset_size,
        seed=seed,
    )
    rulepack_fingerprint = _rulepack_fingerprint_payload(structured_rules=structured_rules, profile_name=profile_name)
    safe_timestamp = (
        generated_at_utc.replace(":", "").replace("-", "").replace(".", "").replace("+", "p")
    )
    run_id = f"parity_{safe_timestamp}_{uuid4().hex[:8]}"
    git_commit = _resolve_git_commit()

    result_payload: Dict[str, object] = {
        "generated_at_utc": generated_at_utc,
        "run_fingerprint": {
            "run_id": run_id,
            "generated_at_utc": generated_at_utc,
            "execution_engine": execution_engine,
            "soda_mode": soda_mode,
            "llm_provider": llm_provider,
            "llm_model": llm_model or "",
            "code_commit": git_commit,
            "dataset_fingerprint": dataset_fingerprint,
            "rulepack_fingerprint": rulepack_fingerprint,
        },
        "dataset": {
            "jsonl_path": str(SAMPLE_FILE),
            "duckdb_path": str(db_path),
            "products_tested": len(products),
            "source_jsonl": str(source_path) if source_path else "synthetic",
            "perl_rules_source": str(perl_rules_dir) if perl_rules_dir else "inline_legacy_rules",
            "execution_engine": execution_engine,
            "soda_mode": soda_mode,
            "profile": profile_name,
            "profile_rule_count": len(structured_rules),
            "dataset_fingerprint_sha256": dataset_fingerprint["sha256"],
            "rulepack_fingerprint_sha256": rulepack_fingerprint["rule_ir_sha256"],
        },
        "migration_summary": {
            "total_rules": total_rules,
            "passed_rules": passed_rules,
            "rules_needing_review": total_rules - passed_rules,
            "average_overall_confidence": round(avg_confidence, 4),
        },
        "rule_results": rule_results,
    }
    if engine_run is not None:
        result_payload["declarative_engine_run"] = engine_run

    results_path.parent.mkdir(parents=True, exist_ok=True)
    with results_path.open("w", encoding="utf-8") as handle:
        json.dump(result_payload, handle, indent=2)
    return result_payload


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Run Perl/Python parity validation prototype.")
    parser.add_argument("--size", type=int, default=300, help="Number of products to generate.")
    parser.add_argument(
        "--seed",
        type=int,
        default=17,
        help="Random seed for synthetic data generation (ignored when --source-jsonl is set).",
    )
    parser.add_argument(
        "--source-jsonl",
        type=Path,
        default=DEFAULT_OFF_JSONL if DEFAULT_OFF_JSONL.exists() else None,
        help="OFF JSONL source path. Defaults to ./openfoodfacts-products.jsonl when present.",
    )
    parser.add_argument(
        "--llm-provider",
        choices=["simulated", "groq"],
        default="groq",
        help="Rule conversion provider.",
    )
    parser.add_argument(
        "--llm-model",
        default=None,
        help="Optional model override (for selected LLM provider).",
    )
    parser.add_argument(
        "--perl-rules-dir",
        type=Path,
        default=None,
        help="Optional directory containing .pl rule snippets for extractor input.",
    )
    parser.add_argument(
        "--execution-engine",
        choices=["python", "dbt", "soda"],
        default="python",
        help="Check execution engine for parity target: python (LLM converted), dbt, or soda.",
    )
    parser.add_argument(
        "--profile",
        choices=list(SUPPORTED_PROFILES),
        default=DEFAULT_PROFILE,
        help="Rule-pack profile to execute: global, canada, or hybrid.",
    )
    parser.add_argument(
        "--soda-mode",
        choices=["local", "cloud"],
        default="local",
        help="Soda execution mode when --execution-engine soda: local or cloud.",
    )
    return parser.parse_args()


def main() -> None:
    args = parse_args()
    results = run_pipeline(
        dataset_size=args.size,
        seed=args.seed,
        source_jsonl=args.source_jsonl,
        llm_provider=args.llm_provider,
        llm_model=args.llm_model,
        perl_rules_dir=args.perl_rules_dir,
        execution_engine=args.execution_engine,
        soda_mode=args.soda_mode,
        profile=args.profile,
    )
    summary = results["migration_summary"]
    print(f"Rules analyzed: {summary['total_rules']}")
    print(f"Passed rules: {summary['passed_rules']}")
    print(f"Rules needing review: {summary['rules_needing_review']}")
    print(f"Dataset source: {results['dataset']['source_jsonl']}")
    print(f"Execution engine: {results['dataset'].get('execution_engine', 'python')}")
    if results["dataset"].get("execution_engine") == "soda":
        print(f"Soda mode: {results['dataset'].get('soda_mode', 'local')}")
    print(f"Profile: {results['dataset'].get('profile', DEFAULT_PROFILE)}")
    print(f"Run ID: {results.get('run_fingerprint', {}).get('run_id', 'n/a')}")
    print(
        "Fingerprints: "
        f"dataset={str(results.get('run_fingerprint', {}).get('dataset_fingerprint', {}).get('sha256', ''))[:16]} | "
        f"rulepack={str(results.get('run_fingerprint', {}).get('rulepack_fingerprint', {}).get('rule_ir_sha256', ''))[:16]}"
    )
    print(f"Results written to: {RESULT_PATH}")


if __name__ == "__main__":
    main()