"""A13: cosine-response irradiance, finite cones, tilt and square occlusion."""
import json
import math
import numpy as np
import less
import validation_support as support

NAME = "point-irradiance"
REF = support.reference("optical_validation")


def expected(c, case):
    tilt = math.radians(case["tilt"])
    half = math.radians(case["fov"])/2
    if case["mode"] == "sun":
        angle = abs(tilt-math.radians(case["sun_zenith"]))
        return math.cos(angle) if angle < half and not case.get("occluder", False) else 0.
    if case.get("occluder", False):
        return 1-REF.rectangle_view_factor(1., 1., 1.)
    if case["fov"] == 180:
        return (1+math.cos(tilt))/2+c["reflectance"]*(1-math.cos(tilt))/2
    assert tilt+half <= math.pi/2+1e-12
    return math.sin(half)**2


def scene_for(c, case, backend):
    scene = less.Scene(backend=backend)
    scene.size = c["size_m"]
    scene.repetitive = not case.get("occluder", False)
    scene.terrain = less.Terrain(property=less.Lambertian(reflectance=c["reflectance"]))
    if case["mode"] == "sky":
        atmosphere = less.PrescribedAtmosphere(direct_beam_transmittance=0,
                                               diffuse_horizontal_transmittance=1)
        source = less.Sun(zenith=0, irradiance=1)
    else:
        atmosphere = less.NoAtmosphere()
        source = less.Sun(zenith=case["sun_zenith"], azimuth=90, irradiance=1)
    scene.illumination = less.Illumination(source=source, atmosphere=atmosphere)
    if case.get("occluder", False):
        panel = less.Object("screen", mesh=str(support.DATA/NAME/"occluder.obj"))
        panel.set_property(less.Lambertian(reflectance=0.))
        scene.add(panel, positions=[(c["size_m"]/2, c["size_m"]/2, 3.)])
    return scene


def run(c, backends=support.BACKENDS):
    refs = {case["name"]: expected(c, case) for case in c["cases"]}
    records, sampling = [], []
    for backend in backends:
        for case in c["cases"]:
            scene = scene_for(c, case, backend)
            target = refs[case["name"]]
            levels = []
            for count in c["quality_levels"]:
                repeats = []
                for seed in c["seeds"]:
                    scene.sampler = less.Sampler("independent", seed=seed)
                    beta = math.radians(case["tilt"])
                    product = scene.simulate(less.IrradianceRadiometer(
                        position=(c["size_m"]/2, c["size_m"]/2, 2.),
                        normal=(math.sin(beta), 0., math.cos(beta)), fov=case["fov"],
                        bands=[550.], quality=count))
                    identity = support.execution(product, backend, "optical_backward", "optical_backward")
                    repeats.append(dict(seed=seed, irradiance=float(product.irradiance[0]),
                        standard_error=float(product.standard_error[0]), execution=identity))
                values = np.array([r["irradiance"] for r in repeats])
                levels.append(dict(samples=count, mean=float(values.mean()),
                    standard_deviation=float(values.std(ddof=1)),
                    rmse=float(np.sqrt(np.mean((values-target)**2))),
                    reported_standard_error=float(np.mean([r["standard_error"] for r in repeats]))))
            error = float(np.max(abs(values-target)))
            change = abs(levels[-1]["mean"]-levels[-2]["mean"])
            limit = c["thresholds"]["zero_absolute" if target == 0 else "irradiance_absolute"]
            row = dict(backend=backend, case=case["name"], reference=target,
                irradiance=levels[-1]["mean"], maximum_error=error, last_change=change,
                repeats=repeats, passed=bool(error <= limit
                    and change <= c["thresholds"]["last_change"]
                    and levels[-1]["standard_deviation"] <= c["thresholds"]["standard_deviation"]
                    and all(abs(r["irradiance"]-target) <= 5*r["standard_error"]+1e-5 for r in repeats)))
            records.append(row)
            sampling.append(dict(backend=backend, case=case["name"], levels=levels))
            print(backend, case["name"], row["passed"], row["irradiance"], target, error, flush=True)
            del scene
    return dict(input=c, references=refs, records=records, sampling=sampling,
                passed=all(r["passed"] for r in records))


def figures(result, output):
    plt = support.plot_settings()
    fig, axes = plt.subplots(1, 3, figsize=(13, 4), layout="constrained")
    names = [c["name"] for c in result["input"]["cases"]]
    x = np.arange(1, len(names)+1)
    axes[0].plot(x, [result["references"][n] for n in names], "-", color="#374151", label="Analytic")
    for backend, color, marker in zip(support.BACKENDS, support.COLORS, support.MARKERS):
        rows = [r for r in result["records"] if r["backend"]==backend]
        axes[0].plot(x, [r["irradiance"] for r in rows], linestyle="none", color=color,
                     marker=marker, markerfacecolor="none", label=backend)
        axes[1].semilogy(x, np.maximum([r["maximum_error"] for r in rows], 1e-8),
                        color=color, marker=marker, markerfacecolor="none", label=backend)
    axes[0].set(xlabel="Condition (table order)", ylabel="Irradiance / W m⁻² nm⁻¹")
    axes[0].legend(frameon=False, fontsize=8)
    axes[1].set(xlabel="Condition (table order)", ylabel="Maximum absolute error / W m⁻² nm⁻¹")
    support.convergence(axes[2], result["sampling"], ylabel="Irradiance RMSE / W m⁻² nm⁻¹")
    fig.savefig(output/"results.svg")
    plt.close(fig)


if __name__ == "__main__":
    args = support.arguments(NAME)
    result = (json.loads((args.output/"results.json").read_text()) if args.figures_only
        else run(support.inputs(NAME), [args.backend] if args.backend else support.BACKENDS))
    support.write_result(args.output, result)
    if args.backend is None:
        figures(result, args.output)
    raise SystemExit(0 if result["passed"] else 1)
