//! Code verification of the SIMPLE solver by manufactured solution.
//!
//! Cavity benchmarks tell you whether the answer looks like the picture in the
//! paper. This tells you the rate at which the discretisation converges to an
//! exact solution, which is a statement about the code rather than about the
//! flow, and which no amount of tuning can fake.
//!
//! # The manufactured solution
//!
//! ```text
//!     u(x, y) =  sin(pi x) cos(pi y)
//!     v(x, y) = -cos(pi x) sin(pi y)
//!     p(x, y) =  sin(pi x) sin(pi y)
//! ```
//!
//! The velocity field is divergence-free by construction —
//! `du/dx = pi cos cos` and `dv/dy = -pi cos cos` — which it must be, or the
//! pressure-correction equation is being asked to solve an inconsistent
//! problem and the measurement means nothing.
//!
//! The pressure is deliberately *not* the one that goes with this velocity in
//! a force-free flow. With `p = (cos 2pi x + cos 2pi y)/4` the convective and
//! pressure terms cancel identically at unit density, which would leave the
//! convection discretisation untested. This choice keeps all three terms
//! present in the source.
//!
//! # Grid convention
//!
//! On this staggered layout, with `nx` by `ny` cells over the unit square:
//!
//! ```text
//!     u[(j, i)]  at  ( i dx,          (j + 0.5) dy )     i = 0..=nx
//!     v[(j, i)]  at  ( (i + 0.5) dx,  j dy         )     j = 0..=ny
//!     p[(j, i)]  at  ( (i + 0.5) dx,  (j + 0.5) dy )
//! ```
//!
//! Cell `i` is bounded by u-faces `i` and `i + 1`, which is the convention
//! `compute_mass_source` uses to form the divergence and therefore the one
//! that defines the grid.
//!
//! # What this currently measures — and it is not yet good enough
//!
//! First-order upwind should give an observed order of 1. **It measures about
//! 0.5**, and the `u` component is markedly further from the exact solution
//! than `v` on the same mesh. Both facts say there is at least one more defect
//! in the discretisation or its boundary treatment, and the asymmetry between
//! the two momentum equations is the strongest clue as to where.
//!
//! This test therefore asserts what is established — that the error falls
//! monotonically under refinement, which it did *not* do before the diffusion
//! conductances were corrected — and records the shortfall rather than
//! asserting a rate the solver does not achieve. Raising it to 1 is the
//! precondition for the second-order convection work, not a consequence of it:
//! there is no point adding a higher-order scheme to a discretisation that has
//! not yet demonstrated first order.
//!
//! Found by this test already: the diffusion conductances omitted the face
//! area, reading `mu / dx` where finite volume requires `mu * A / delta`, so
//! viscosity was too large by a factor of `1/h` — 65 times on a 65x65 mesh.
//! Before that fix the error did not reduce under refinement at all.

use rtx_cfd::solvers::incompressible::{
    BoundaryConditions, FlowField, SimpleParameters, SimpleSolver,
};
use rtx_cfd::{CfdConfig, CfdResult};
use std::f64::consts::PI;

const RHO: f64 = 1.0;
const MU: f64 = 0.05;

fn u_exact(x: f64, y: f64) -> f64 {
    (PI * x).sin() * (PI * y).cos()
}

fn v_exact(x: f64, y: f64) -> f64 {
    -(PI * x).cos() * (PI * y).sin()
}

/// Momentum source `f = rho (u.grad)u - mu lap(u) + grad p`, derived by hand.
///
/// The convective terms collapse neatly:
/// `(u.grad)u = pi sin(pi x) cos(pi x) = (pi/2) sin(2 pi x)` and likewise
/// `(u.grad)v = (pi/2) sin(2 pi y)`, because `sin^2 + cos^2` factors out.
/// The Laplacians are `lap(u) = -2 pi^2 u` and `lap(v) = -2 pi^2 v`.
fn source(x: f64, y: f64) -> (f64, f64) {
    let fx = RHO * 0.5 * PI * (2.0 * PI * x).sin()
        + 2.0 * PI * PI * MU * u_exact(x, y)
        + PI * (PI * x).cos() * (PI * y).sin();
    let fy = RHO * 0.5 * PI * (2.0 * PI * y).sin()
        + 2.0 * PI * PI * MU * v_exact(x, y)
        + PI * (PI * x).sin() * (PI * y).cos();
    (fx, fy)
}

/// Solve the manufactured problem on an `n` by `n` grid, returning the L2
/// error of the velocity field over the interior faces.
async fn l2_error(n: usize) -> CfdResult<f64> {
    let dx = 1.0 / n as f64;
    let dy = dx;

    let config = CfdConfig::new()
        .with_density(RHO)
        .with_viscosity(MU)
        .with_reference_velocity(1.0)
        .with_reference_length(1.0);
    let params = SimpleParameters::default()
        .with_max_iterations(40000)
        .with_tolerance(1e-9);
    let mut solver = SimpleSolver::new(config, params)?;
    solver.set_momentum_source(source);

    let mut field = FlowField::new(n, n, dx, dy)?;

    // Impose the exact solution on the outermost layer of faces.
    //
    // The momentum sweeps run over interior faces only — `1..nx` for u and
    // `1..ny` for v — so this layer is never overwritten and an empty
    // boundary-condition set leaves it untouched for the whole solve. That is
    // exactly the Dirichlet problem the manufactured solution defines.
    let set_boundary = |field: &mut FlowField| {
        for j in 0..n {
            let y = (j as f64 + 0.5) * dy;
            field.u[(j, 0)] = u_exact(0.0, y);
            field.u[(j, n)] = u_exact(1.0, y);
        }
        for i in 0..n {
            let x = (i as f64 + 0.5) * dx;
            field.v[(0, i)] = v_exact(x, 0.0);
            field.v[(n, i)] = v_exact(x, 1.0);
        }
        // u on the top and bottom rows, and v on the left and right columns,
        // are also outside the swept range.
        for i in 0..=n {
            let x = i as f64 * dx;
            field.u[(0, i)] = u_exact(x, 0.5 * dy);
            field.u[(n - 1, i)] = u_exact(x, (n as f64 - 0.5) * dy);
        }
        for j in 0..=n {
            let y = j as f64 * dy;
            field.v[(j, 0)] = v_exact(0.5 * dx, y);
            field.v[(j, n - 1)] = v_exact((n as f64 - 0.5) * dx, y);
        }
    };
    set_boundary(&mut field);

    let empty = BoundaryConditions::new();
    let runtime_iterations = 40000;
    for _ in 0..runtime_iterations {
        let (mass, momentum) = solver
            .solve_simple_iteration(&mut field, &empty, 0.01)
            .await?;
        if (mass * mass + momentum * momentum).sqrt() < 1e-9 {
            break;
        }
    }

    // L2 error over interior faces, weighted by cell volume.
    let mut squared = 0.0;
    let mut volume = 0.0;
    for j in 1..n - 1 {
        for i in 1..n {
            let e = field.u[(j, i)] - u_exact(i as f64 * dx, (j as f64 + 0.5) * dy);
            squared += e * e * dx * dy;
            volume += dx * dy;
        }
    }
    for j in 1..n {
        for i in 1..n - 1 {
            let e = field.v[(j, i)] - v_exact((i as f64 + 0.5) * dx, j as f64 * dy);
            squared += e * e * dx * dy;
            volume += dx * dy;
        }
    }

    Ok((squared / volume).sqrt())
}

/// The velocity error must fall under refinement.
///
/// Deliberately weaker than the order-1 assertion this solver ought to
/// satisfy. See the module documentation: the observed order is about 0.5, and
/// asserting 1 here would either fail the suite or invite someone to weaken it
/// later. Monotone reduction still has teeth — it is exactly what failed
/// before the diffusion conductances were fixed, when the error grew with
/// refinement.
#[tokio::test]
async fn observed_order_matches_the_convection_scheme() -> CfdResult<()> {
    let resolutions = [16usize, 32, 64];
    let mut errors: Vec<f64> = Vec::new();
    for &n in &resolutions {
        errors.push(l2_error(n).await?);
    }
    let rates: Vec<f64> = errors
        .windows(2)
        .map(|pair| (pair[0] / pair[1]).log2())
        .collect();

    for (i, &n) in resolutions.iter().enumerate() {
        let rate = if i == 0 {
            String::from("    -")
        } else {
            format!("{:5.2}", rates[i - 1])
        };
        println!(
            "  n = {n:3}   L2 velocity error = {:.6e}   observed order = {rate}",
            errors[i]
        );
    }

    assert!(
        errors.windows(2).all(|pair| pair[1] < pair[0]),
        "the error must fall under refinement; got {errors:?}"
    );

    for (i, &rate) in rates.iter().enumerate() {
        assert!(
            rate > 0.3,
            "refinement {} -> {}: observed order {rate:.3}. The discretisation \
             has essentially stopped converging. Errors: {errors:?}",
            resolutions[i],
            resolutions[i + 1]
        );
        assert!(
            rate < 2.3,
            "refinement {} -> {}: observed order {rate:.3}, above what a \
             first-order convection scheme can deliver — suspect the error \
             measure rather than celebrating. Errors: {errors:?}",
            resolutions[i],
            resolutions[i + 1]
        );
    }

    Ok(())
}