"""Fit driver-space parameters by group and record per-group runtime summaries."""
import json
from pathlib import Path
import numpy as np
import pandas as pd
from _common import numeric, output_path, parser, read_csv, require, save_csv, preflight_outputs
from driver_space_model import drspace
from annotate_interactions import validate_parameters


def fit_groups(df, output, audit_path, width=2., length=5., percentile=0.5, minimum_samples=50000,
               maximum_samples=50000, max_iter=50, workers=1, seed=42):
    preflight_outputs(output, audit_path)
    df = df.copy()
    require(df, ["cangle", "round_v", "x_local", "y_local", "v_rel"])
    numeric(df, ["cangle"], integer=True)
    numeric(df, ["round_v", "x_local", "y_local", "v_rel"])
    if not df.cangle.isin([0, 1]).all() or df.v_rel.le(0).any():
        raise ValueError("Require binary cangle and positive relative speed")
    if (not np.isfinite([width, length, percentile]).all() or min(width, length) <= 0 or not 0 <= percentile <= 100
            or minimum_samples < 1 or maximum_samples < minimum_samples or workers < 1 or max_iter < 0):
        raise ValueError("Invalid inference settings")
    if Path(output).resolve() == Path(audit_path).resolve() or Path(audit_path).exists():
        raise FileExistsError("Choose distinct new parameter and audit files")
    if Path(output).exists():
        raise FileExistsError(output)
    records, results = [], []
    for (category, speed), group in df.groupby(["cangle", "round_v"], sort=True):
        record = {"cangle": int(category), "round_v": float(speed), "available_samples": len(group),
                  "sample_group_ids": sorted(group.Sample_Group_ID.astype(str).unique().tolist()) if "Sample_Group_ID" in group else None}
        if len(group) < minimum_samples:
            record.update(status="insufficient_samples", used_samples=0)
            records.append(record)
            continue
        samples = group[["x_local", "y_local", "v_rel"]].rename(columns={"x_local": "x", "y_local": "y", "v_rel": "v"})
        if len(samples) > maximum_samples:
            samples = samples.sample(n=maximum_samples, random_state=seed)
        model = drspace(samples, width=width, length=length, percentile=percentile)
        limits, parameters, standard_errors, p_values = model.Inference(max_iter=max_iter, workers=workers)
        status = getattr(model, "inference_status", "unknown")
        optimizer_failures = getattr(model, "optimizer_failures", [])
        accepted = (status in ["converged_rounded_parameters", "cycle_resolved_by_legacy_p_values"]
                    and not optimizer_failures and np.isfinite(parameters).all() and np.all(parameters > 0))
        record.update(status=status, accepted=bool(accepted), used_samples=len(samples),
                      iterations=int(getattr(model, "completed_iterations", 0)),
                      error=getattr(model, "inference_error", None), optimizer_failures=optimizer_failures,
                      bounds=np.asarray(limits).tolist(), parameters=np.asarray(parameters).tolist())
        # The parameter CSV contains fitted values, sample sizes and fit status.
        if accepted:
            results.append({"cangle": int(category), "round_v": float(speed)})
            results[-1].update(dict(zip(["rx_plus", "rx_minus", "ry_plus", "ry_minus", "bx_plus", "bx_minus", "by_plus", "by_minus"], parameters)))
            results[-1].update(sample_size=len(samples), Fit_Status=status, Fit_Method="author_legacy_hybrid")
        records.append(record)
    complete = bool(records) and len(results) == len(records)
    audit = {"complete": complete, "method": "Alternating curvature-grid scale updates and constrained conditional maximum-likelihood shape updates",
             "width_m": width, "length_m": length, "initial_percentile": percentile,
             "minimum_samples": minimum_samples, "maximum_samples": maximum_samples, "max_iter": max_iter, "workers": workers,
             "downsample_seed": seed, "groups": records,
             "uncertainty_note": "Approximate inverse-Hessian p-values are used to select among recurring parameter vectors; the parameter CSV reports fitted values, sample size and fit status."}
    # Serialize nonfinite runtime-summary values as JSON null.
    def clean(value):
        if isinstance(value, dict): return {k: clean(v) for k, v in value.items()}
        if isinstance(value, list): return [clean(v) for v in value]
        return None if isinstance(value, float) and not np.isfinite(value) else value
    with output_path(audit_path) as temporary:
        Path(temporary).write_text(json.dumps(clean(audit), indent=2, allow_nan=False), encoding="utf-8")
    if not complete:
        raise ValueError("One or more inference groups failed or were undersized; audit saved; no parameter CSV published")
    result = pd.DataFrame(results)
    validate_parameters(result)
    save_csv(result, output)
    return result


def main():
    p = parser(__doc__)
    p.add_argument("--input", required=True, help="Balanced fitting CSV generated by balance_pair_samples.py")
    p.add_argument("--output", required=True, help="New complete parameter CSV, compatible with annotate_interactions.py")
    p.add_argument("--audit", required=True, help="New JSON with per-group status and sample counts")
    p.add_argument("--width-m", type=float, default=2., help="Driver-space model width setting in meters")
    p.add_argument("--length-m", type=float, default=5., help="Driver-space model length setting in meters")
    p.add_argument("--initial-percentile", type=float, default=0.5, help="Initial np.percentile value: 0.5 selects the 0.5th percentile")
    p.add_argument("--minimum-samples", type=int, default=50000)
    p.add_argument("--maximum-samples", type=int, default=50000)
    p.add_argument("--max-iter", type=int, default=50)
    p.add_argument("--workers", type=int, default=1, help="Number of inference workers; default is 1")
    p.add_argument("--seed", type=int, default=42)
    a = p.parse_args()
    fit_groups(read_csv(a.input), a.output, a.audit, a.width_m, a.length_m, a.initial_percentile,
               a.minimum_samples, a.maximum_samples, a.max_iter, a.workers, a.seed)


if __name__ == "__main__":
    main()