"""A12: RPV and wind-roughened water against independent angular formulas."""
import json
import numpy as np
import less
import validation_support as support

NAME = "directional-surfaces"
REF = support.reference("optical_validation")


def scene_for(c, backend, model, parameters):
    scene = less.Scene(backend=backend)
    scene.size, scene.repetitive = c["size_m"], True
    if model == "rpv":
        surface = less.RPV(**parameters)
    else:
        surface = less.WaterSurface(roughness=less.CoxMunk(
            wind_speed=parameters["wind_speed"], wind_azimuth=parameters["wind_azimuth"]),
            refractive_index=parameters["index"])
    scene.terrain = less.Terrain(property=surface)
    zenith = c["sun_zenith"] if model == "rpv" else c["water_sun_zenith"]
    scene.illumination = less.Illumination(source=less.Sun(zenith=zenith,
        azimuth=c["sun_azimuth"], irradiance=1), atmosphere=less.NoAtmosphere())
    return scene, zenith


def run(c, backends=support.BACKENDS):
    records, sampling, forward_checks, reciprocity = [], [], [], []
    for backend in backends:
        for model in ("rpv", "water"):
            parameters = c["rpv_parameters" if model == "rpv" else "water_parameters"]
            views = c["views" if model == "rpv" else "water_views"]
            for index, settings in enumerate(parameters):
                scene, sun = scene_for(c, backend, model, settings)
                wi = REF.direction(sun, c["sun_azimuth"])
                targets = [REF.rpv(wi, REF.direction(*v), **settings) if model == "rpv" else
                    np.pi*REF.water(wi, REF.direction(*v), **settings) for v in views]
                values = []
                for view, target in zip(views, targets):
                    levels = []
                    for quality in c["quality_levels"]:
                        replicas = []
                        for seed in c["seeds"]:
                            scene.sampler = less.Sampler("sobol", seed=seed)
                            image = scene.simulate(less.OpticalImager(less.Orthographic(
                                image_size=2, view_zenith=view[0], view_azimuth=view[1]),
                                bands=[550.], quality=quality))
                            identity = support.execution(image, backend, "optical_backward", "optical_backward")
                            replicas.append(dict(seed=seed, brf=float(image.to_brf().data.mean()), execution=identity))
                        mean = float(np.mean([r["brf"] for r in replicas]))
                        levels.append(dict(samples=quality, brf=mean, rmse=abs(mean-target)))
                    error = abs(mean-target)
                    bound = c["thresholds"]["brf_absolute"]+c["thresholds"]["brf_relative"]*abs(target)
                    row = dict(backend=backend, model=model, parameter_index=index,
                        view=view, reference=target, brf=mean, absolute_error=error, repeats=replicas,
                        budget_change=abs(levels[-1]["brf"]-levels[-2]["brf"]),
                        passed=bool(error <= bound and abs(levels[-1]["brf"]-levels[-2]["brf"]) <=
                            c["thresholds"]["last_change"]+c["thresholds"]["brf_relative"]*abs(target)))
                    records.append(row)
                    sampling.append(dict(backend=backend, model=model, parameter_index=index,
                                         view=view, levels=levels))
                    values.append(mean)
                scene.sampler = less.Sampler("sobol", seed=c["seeds"][0])
                forward = scene.simulate(less.BRFSensor(bands=[550.],
                    directions=[tuple(v) for v in views], num_photons=c["forward_photons"]))
                identity = support.execution(forward, backend, "optical_brf", "optical_brf")
                difference = np.asarray(forward.brf[:, 0], float)-targets
                forward_checks.append(dict(backend=backend, model=model, parameter_index=index,
                    num_photons=c["forward_photons"], brf=np.asarray(forward.brf[:, 0], float).tolist(),
                    maximum_error=float(np.max(abs(difference))), execution=identity,
                    passed=bool(np.max(abs(difference)) <= c["thresholds"]["forward_brf_max"] and np.sqrt(np.mean(difference**2)) <= c["thresholds"]["forward_brf_rmse"])))
                reverse = []
                for view, target in zip(views, targets):
                    scene.illumination = less.Illumination(source=less.Sun(zenith=view[0],
                        azimuth=view[1], irradiance=1), atmosphere=less.NoAtmosphere())
                    product = scene.simulate(less.OpticalImager(less.Orthographic(image_size=2,
                        view_zenith=sun, view_azimuth=c["sun_azimuth"]), bands=[550.], quality=1))
                    support.execution(product, backend, "optical_backward", "optical_backward")
                    reverse.append(float(product.to_brf().data.mean()))
                delta = float(np.max(abs(np.asarray(reverse)-values)))
                reciprocity.append(dict(backend=backend, model=model, parameter_index=index,
                    reversed_brf=reverse, maximum_difference=delta,
                    passed=delta <= c["thresholds"]["reciprocity"]))
                print(backend, model, index, "maximum BRF error",
                      float(np.max(abs(np.array(values)-targets))), flush=True)
                del scene
    return dict(input=c, records=records, sampling=sampling,
                forward_checks=forward_checks, reciprocity=reciprocity,
                passed=all(r["passed"] for r in records+forward_checks+reciprocity))


def figures(result, output):
    plt = support.plot_settings()
    fig, axes = plt.subplots(1, 3, figsize=(13, 4), layout="constrained")
    for ax, model, index, title in ((axes[0], "rpv", 1, "RPV angular response"),
            (axes[1], "water", 1, "Water sun glint")):
        rows = [r for r in result["records"] if r["model"]==model and r["parameter_index"]==index
                and r["backend"]==support.BACKENDS[0]]
        x = np.arange(len(rows))
        ax.plot(x, [r["reference"] for r in rows], "-", color="#374151", label="Reference")
        for backend, color, marker in zip(support.BACKENDS, support.COLORS, support.MARKERS):
            selected = [r for r in result["records"] if r["model"]==model
                        and r["parameter_index"]==index and r["backend"]==backend]
            ax.plot(x, [r["brf"] for r in selected], linestyle="none", color=color,
                    marker=marker, markerfacecolor="none", label=backend)
        ax.set(title=title, xlabel="View zenith / azimuth (degrees)", ylabel="BRF",
               xticks=x, xticklabels=[f'{r["view"][0]}/{r["view"][1]}' for r in rows])
        ax.tick_params(axis="x", labelrotation=45, labelsize=8)
        ax.legend(frameon=False, fontsize=8)
    support.convergence(axes[2], result["sampling"], ylabel="BRF RMSE")
    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)
