"""A11: visible sunlit/shaded component fractions against exact geometry."""
import json
import numpy as np
import less
import validation_support as support

NAME = "four-component"
REF = support.reference("optical_validation")


def scene_for(c, case, backend):
    scene = less.Scene(backend=backend)
    scene.size, scene.measurement_plane = c["size_m"], 0.
    scene.repetitive = case.get("periodic", False)
    scene.terrain = less.Terrain(property=less.Lambertian(reflectance=.2))
    scene.illumination = less.Illumination(source=less.Sun(zenith=case["sun_zenith"],
        azimuth=90 if case.get("sun_sign", 1)>0 else 270), atmosphere=less.NoAtmosphere())
    for name in ("upper", "lower"):
        leaf = less.Object(name, mesh=str(support.DATA/NAME/(name+".obj")))
        leaf.set_property(less.Lambertian(reflectance=.3))
        scene.add(leaf, positions=[(0, 0, 0)])
    return scene


def run(c, backends=support.BACKENDS):
    refs = {case["name"]: REF.component_image(c, case) for case in c["cases"]}
    records, sampling = [], []
    area = (c["size_m"]/c["image_size"])**2
    for backend in backends:
        for case in c["cases"]:
            scene = scene_for(c, case, backend)
            exact = refs[case["name"]]
            target_area = exact.sum(axis=(0, 1))*area
            levels = []
            for count in c["quality_levels"]:
                images, repeats, label_errors = [], [], []
                for seed in c["seeds"]:
                    scene.sampler = less.Sampler("sobol", seed=seed)
                    product = scene.simulate(less.FourComponentImager(less.Orthographic(
                        image_size=c["image_size"], extent=c["size_m"], altitude=10.,
                        view_zenith=case["view_zenith"],
                        view_azimuth=90 if case.get("view_sign", 1)>0 else 270), num_samples=count))
                    identity = support.execution(product, backend, "four_component_classification", "four_component")
                    image = np.asarray(product.fractions, float)
                    images.append(image)
                    ordered = np.sort(exact, axis=-1)
                    stable = ordered[..., -1]-ordered[..., -2] > .05
                    errors = int(np.sum(stable & (product.labels != np.argmax(exact, axis=-1)+1)))
                    label_errors.append(errors)
                    repeats.append(dict(seed=seed, areas_m2=(image.sum(axis=(0, 1))*area).tolist(),
                        closure=float(np.max(abs(image.sum(axis=-1)-1))), execution=identity))
                average = np.mean(images, axis=0)
                level = dict(samples=count, rmse=float(np.sqrt(np.mean((average-exact)**2))),
                    areas_m2=(average.sum(axis=(0, 1))*area).tolist(),
                    area_error_m2=float(np.max(abs(average.sum(axis=(0, 1))*area-target_area))))
                levels.append(level)
            error = dict(area_m2=level["area_error_m2"], fraction_rmse=level["rmse"],
                fraction_max=float(np.max(abs(average-exact))),
                closure=max(r["closure"] for r in repeats), label_errors=max(label_errors),
                last_area_change_m2=float(np.max(abs(np.array(levels[-1]["areas_m2"])-levels[-2]["areas_m2"]))))
            row = dict(backend=backend, case=case["name"], fractions=average.tolist(),
                areas_m2=level["areas_m2"], repeats=repeats, errors=error,
                passed=all(value <= c["thresholds"][key] for key, value in error.items()))
            records.append(row)
            sampling.append(dict(backend=backend, case=case["name"], levels=levels))
            print(backend, case["name"], row["passed"], error, flush=True)
            del scene
    return dict(input=c, references={k: v.tolist() for k, v in refs.items()}, records=records,
                sampling=sampling, passed=all(r["passed"] for r in records))


def figures(result, output):
    plt = support.plot_settings()
    fig, axes = plt.subplots(2, 3, figsize=(12, 7), layout="constrained")
    name = "nadir_sun45"
    exact = np.array(result["references"][name])
    panels = [exact]+[np.array(next(r for r in result["records"] if r["case"]==name
        and r["backend"]==b)["fractions"]) for b in support.BACKENDS]
    from matplotlib.colors import ListedColormap
    colors = ListedColormap(["#bd8b52", "#83b759", "#5b4538", "#25533f"])
    for ax, image, title in zip(axes.flat, panels, ("Geometry reference",)+support.BACKENDS):
        ax.imshow(np.argmax(image, axis=-1), cmap=colors, vmin=0, vmax=3,
                  extent=[0, 6, 6, 0], interpolation="nearest")
        ax.set(title=title, xlabel="East / m", ylabel="South / m")
    x = np.arange(1, len(result["input"]["cases"])+1)
    for p, label in enumerate(("Sunlit soil", "Sunlit leaf", "Shaded soil", "Shaded leaf")):
        axes[1, 1].plot(x, [np.sum(result["references"][c["name"]], axis=(0, 1))[p]*
            (6/result["input"]["image_size"])**2 for c in result["input"]["cases"]], "o-",
            color=colors.colors[p], label=label)
    axes[1, 1].set(title="Reference areas", xlabel="Condition (table order)", xticks=x,
                    ylabel="Visible projected area / m²")
    axes[1, 1].legend(frameon=False, fontsize=8)
    support.convergence(axes[1, 2], result["sampling"], ylabel="Fraction 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)
