"""Shape-noise injection and recovery for a singular isothermal sphere (SIS).

Independent check of the Lab's shear-profile fit: a different lens model (the singular SIS,
kappa = gamma_t = theta_E / (2 theta), Bartelmann & Schneider 2001, Eq. 3.18), its own random
catalogs, the exact ellipticity transformation (B&S Eq. 4.12 inverted), a least-squares fit and a
Kaiser-Squires E/B map. Nothing here imports the Lab code.
"""
import numpy as np

SAFE_RADIUS_FRACTION = 1.0  # fit only where theta > theta_E, so |g| < 1


def lens_ellipticity(intrinsic, reduced_shear):
    """epsilon = (epsilon_s + g) / (1 + g* epsilon_s) for |g| <= 1."""
    return (intrinsic + reduced_shear) / (1.0 + np.conj(reduced_shear) * intrinsic)


def sis_reduced_shear(einstein_radius, x, y):
    radius = np.hypot(x, y)
    phi = np.arctan2(y, x)
    kappa = einstein_radius / (2.0 * radius)
    tangential = kappa
    # gamma = -gamma_t exp(2 i phi) (B&S Eq. 3.18 sign convention)
    shear = -tangential * np.exp(2j * phi)
    return shear / (1.0 - kappa), kappa


def tangential_profile(x, y, ellipticity, edges):
    radius = np.hypot(x, y)
    rotated = ellipticity * np.exp(-2j * np.arctan2(y, x))
    tangential, cross = -rotated.real, -rotated.imag
    means, cross_means, errors, centres = [], [], [], []
    for lower, upper in zip(edges[:-1], edges[1:]):
        selected = (radius >= lower) & (radius < upper)
        count = selected.sum()
        means.append(tangential[selected].mean())
        cross_means.append(cross[selected].mean())
        errors.append(tangential[selected].std(ddof=1) / np.sqrt(count))
        # The leading SIS term scales as 1/theta, so the harmonic-mean radius makes the binned
        # model match the bin average to first order; the arithmetic mean would bias theta_E high.
        centres.append(1.0 / (1.0 / radius[selected]).mean())
    return np.array(centres), np.array(means), np.array(cross_means), np.array(errors)


def fit_einstein_radius(centres, means, errors):
    """Weighted least squares for g_t = (theta_E / 2 theta) / (1 - theta_E / 2 theta) on a fine grid."""
    trial = np.linspace(0.01, 3.0, 6000)
    model = (trial[:, None] / (2 * centres[None, :])) / (1 - trial[:, None] / (2 * centres[None, :]))
    chi_square = (((means[None, :] - model) / errors[None, :]) ** 2).sum(axis=1)
    best = np.argmin(chi_square)
    # 1-sigma from Delta chi^2 = 1
    inside = trial[chi_square <= chi_square[best] + 1.0]
    return trial[best], 0.5 * (inside.max() - inside.min())


def injection_trials(settings, shape_noise):
    theta_e = settings["einstein_radius_arcmin"]
    half = settings["field_arcmin"] / 2
    edges = np.array(settings["annulus_edges_arcmin"])
    rng = np.random.default_rng(settings["first_seed"])
    fitted, uncertainties, cross_significance = [], [], []
    for _ in range(settings["trials"]):
        count = rng.poisson(settings["galaxies_per_arcmin2"] * settings["field_arcmin"] ** 2)
        x, y = rng.uniform(-half, half, count), rng.uniform(-half, half, count)
        keep = np.hypot(x, y) > SAFE_RADIUS_FRACTION * theta_e
        x, y = x[keep], y[keep]
        intrinsic = shape_noise * (rng.standard_normal(x.size) + 1j * rng.standard_normal(x.size))
        magnitude = np.abs(intrinsic)
        intrinsic = np.where(magnitude > 0.9, intrinsic * 0.9 / np.maximum(magnitude, 1e-12), intrinsic)
        reduced, _ = sis_reduced_shear(theta_e, x, y)
        observed = lens_ellipticity(intrinsic, reduced)
        centres, means, cross, errors = tangential_profile(x, y, observed, edges)
        estimate, uncertainty = fit_einstein_radius(centres, means, errors)
        fitted.append(estimate)
        uncertainties.append(uncertainty)
        cross_significance.append((cross / errors).sum() / np.sqrt(len(cross)))
    fitted, uncertainties = np.array(fitted), np.array(uncertainties)
    pulls = (fitted - theta_e) / uncertainties
    return {
        "true_einstein_radius_arcmin": theta_e,
        "mean_fitted_einstein_radius_arcmin": float(fitted.mean()),
        "standard_error_of_mean_arcmin": float(fitted.std(ddof=1) / np.sqrt(fitted.size)),
        "scatter_of_fits_arcmin": float(fitted.std(ddof=1)),
        "median_quoted_uncertainty_arcmin": float(np.median(uncertainties)),
        "pull_mean": float(pulls.mean()),
        "pull_standard_deviation": float(pulls.std(ddof=1)),
        "cross_shear_significance_mean": float(np.mean(cross_significance)),
        "cross_shear_significance_standard_deviation": float(np.std(cross_significance, ddof=1)),
    }


def kaiser_squires_null_test(settings, pixels=256):
    """Noise-free SIS shear on a grid, inverted with Kaiser-Squires.

    The inversion recovers kappa minus its field mean (the ell = 0 mode is lost); the B mode is
    zero up to edge and pixel effects because the field is truncated by the box.
    """
    theta_e = settings["einstein_radius_arcmin"]
    side = settings["field_arcmin"]
    coordinate = (np.arange(pixels) + 0.5) * side / pixels - side / 2
    x, y = np.meshgrid(coordinate, coordinate, indexing="xy")
    radius = np.hypot(x, y)
    kappa = theta_e / (2 * np.maximum(radius, side / pixels))
    shear = -kappa * np.exp(2j * np.arctan2(y, x))
    frequencies = np.fft.fftfreq(2 * pixels)
    ell_x, ell_y = np.meshgrid(frequencies, frequencies, indexing="xy")
    padded = np.zeros((2 * pixels, 2 * pixels), dtype=complex)
    padded[:pixels, :pixels] = shear
    ell_squared = ell_x ** 2 + ell_y ** 2
    inverse_kernel = np.zeros_like(padded)
    nonzero = ell_squared > 0
    inverse_kernel[nonzero] = ((ell_x ** 2 - ell_y ** 2) - 2j * ell_x * ell_y)[nonzero] / ell_squared[nonzero]
    reconstructed = np.fft.ifft2(inverse_kernel * np.fft.fft2(padded))[:pixels, :pixels]
    interior = (np.abs(x) < side / 4) & (np.abs(y) < side / 4) & (radius > 2.0)
    e_mode, b_mode = reconstructed.real, reconstructed.imag
    offset = (kappa[interior] - e_mode[interior]).mean()
    residual_after_offset = kappa[interior] - e_mode[interior] - offset
    return {
        "interior_true_convergence_rms": float(np.sqrt((kappa[interior] ** 2).mean())),
        "interior_mean_offset_true_minus_e_mode": float(offset),
        "field_mean_true_convergence": float(kappa.mean()),
        "interior_residual_rms_after_offset": float(np.sqrt((residual_after_offset ** 2).mean())),
        "interior_b_mode_rms": float(np.sqrt((b_mode[interior] ** 2).mean())),
    }
