#!/usr/bin/env python3
"""Evaluate the eligible cross-output precision proxy leave one output out.

For each assessed output, its source picks are removed and the remaining picks
are reclustered with the released strict-span rule. Assessed picks and external
candidates are then assigned one-to-one within ``delta``. Eligibility is
queried at the assessed-pick time. An optional station-day circular time-shift
null is calculated for one declared output without changing its daily pick
count.
"""

from __future__ import annotations

import argparse
import csv
import json
import math
import sqlite3
import sys
import zlib
from collections import defaultdict
from pathlib import Path
from typing import Any, Iterable

import numba
import numpy as np
import orjson
import zstandard as zstd

ROOT = Path(__file__).resolve().parents[1]
if str(ROOT) not in sys.path:
    sys.path.insert(0, str(ROOT))

from scripts.build_all_model_phase_catalog import cluster_group


DAY_US = 86_400_000_000
PERIODS = {
    "2019": (1_561_939_200_000_000, 1_562_544_000_000_000),
    "2021": (1_636_329_600_000_000, 1_636_934_400_000_000),
}


@numba.njit(cache=True)
def assign_sorted_one_to_one(
    assessed: np.ndarray,
    candidates: np.ndarray,
    tolerance_us: int,
) -> np.ndarray:
    """Return candidate indices using deterministic earliest-feasible matching."""
    assigned = np.full(len(assessed), -1, dtype=np.int64)
    i = 0
    j = 0
    while i < len(assessed) and j < len(candidates):
        if candidates[j] < assessed[i] - tolerance_us:
            j += 1
        elif assessed[i] < candidates[j] - tolerance_us:
            i += 1
        else:
            assigned[i] = j
            i += 1
            j += 1
    return assigned


def period_for_time(time_us: int) -> str | None:
    for period, (left, right) in PERIODS.items():
        if left <= time_us < right:
            return period
    return None


def load_eligibility(
    path: Path,
) -> tuple[dict[tuple[str, str, int], tuple[np.ndarray, np.ndarray]], dict[int, str]]:
    con = sqlite3.connect(path)
    names = {
        int(output_id): str(output_name)
        for output_id, output_name in con.execute(
            "SELECT output_id, output_name FROM outputs ORDER BY output_id"
        )
    }
    grouped: dict[tuple[str, str, int], list[tuple[int, int]]] = defaultdict(list)
    for station, output_id, left, right, phase_mask in con.execute(
        """
        SELECT station_id, output_id, processed_start_us, processed_end_us,
               phase_mask
        FROM eligibility_intervals
        WHERE valid_input=1
        ORDER BY station_id, output_id, processed_start_us, processed_end_us
        """
    ):
        if int(phase_mask) & 1:
            grouped[(str(station), "P", int(output_id))].append((int(left), int(right)))
        if int(phase_mask) & 2:
            grouped[(str(station), "S", int(output_id))].append((int(left), int(right)))
    con.close()
    result = {
        key: (
            np.asarray([left for left, _ in values], dtype=np.int64),
            np.asarray([right for _, right in values], dtype=np.int64),
        )
        for key, values in grouped.items()
    }
    return result, names


def eligibility_count(
    times: np.ndarray,
    station: str,
    phase: str,
    excluded_output: int,
    intervals: dict[tuple[str, str, int], tuple[np.ndarray, np.ndarray]],
    output_count: int,
) -> np.ndarray:
    counts = np.zeros(len(times), dtype=np.uint8)
    for output_id in range(output_count):
        if output_id == excluded_output:
            continue
        item = intervals.get((station, phase, output_id))
        if item is None:
            continue
        starts, ends = item
        indices = np.searchsorted(starts, times, side="right") - 1
        valid = indices >= 0
        safe = np.maximum(indices, 0)
        valid &= ends[safe] >= times
        counts += valid.astype(np.uint8)
    return counts


def shifted_station_day_times(
    times: np.ndarray,
    station: str,
    replicate: int,
) -> np.ndarray:
    shifted = np.empty_like(times)
    days = times // DAY_US
    for day in np.unique(days):
        mask = days == day
        seed = zlib.crc32(f"{station}:{int(day)}:{replicate}".encode("utf-8"))
        offset_s = 60 + seed % 541
        day_start = int(day) * DAY_US
        shifted[mask] = day_start + (
            (times[mask] - day_start + offset_s * 1_000_000) % DAY_US
        )
    shifted.sort()
    return shifted


def iter_station_phase_groups(path: Path) -> Iterable[tuple[str, str, np.ndarray, np.ndarray]]:
    current_key: tuple[str, str] | None = None
    times: list[int] = []
    models: list[int] = []
    with path.open("rb") as raw:
        with zstd.ZstdDecompressor().stream_reader(raw) as reader:
            buffer = b""
            while True:
                chunk = reader.read(8 * 1024 * 1024)
                if not chunk:
                    break
                buffer += chunk
                lines = buffer.split(b"\n")
                buffer = lines.pop()
                for line in lines:
                    if not line:
                        continue
                    record = orjson.loads(line)
                    key = (str(record["s"]), str(record["p"]))
                    if current_key is not None and key != current_key:
                        if len(times) > 1 and any(a > b for a, b in zip(times, times[1:])):
                            order = np.argsort(np.asarray(times), kind="stable")
                            times = [times[index] for index in order]
                            models = [models[index] for index in order]
                        yield (
                            current_key[0], current_key[1],
                            np.asarray(times, dtype=np.int64),
                            np.asarray(models, dtype=np.uint8),
                        )
                        times = []
                        models = []
                    current_key = key
                    base = int(record["t"])
                    for member in record["x"]:
                        models.append(int(member[0]))
                        times.append(base + int(member[2]))
            if buffer.strip():
                record = orjson.loads(buffer)
                key = (str(record["s"]), str(record["p"]))
                if current_key is not None and key != current_key:
                    if len(times) > 1 and any(a > b for a, b in zip(times, times[1:])):
                        order = np.argsort(np.asarray(times), kind="stable")
                        times = [times[index] for index in order]
                        models = [models[index] for index in order]
                    yield (
                        current_key[0], current_key[1],
                        np.asarray(times, dtype=np.int64),
                        np.asarray(models, dtype=np.uint8),
                    )
                    times = []
                    models = []
                current_key = key
                base = int(record["t"])
                for member in record["x"]:
                    models.append(int(member[0]))
                    times.append(base + int(member[2]))
    if current_key is not None:
        if len(times) > 1 and any(a > b for a, b in zip(times, times[1:])):
            order = np.argsort(np.asarray(times), kind="stable")
            times = [times[index] for index in order]
            models = [models[index] for index in order]
        yield (
            current_key[0], current_key[1],
            np.asarray(times, dtype=np.int64),
            np.asarray(models, dtype=np.uint8),
        )


def accumulate(
    counters: dict[tuple[Any, ...], list[int]],
    key_prefix: tuple[Any, ...],
    assessed: np.ndarray,
    external_times: np.ndarray,
    external_support: np.ndarray,
    eligible_m: np.ndarray,
    delta_us: int,
    q0: float,
    m0: int,
) -> None:
    assignments = assign_sorted_one_to_one(assessed, external_times, delta_us)
    for period in PERIODS:
        left, right = PERIODS[period]
        mask = (assessed >= left) & (assessed < right)
        if not np.any(mask):
            continue
        m = eligible_m[mask]
        assigned = assignments[mask]
        denominator = m >= m0
        matched = assigned >= 0
        k = np.zeros(len(assigned), dtype=np.uint8)
        k[matched] = external_support[assigned[matched]]
        corroborated = denominator & matched & (k / np.maximum(m, 1) >= q0)
        values = counters.setdefault((*key_prefix, period), [0, 0, 0])
        values[0] += int(mask.sum())
        values[1] += int(denominator.sum())
        values[2] += int(corroborated.sum())


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument(
        "--candidates", type=Path,
        default=ROOT / "data/label/all_model_phase_picks.jsonl.zst",
    )
    parser.add_argument(
        "--eligibility", type=Path,
        default=ROOT / "data/label/output_eligibility.sqlite",
    )
    parser.add_argument(
        "--output-tsv", type=Path,
        default=ROOT / "data/validation/leave_one_output_precision_proxy.tsv",
    )
    parser.add_argument(
        "--output-json", type=Path,
        default=ROOT / "data/validation/leave_one_output_precision_proxy.json",
    )
    parser.add_argument("--cluster-span-s", type=float, default=1.5)
    parser.add_argument("--delta-s", type=float, default=0.5)
    parser.add_argument("--q0", type=float, default=0.5)
    parser.add_argument("--m0", type=int, default=6)
    parser.add_argument("--null-output", default="seismicxm.01")
    parser.add_argument("--null-replicates", type=int, default=20)
    args = parser.parse_args()

    intervals, output_names = load_eligibility(args.eligibility)
    name_to_id = {name: output_id for output_id, name in output_names.items()}
    if args.null_output not in name_to_id:
        raise KeyError(f"null output is absent from registry: {args.null_output}")
    null_output = name_to_id[args.null_output]
    model_count = len(output_names)
    cluster_us = int(round(args.cluster_span_s * 1_000_000))
    delta_us = int(round(args.delta_s * 1_000_000))
    observed: dict[tuple[Any, ...], list[int]] = {}
    null: dict[tuple[Any, ...], list[int]] = {}
    source_pick_count = 0

    for group_index, (station, phase, times, models) in enumerate(
        iter_station_phase_groups(args.candidates), 1
    ):
        source_pick_count += len(times)
        for assessed_output in range(model_count):
            assessed_mask = models == assessed_output
            if not np.any(assessed_mask):
                continue
            assessed = times[assessed_mask]
            external_times_raw = times[~assessed_mask]
            external_models = models[~assessed_mask]
            _, _, candidate_times, _, candidate_support, _ = cluster_group(
                external_times_raw, external_models, cluster_us, model_count
            )
            eligible_m = eligibility_count(
                assessed, station, phase, assessed_output, intervals, model_count
            )
            accumulate(
                observed, (assessed_output, phase), assessed, candidate_times,
                candidate_support, eligible_m, delta_us, args.q0, args.m0,
            )
            if assessed_output == null_output:
                for replicate in range(args.null_replicates):
                    shifted = shifted_station_day_times(assessed, station, replicate)
                    shifted_m = eligibility_count(
                        shifted, station, phase, assessed_output, intervals, model_count
                    )
                    accumulate(
                        null, (replicate, phase), shifted, candidate_times,
                        candidate_support, shifted_m, delta_us, args.q0, args.m0,
                    )
        if group_index % 100 == 0:
            print(
                f"[LOO] groups={group_index:,} source_picks={source_pick_count:,}",
                flush=True,
            )

    rows = []
    for (output_id, phase, period), (reported, eligible, corroborated) in sorted(observed.items()):
        rows.append(
            {
                "output_id": output_id,
                "output_name": output_names[output_id],
                "period": period,
                "phase": phase,
                "reported_pick_count": reported,
                "eligible_denominator": eligible,
                "corroborated_count": corroborated,
                "cross_output_precision_proxy": (
                    corroborated / eligible if eligible else None
                ),
            }
        )
    null_rows = []
    for phase in ("P", "S"):
        for period in PERIODS:
            fractions = []
            denominators = []
            for replicate in range(args.null_replicates):
                _, eligible, corroborated = null.get((replicate, phase, period), [0, 0, 0])
                if eligible:
                    fractions.append(corroborated / eligible)
                    denominators.append(eligible)
            null_rows.append(
                {
                    "output_id": null_output,
                    "output_name": output_names[null_output],
                    "period": period,
                    "phase": phase,
                    "replicates": len(fractions),
                    "mean_eligible_denominator": float(np.mean(denominators)) if denominators else None,
                    "mean_null_fraction": float(np.mean(fractions)) if fractions else None,
                    "null_fraction_p05": float(np.quantile(fractions, 0.05)) if fractions else None,
                    "null_fraction_p95": float(np.quantile(fractions, 0.95)) if fractions else None,
                }
            )

    payload = {
        "schema": "seismicx-cont-leave-one-output-precision-proxy-v1",
        "candidate_file": args.candidates.relative_to(ROOT).as_posix(),
        "eligibility_file": args.eligibility.relative_to(ROOT).as_posix(),
        "source_pick_count": source_pick_count,
        "parameters": {
            "cluster_strict_span_s": args.cluster_span_s,
            "assignment_tolerance_delta_s": args.delta_s,
            "normalized_support_threshold_q0": args.q0,
            "minimum_external_eligibility_m0": args.m0,
            "assignment": "deterministic earliest-feasible one-to-one assignment on sorted times",
            "eligibility_query_time": "assessed-pick time",
        },
        "rows": rows,
        "station_day_time_shift_null": {
            "output": args.null_output,
            "replicates": args.null_replicates,
            "offset_s": "deterministic uniform integer in [60, 600] per station-day-replicate",
            "daily_pick_count_preserved": True,
            "rows": null_rows,
        },
    }
    args.output_json.parent.mkdir(parents=True, exist_ok=True)
    args.output_json.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n")
    with args.output_tsv.open("w", newline="") as stream:
        writer = csv.DictWriter(stream, fieldnames=list(rows[0]), delimiter="\t")
        writer.writeheader()
        writer.writerows(rows)
    print(json.dumps({"rows": len(rows), "source_pick_count": source_pick_count}, indent=2))


if __name__ == "__main__":
    main()