"""Independent dipole radar slab: closed first order and Cartesian coherency orders.

NumPy/SciPy only. Particle dielectric and orientation moments are calculated from
the independent layered reference, never from LESS tables. The active beam keeps
its full azimuth dependence and complex Cartesian coherency at every order.
"""
from pathlib import Path
import importlib.util
import numpy as np

_path = Path(__file__).with_name("microwave_layered_reference.py")
if not _path.exists():
    _path = Path(__file__).with_name("microwave_layered.py")
_spec = importlib.util.spec_from_file_location("radar_particle_reference", _path)
_particles = importlib.util.module_from_spec(_spec)
_spec.loader.exec_module(_particles)


def basis(d):
    return _particles.basis(d[..., 2], np.arctan2(d[..., 1], d[..., 0]))


def reflection(d, eps, k=0., roughness=0.):
    mu = abs(d[..., 2])
    root = np.sqrt(eps-(1-mu*mu)+0j)
    rv, rh = (eps*mu-root)/(eps*mu+root), (mu-root)/(mu+root)
    amplitude = np.exp(-.5*(2*k*roughness*mu)**2)
    b_in, b_out = basis(d), basis(d*np.array([1., 1., -1.]))
    return np.einsum("...pa,...p,...pb->...ab", b_out,
                     np.stack([rv, rh], axis=-1)*amplitude[..., None], b_in)


class Inputs:
    def __init__(self, population, frequency, temperature, soil_eps):
        self.population = _particles.Population(population, frequency, temperature)
        self.eps_soil, self.k = soil_eps, self.population.k
        self.density = self.population.density
        a = self.k**2/(4*np.pi)*self.population.alpha[0]
        b = self.k**2/(4*np.pi)*np.diff(self.population.alpha)[0]
        self.angular = abs(a)**2+2*(a*b.conjugate()).real/3+2*abs(b)**2/15
        self.constant = abs(b)**2/15
        absorption, scattering = self.population.rates(1.)
        self.absorption, self.scattering = float(absorption[0]), float(scattering[0])

    def phase(self, outgoing, incoming):
        out, inc = basis(outgoing), basis(incoming)
        axes, weights = self.population.axes, self.population.weights
        a, delta = self.population.alpha[0], np.diff(self.population.alpha)[0]
        amplitudes = a*(out@inc.T)[..., None]+delta*np.einsum(
            "pn,qn->pqn", out@axes.T, inc@axes.T)
        return self.density*self.k**4/(4*np.pi)**2*np.einsum(
            "pqn,n->pq", abs(amplitudes)**2, weights)


def integral(rate, length):
    rate = np.asarray(rate)
    small = abs(rate*length)<1e-8
    return np.where(small, length*(1+.5*rate*length),
                    np.expm1(rate*length)/np.where(small, 1., rate))


def first_order(inputs, incidence, thickness=2.):
    mu = abs(incidence[2])
    view = -incidence
    up, down = incidence*np.array([1., 1., -1.]), view*np.array([1., 1., -1.])
    a, s = inputs.population.rates(mu)
    extinction = a+s
    receive, transmit = extinction[:, None], extinction[None, :]
    length = thickness/mu
    eps = inputs.eps_soil
    root = np.sqrt(eps-(1-mu*mu))
    power = abs(np.array([(eps*mu-root)/(eps*mu+root), (mu-root)/(mu+root)]))**2
    rp, rq = power[:, None], power[None, :]
    terms = dict(
        direct_crown=inputs.phase(view, incidence)*integral(-(receive+transmit), length),
        gc=inputs.phase(view, up)*rq*np.exp(-2*transmit*length)*integral(transmit-receive, length),
        cg=rp*inputs.phase(down, incidence)*np.exp(-2*receive*length)*integral(receive-transmit, length),
        gcg=rp*rq*inputs.phase(down, up)*np.exp(-2*(receive+transmit)*length)
            *integral(receive+transmit, length))
    return {name: 4*np.pi*mu*value for name,value in terms.items()}


def _e0e1(tau):
    small = tau<1e-4
    safe = np.where(small, 1., tau)
    e0 = np.where(small, 1-tau/2+tau*tau/6, -np.expm1(-safe)/safe)
    e1 = np.where(small, .5-tau/3+tau*tau/8, (1-e0)/safe)
    return e0,e1


def sandwich(operator, field):
    return operator@field@operator.conj().swapaxes(-1, -2)


def solve_orders(inputs, incidence, *, thickness=4., roughness=.008,
                 n_mu=16, n_phi=8, n_layers=300, max_order=8):
    if inputs.population.settings["orientation"] != "spherical":
        raise ValueError("Cartesian moment solver requires isotropic axes")
    kappa = inputs.absorption+inputs.scattering
    mu_view = abs(incidence[2])
    z = np.linspace(0., thickness, n_layers+1)
    mg, mw = np.polynomial.legendre.leggauss(n_mu)
    mu = np.repeat((mg+1)/2, n_phi)
    phi = np.tile((np.arange(n_phi)+.5)*2*np.pi/n_phi, n_mu)
    weights = np.repeat(mw/2, n_phi)*2*np.pi/n_phi
    up = np.stack([np.sqrt(1-mu*mu)*np.cos(phi),
                   np.sqrt(1-mu*mu)*np.sin(phi), mu], axis=-1)
    down = up*np.array([1., 1., -1.])
    project_up = np.eye(3)-np.einsum("di,dj->dij", up, up)
    project_down = np.eye(3)-np.einsum("di,dj->dij", down, down)
    ground = reflection(down, inputs.eps_soil, inputs.k, roughness)
    inc_basis = basis(incidence)
    incident_field = np.einsum("pi,pj->pij", inc_basis, inc_basis).astype(complex)
    reflected_field = sandwich(reflection(incidence, inputs.eps_soil, inputs.k,
                                         roughness), incident_field)
    moment = (np.exp(-kappa*(thickness-z)/mu_view)[:, None, None, None]*incident_field
        + np.exp(-kappa*(thickness+z)/mu_view)[:, None, None, None]*reflected_field)

    def scatter(field):
        trace = np.trace(field, axis1=-2, axis2=-1)
        return inputs.density*((inputs.angular-inputs.constant)*field
            + inputs.constant*field.swapaxes(-1, -2)
            + inputs.constant*trace[..., None, None]*np.eye(3))

    def sweep(source, cosines, start, upward):
        step = thickness/n_layers/abs(cosines)
        tau = kappa*step
        e0, e1 = _e0e1(tau)
        shape = (len(cosines), 1, 1, 1)
        decay = np.exp(-tau).reshape(shape)
        first = (step*(e0-e1)).reshape(shape)
        second = (step*e1).reshape(shape)
        out = np.empty_like(source)
        out[0 if upward else -1] = start
        for i in (range(n_layers) if upward else range(n_layers, 0, -1)):
            j = i+1 if upward else i-1
            out[j] = decay*out[i]+first*source[i]+second*source[j]
        return out

    view = -incidence
    return_down = view*np.array([1., 1., -1.])
    pv = np.eye(3)-np.outer(view, view)
    pr = np.eye(3)-np.outer(return_down, return_down)
    rv = reflection(return_down, inputs.eps_soil, inputs.k, roughness)
    view_basis = basis(view)
    orders = []
    for order in range(1, max_order+1):
        source_tensor = scatter(moment)
        source_down = sandwich(project_down[None, :, None], source_tensor[:, None])
        source_up = sandwich(project_up[None, :, None], source_tensor[:, None])
        down_field = sweep(source_down, mu, np.zeros_like(source_down[0]), False)
        ground_field = sandwich(ground[:, None], down_field[0])
        up_field = sweep(source_up, mu, ground_field, True)
        moment = np.einsum("d,ldpij->lpij", weights, up_field+down_field)
        view_down = sandwich(pr, source_tensor)[:, None]
        view_up = sandwich(pv, source_tensor)[:, None]
        returned = sweep(view_down, np.array([mu_view]), np.zeros_like(view_down[0]), False)
        observed = sweep(view_up, np.array([mu_view]),
                         sandwich(rv, returned[0]), True)[-1, 0]
        # Matrix [receive V/H, transmit V/H], linear sigma0 per ground area.
        response = np.einsum("ri,pij,rj->rp", view_basis, observed, view_basis).real
        orders.append(4*np.pi*mu_view*response)
    return np.asarray(orders)
