"""A10: polarized canopy backscatter, mechanism sums and scattering orders."""
import json
import numpy as np
import less
from less.distributions import Fixed, DeWit
import validation_support as support

NAME = "radar-backscatter"
REF = support.reference("microwave_backscatter")
MECHANISMS = ("direct_crown", "gc", "cg", "gcg")


def soil_epsilon(c):
    texture = [1, c["sand_fraction"]*100, c["clay_fraction"]*100]
    values = [sum(np.dot(row, texture)*c["soil_moisture"]**i
        for i, row in enumerate(c["dielectric_coefficients"][key])) for key in ("real", "loss")]
    return complex(values[0], -values[1])


def reference(c):
    refs = {}
    for p in c["populations"]:
        local = REF.Inputs(p, c["frequency_Hz"], c["temperature_K"], soil_epsilon(c))
        for angle in c["view_angles"]:
            z = np.deg2rad(angle)
            incidence = np.array([0., np.sin(z), -np.cos(z)])
            terms = REF.first_order(local, incidence, c["thickness_m"])
            refs[p["name"]+"_"+str(angle)] = {k:v.tolist() for k,v in terms.items()}
    m = c["multiple"]
    pop = next(p for p in c["populations"] if p["name"]==m["population"])
    local = REF.Inputs(pop, c["frequency_Hz"], c["temperature_K"], soil_epsilon(c))
    z = np.deg2rad(m["angle"])
    incidence = np.array([0., np.sin(z), -np.cos(z)])
    levels = []
    for mu, phi, layers in m["reference_grids"]:
        orders = REF.solve_orders(local, incidence, thickness=c["thickness_m"], roughness=0.,
            n_mu=mu, n_phi=phi, n_layers=layers, max_order=m["depth"])
        levels.append(orders)
    scale = np.maximum(abs(orders), 1e-12)
    change = float(np.max(abs(levels[-1]-levels[-2])/scale))
    analytic = sum(np.array(v) for v in refs[m["population"]+"_"+str(m["angle"])].values())
    first_error = float(np.max(abs(orders[0]-analytic)/np.maximum(analytic, 1e-12)))
    print("reference grid change", change, "first-order agreement", first_error, flush=True)
    assert max(change, first_error) <= c["thresholds"]["reference_relative"]
    return refs, dict(orders_VH=orders.tolist(), grid_change_relative=change,
        first_order_relative_error=first_error, grids=m["reference_grids"])


def scene_for(c, p, backend):
    scene = less.Scene(backend=backend)
    scene.size, scene.repetitive, scene.measurement_plane = c["size_m"], True, 0.
    scene.terrain = less.Terrain(property=less.Lambertian(reflectance=.1))
    scene.terrain.set_property(less.MicrowaveSoil(surface_model="specular", rms_height_cm=0,
        soil_moisture=c["soil_moisture"], sand_fraction=c["sand_fraction"],
        clay_fraction=c["clay_fraction"], dielectric_model="hallikainen"))
    crown = less.Object("layer")
    crown.add_component("crown", less.TurbidBoundary(str(support.DATA/"microwave-brightness/layer.obj")))
    constructor = less.MicrowaveLeaf if p["shape"]=="leaf" else less.MicrowaveNeedle
    dimensions = {"thickness" if p["shape"]=="leaf" else "length":p["length_m"]}
    particle = constructor(radius=p["radius_m"], **dimensions, density=p["density_m3"],
        moisture=p["moisture"], dry_density=p["dry_density"], temperature=c["temperature_K"],
        orientation=DeWit("spherical") if p["orientation"]=="spherical" else Fixed(p["orientation"]),
        scattering_model="rayleigh")
    crown.set_property("crown", less.MicrowaveVegetation(components=[particle]))
    scene.add(crown, positions=[(0, 0, 0)])
    return scene


def execute(c, scene, angle, quality, seed, multiple=False):
    scene.sampler = less.Sampler("sobol", seed=seed)
    product = scene.simulate(less.RadarScatterometer(frequency=c["frequency_Hz"],
        geometry=less.Orthographic(image_size=c["image_size"], extent=c["footprint_m"],
            altitude=c["altitude_m"], view_zenith=angle, view_azimuth=0),
        quality=quality, scattering_order=None if multiple else 1,
        max_scatter_depth=c["multiple"]["depth"], scattering_samples=c["angular_samples"]))
    identity = support.execution(product, scene.backend, "active_microwave",
                                  "radar_multiple" if multiple else "radar")
    terms = {k:np.asarray(v.mueller, float) for k,v in product.mechanisms.items()}
    closure = float(np.max(abs(sum(terms.values())-product.mueller)))
    means = {k:v.mean(axis=(0, 1))[:2, :2].tolist() for k,v in terms.items()}
    return dict(seed=seed, sigma0_VH=np.asarray(product.mueller).mean(axis=(0, 1))[:2, :2].tolist(),
                mechanisms_VH=means, closure=closure, execution=identity)


def run(c, backends=support.BACKENDS):
    refs, orders = reference(c)
    records, sampling, multiple = [], [], []
    t = c["thresholds"]
    for backend in backends:
        for p in c["populations"]:
            scene = scene_for(c, p, backend)
            for angle in c["view_angles"]:
                name = p["name"]+"_"+str(angle)
                expected = np.array([refs[name][k] for k in MECHANISMS])
                exact = expected.sum(axis=0)
                levels = []
                for quality in c["quality_levels"]:
                    replicas = [execute(c, scene, angle, quality, seed) for seed in c["seeds"]]
                    terms = np.array([[r["mechanisms_VH"][k] for k in MECHANISMS] for r in replicas])
                    mean = np.mean([r["sigma0_VH"] for r in replicas], axis=0)
                    levels.append(dict(samples=quality, sigma0_VH=mean.tolist(),
                        rmse=float(np.sqrt(np.mean((mean-exact)**2)))))
                mechanism_error = abs(terms.mean(axis=0)-expected)
                std = np.std([r["sigma0_VH"] for r in replicas], axis=0, ddof=1)
                change = abs(np.array(levels[-2]["sigma0_VH"])-mean)
                passed = (np.all(abs(mean-exact) <= t["first_absolute"]+t["first_relative"]*exact)
                    and np.all(mechanism_error <= t["first_absolute"]+t["mechanism_relative"]*expected)
                    and np.all(std <= t["first_absolute"]+t["repeat_relative"]*exact)
                    and np.all(change <= t["first_absolute"]+t["last_change_relative"]*exact)
                    and max(r["closure"] for r in replicas) <= t["closure"])
                row = dict(backend=backend, case=name, sigma0_VH=mean.tolist(),
                    reference_VH=exact.tolist(), mechanism_error_max=float(mechanism_error.max()),
                    maximum_absolute_error=float(abs(mean-exact).max()),
                    relative_error_max=float(np.max(abs(mean-exact)/(exact+t["first_absolute"]))),
                    repeats=replicas, passed=bool(passed))
                records.append(row)
                sampling.append(dict(backend=backend, case=name, levels=levels))
                print(backend, name, bool(passed), row["relative_error_max"], flush=True)
            if p["name"] == c["multiple"]["population"]:
                numerical = np.array(orders["orders_VH"])
                target = np.stack([numerical[0], numerical[1], numerical[2:].sum(axis=0), numerical.sum(axis=0)])
                levels = []
                for quality in c["multiple"]["quality_levels"]:
                    replicas = [execute(c, scene, c["multiple"]["angle"], quality, seed, True)
                                for seed in c["seeds"]]
                    grouped = []
                    for r in replicas:
                        terms = r["mechanisms_VH"]
                        grouped.append([sum(np.array(terms[k]) for k in MECHANISMS),
                            terms["second_order"], terms["higher_order"], r["sigma0_VH"]])
                    grouped = np.asarray(grouped)
                    mean = grouped.mean(axis=0)
                    se = grouped.std(axis=0, ddof=1)/np.sqrt(len(replicas))
                    levels.append(dict(samples=quality, rmse=float(np.sqrt(np.mean((mean-target)**2))),
                        sigma0_VH=mean.tolist(), standard_error_VH=se.tolist()))
                    print(backend, "multiple", quality, levels[-1]["rmse"], flush=True)
                change = abs(mean-np.array(levels[-2]["sigma0_VH"]))
                bound = t["first_absolute"]+t["multiple_relative"]*target+t["multiple_standard_errors"]*se
                passed = bool(np.all(abs(mean-target)<=bound) and np.all(change<=2*bound)
                    and max(r["closure"] for r in replicas)<=t["closure"])
                multiple.append(dict(backend=backend, groups=["first", "second", "higher", "total"],
                    reference_VH=target.tolist(), sigma0_VH=mean.tolist(),
                    standard_error_VH=se.tolist(), repeats=replicas, levels=levels, passed=passed))
            del scene
    return dict(input=c, references=refs, numerical_reference=orders, records=records,
        sampling=sampling, multiple=multiple, passed=all(r["passed"] for r in records+multiple))


def figures(result, output):
    plt = support.plot_settings()
    fig, axes = plt.subplots(1, 3, figsize=(13, 4), layout="constrained")
    rows = [r for r in result["records"] if r["case"].startswith("isotropic")]
    angles = result["input"]["view_angles"]
    axes[0].plot(angles, [r["reference_VH"][0][0] for r in rows[:len(angles)]],
                 color="#374151", label="Reference VV")
    axes[0].plot(angles, [r["reference_VH"][1][1] for r in rows[:len(angles)]],
                 color="#374151", linestyle="--", label="Reference HH")
    for backend, color, marker in zip(support.BACKENDS, support.COLORS, support.MARKERS):
        selected = [r for r in rows if r["backend"]==backend]
        for i in (0, 1):
            axes[0].plot(angles, [r["sigma0_VH"][i][i] for r in selected], color=color,
                marker=marker, linestyle="none", markerfacecolor="none", label=backend if i==0 else None)
    axes[0].set(xlabel="Incidence angle / degrees", ylabel="Linear backscatter coefficient")
    axes[0].legend(frameon=False, fontsize=8)
    ref = np.array(result["multiple"][0]["reference_VH"])
    x = np.arange(4)
    axes[1].bar(x, ref[:, 0, 0], color="#d1d5db", label="Reference VV")
    for row, color, marker in zip(result["multiple"], support.COLORS, support.MARKERS):
        axes[1].plot(x, np.array(row["sigma0_VH"])[:, 0, 0], linestyle="none", color=color,
                     marker=marker, markerfacecolor="none", label=row["backend"])
    axes[1].set(xticks=x, xticklabels=["1", "2", "3–8", "Total"],
                xlabel="Vegetation scattering order", ylabel="Linear VV coefficient")
    axes[1].set_yscale("log")
    axes[1].legend(frameon=False, fontsize=8)
    support.convergence(axes[2], result["multiple"], ylabel="Scattering-order sigma0 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)
