#!/usr/bin/env python3
"""Independent pressure FEM for compactly supported matrix drainage.

Functional: E[P] = integral (x**-2 |P'|**2 + x**-.8 P* M(x) P) dx.
The inlet value is prescribed.  Drainage vanishes beyond x=3, and the
finite-energy tail is constant; hence the natural endpoint condition is
Q(3)=0.  Every element stiffness is assembled by Gaussian quadrature,
and the inlet capacity is its Schur complement.  No Bessel formula or
analytic matrix capacity is used.

Run from any directory; output defaults to ../results/capacity.json.
Requires Python 3, NumPy, SciPy.
"""

from __future__ import annotations

import argparse
import json
from pathlib import Path

import numpy as np
from numpy.polynomial.legendre import leggauss
from scipy.sparse import coo_matrix
from scipy.sparse.linalg import splu


def profile_matrix(midpoint: float, rotating: bool) -> np.ndarray:
    angle = np.pi / 4 if rotating and midpoint > 2 else 0.0
    v = np.array([np.cos(angle), np.sin(angle)])
    return np.outer(v, v)


def assemble(cells: int, rotating: bool):
    if cells % 2:
        raise ValueError("An even cell count places the interface x=2 on a node.")
    x = np.linspace(1.0, 3.0, cells + 1)
    xi, wi = leggauss(8)
    rows, cols, values = [], [], []
    for element in range(cells):
        left, right = x[element : element + 2]
        h = right - left
        points = (left + right) / 2 + h * xi / 2
        weights = h * wi / 2
        phi = np.column_stack([(1 - xi) / 2, (1 + xi) / 2])
        # Exact integral of x^-2 avoids unnecessary quadrature error here.
        diffusion = (1 / left - 1 / right) / h**2
        reaction = np.einsum("q,qi,qj->ij", weights * points**-0.8, phi, phi)
        local = np.kron(diffusion * np.array([[1, -1], [-1, 1]]), np.eye(2))
        local += np.kron(reaction, profile_matrix((left + right) / 2, rotating))
        dofs = np.arange(2 * element, 2 * element + 4)
        for i, di in enumerate(dofs):
            for j, dj in enumerate(dofs):
                rows.append(di)
                cols.append(dj)
                values.append(local[i, j])
    size = 2 * (cells + 1)
    return x, coo_matrix((values, (rows, cols)), shape=(size, size)).tocsc()


def capacity(stiffness, tail_conductance: float = 0.0, dirichlet_tail=False):
    """Return inlet Schur complement and minimizing fields for basis inputs."""
    k = stiffness.copy().tolil()
    n = k.shape[0]
    if tail_conductance:
        k[n - 2, n - 2] += tail_conductance
        k[n - 1, n - 1] += tail_conductance
    k = k.tocsc()
    free = np.arange(2, n - 2 if dirichlet_tail else n)
    rhs = k[free, :2].toarray()
    solver = splu(k[free, :][:, free])
    u = np.zeros((n, 2))
    u[:2] = np.eye(2)
    u[free] = -solver.solve(rhs)
    raw = k[:2, :] @ u
    c = (raw + raw.T) / 2
    residual = np.max(np.abs(k[free, :] @ u))
    energy_error = np.max(np.abs(u.T @ (k @ u) - c))
    return c, u, {"maximum_free_equation_residual": float(residual),
                  "boundary_energy_discrepancy": float(energy_error)}


def eigenvalues(a):
    return np.linalg.eigvalsh(a).tolist()


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--output", type=Path,
                        default=Path(__file__).resolve().parents[1] / "results/capacity.json")
    args = parser.parse_args()
    results = {
        "model": {"R": "x^2", "G": "x^(-4/5)", "interval": [1, 3],
                  "drainage": "v v^T; v=(1,0) on [1,2], rotated by pi/4 on [2,3]; zero beyond 3",
                  "tail_condition": "natural Q(3)=0; finite-energy pressure tail may be constant",
                  "method": "linear pressure FEM, 8-point reaction quadrature; inlet Schur complement"},
        "mesh_refinement": [],
    }
    finest = {}
    for cells in [100, 200, 400, 800]:
        entry = {"cells": cells}
        for rotating, name in [(False, "fixed"), (True, "rotating")]:
            x, k = assemble(cells, rotating)
            c, u, diagnostics = capacity(k)
            entry[name] = {"capacity": c.tolist(), "eigenvalues": eigenvalues(c), **diagnostics}
            finest[name] = (k, c, u)
        results["mesh_refinement"].append(entry)

    g1 = 5 * (2**0.2 - 1)
    g2 = 5 * (3**0.2 - 2**0.2)
    h_fixed = np.diag([g1 + g2, 0.0])
    v2 = np.array([1.0, 1.0]) / np.sqrt(2)
    h_rotating = np.diag([g1, 0.0]) + g2 * np.outer(v2, v2)
    s, g = (3**3 - 1) / 3, g1 + g2
    bound_fixed = h_fixed / (2 * (1 + s * g))
    bound_rotating = h_rotating / (2 * (1 + s * g))
    c_fixed = finest["fixed"][1]
    c_rotating = finest["rotating"][1]
    results["common_kernel"] = {
        "theorem": "ker C = {z: M(x) z=0 for almost every x}; compact support, finite interval with natural tail",
        "proof": "Zero minimum energy forces P'=0 a.e. and M^(1/2)P=0 a.e.; conversely a constant common-kernel vector has zero energy.",
        "fixed_common_kernel_dimension": 1,
        "rotating_common_kernel_dimension": 0,
        "fixed_capacity_null_residual": float(np.linalg.norm(c_fixed @ np.array([0.0, 1.0]))),
        "rotating_smallest_capacity_eigenvalue": float(np.linalg.eigvalsh(c_rotating)[0]),
        "fixed_gram_eigenvalues": eigenvalues(h_fixed),
        "rotating_gram_eigenvalues": eigenvalues(h_rotating),
    }
    results["gram_lower_bound"] = {
        "formula": "C >= H / [2(1+S*g)], H=int G*M, S=int R, g=int G*||M||",
        "S": s, "g": g,
        "fixed_bound": bound_fixed.tolist(),
        "rotating_bound": bound_rotating.tolist(),
        "fixed_difference_eigenvalues": eigenvalues(c_fixed - bound_fixed),
        "rotating_difference_eigenvalues": eigenvalues(c_rotating - bound_rotating),
    }

    k = finest["fixed"][0]
    cutoff = []
    for endpoint in [3, 4, 6, 10, 30, 100]:
        if endpoint == 3:
            c, _, diagnostics = capacity(k, dirichlet_tail=True)
            tail_kappa = None
        else:
            tail_kappa = 3 / (endpoint**3 - 3**3)
            c, _, diagnostics = capacity(k, tail_conductance=tail_kappa)
        expected_dark = 3 / (endpoint**3 - 1)
        cutoff.append({"Dirichlet_cutoff": endpoint,
                       "exact_tail_conductance_at_3": tail_kappa,
                       "capacity_eigenvalues": eigenvalues(c),
                       "capacity_distance_from_natural": float(np.linalg.norm(c - c_fixed, 2)),
                       "dark_capacity": float(c[1, 1]),
                       "exact_dark_capacity": expected_dark,
                       "relative_dark_error": float(abs(c[1, 1] - expected_dark) / expected_dark),
                       **diagnostics})
    results["finite_Dirichlet_cutoffs"] = cutoff
    results["tail_explanation"] = {
        "exact_scalar_tail_cost": "|P(3)|^2 / integral_3^T R = 3|P(3)|^2/(T^3-27)",
        "reason": "Cauchy-Schwarz yields the bound; P' proportional to R attains it.",
        "limit": "Cost vanishes as T tends to infinity. Imposing P(3)=0 adds artificial conductance; imposing decay only at infinity has the same infimum, potentially without an attained minimizer.",
    }

    max_diag = max(max(item[name]["maximum_free_equation_residual"],
                       item[name]["boundary_energy_discrepancy"])
                   for item in results["mesh_refinement"] for name in ["fixed", "rotating"])
    checks = {
        "fixed_common_kernel_is_null": results["common_kernel"]["fixed_capacity_null_residual"] < 2e-8,
        "rotating_rank_one_drainage_is_full_capacity": np.linalg.eigvalsh(c_rotating)[0] > 0.01,
        "fixed_gram_bound": min(eigenvalues(c_fixed - bound_fixed)) > -2e-8,
        "rotating_gram_bound": min(eigenvalues(c_rotating - bound_rotating)) > 0,
        "mesh_refines": np.linalg.norm(np.array(results["mesh_refinement"][-1]["rotating"]["capacity"]) -
                                        np.array(results["mesh_refinement"][-2]["rotating"]["capacity"])) < 1e-5,
        "Euler_and_energy_consistency": max_diag < 2e-7,
        "finite_cutoff_dark_cost": max(row["relative_dark_error"] for row in cutoff) < 5e-5,
        "cutoff_artifact_decays": all(cutoff[i + 1]["capacity_distance_from_natural"] <
                                      cutoff[i]["capacity_distance_from_natural"] for i in range(len(cutoff) - 1)),
    }
    results["checks"] = {key: bool(value) for key, value in checks.items()}
    results["all_passed"] = all(checks.values())
    args.output.parent.mkdir(parents=True, exist_ok=True)
    args.output.write_text(json.dumps(results, indent=2) + "\n")
    print(json.dumps({"all_passed": results["all_passed"],
                      "fixed_eigenvalues": eigenvalues(c_fixed),
                      "rotating_eigenvalues": eigenvalues(c_rotating),
                      "checks": results["checks"]}, indent=2))
    if not results["all_passed"]:
        raise SystemExit(1)


if __name__ == "__main__":
    main()