"""Extract baseline RANS at experimental locations using foamToVTK + Python+vtk.

Usage (per-case): the per-case shell script `run_baseline_extraction.sh` invokes
this module after producing a VTK/<case>_<time>.vtk file via foamToVTK.

Approach: the VTK volume is a vtkUnstructuredGrid containing U, k, omega, p, nut.
For each experimental measurement location, we use vtkProbeFilter with a
vtkPolyData of the experiment points to interpolate the volume fields onto
those exact (x,y,z). Output: one CSV per highfidelity .csv with the same
(x, y, z) coords replaced by sampled (U, V, W, k, omega, p, nut).

Reynolds stresses are computed from Boussinesq:
    R_ij = (2/3) k delta_ij  -  nut * (dU_i/dx_j + dU_j/dx_i)
gradU is computed via vtkGradientFilter on the volume.
"""

import os
import sys
import glob
import numpy as np
import pandas as pd
import vtk
from vtk.util import numpy_support as ns


def load_volume(vtk_path):
    """Load a foamToVTK output (legacy .vtk or .vtu/.pvtu) -> vtkUnstructuredGrid."""
    if vtk_path.endswith('.vtk'):
        reader = vtk.vtkUnstructuredGridReader()
    elif vtk_path.endswith('.vtu'):
        reader = vtk.vtkXMLUnstructuredGridReader()
    elif vtk_path.endswith('.pvtu'):
        reader = vtk.vtkXMLPUnstructuredGridReader()
    else:
        raise ValueError(f'Unknown VTK format: {vtk_path}')
    reader.SetFileName(vtk_path)
    reader.Update()
    return reader.GetOutput()


def add_grad_U(grid):
    """Compute gradU via vtkGradientFilter and attach as point data."""
    grad = vtk.vtkGradientFilter()
    grad.SetInputData(grid)
    grad.SetInputScalars(grid.FIELD_ASSOCIATION_POINTS, 'U')
    grad.SetResultArrayName('gradU')
    grad.Update()
    return grad.GetOutput()


def probe_at_points(volume, points_xyz):
    """Interpolate volume fields onto given (N,3) point cloud.
    Points that fall outside the volume mesh are marked NaN (not 0) so plots
    can mask missing data instead of treating zeros as real values."""
    pts = vtk.vtkPoints()
    pts.SetData(ns.numpy_to_vtk(np.ascontiguousarray(points_xyz, dtype=np.float64)))
    poly = vtk.vtkPolyData()
    poly.SetPoints(pts)

    probe = vtk.vtkProbeFilter()
    probe.SetSourceData(volume)
    probe.SetInputData(poly)
    probe.SetValidPointMaskArrayName('vtkValidPointMask')
    probe.Update()
    out = probe.GetOutput()

    pdata = out.GetPointData()
    valid_arr = pdata.GetArray('vtkValidPointMask')
    valid = ns.vtk_to_numpy(valid_arr).astype(bool) if valid_arr else np.ones(len(points_xyz), bool)
    n_invalid = int((~valid).sum())
    if n_invalid:
        print(f'    [probe] {n_invalid}/{len(valid)} query points outside mesh -> NaN')

    fields = {}
    for i in range(pdata.GetNumberOfArrays()):
        name = pdata.GetArrayName(i)
        if name == 'vtkValidPointMask':
            continue
        arr = ns.vtk_to_numpy(pdata.GetArray(i)).astype(np.float64)
        if arr.ndim == 1:
            arr[~valid] = np.nan
        else:
            arr[~valid, :] = np.nan
        fields[name] = arr
    return fields


def reynolds_from_boussinesq(U, gradU_flat, k, nut):
    """gradU_flat shape (N, 9): [du/dx du/dy du/dz dv/dx ... dw/dz]
    Returns dict with R_xx, R_yy, R_zz, R_xy, R_xz, R_yz."""
    g = gradU_flat.reshape(-1, 3, 3)
    S = 0.5 * (g + g.transpose(0, 2, 1))
    R = np.zeros_like(S)
    for i in range(3):
        R[:, i, i] = (2.0 / 3.0) * k
    R = R - 2.0 * nut[:, None, None] * S
    return {
        'R_xx': R[:, 0, 0], 'R_yy': R[:, 1, 1], 'R_zz': R[:, 2, 2],
        'R_xy': R[:, 0, 1], 'R_xz': R[:, 0, 2], 'R_yz': R[:, 1, 2],
    }


def main():
    if len(sys.argv) < 4:
        print("Usage: extract_baseline_from_vtk.py <vtk_volume> <highfidelity_dir> <output_dir>")
        sys.exit(1)
    vtk_path, hf_dir, out_dir = sys.argv[1:4]

    print(f'[load] {vtk_path}')
    grid = load_volume(vtk_path)
    print(f'[grad] computing gradU')
    grid = add_grad_U(grid)

    os.makedirs(out_dir, exist_ok=True)

    import re

    # Per-case length scale: divide experiment coords by H_NORM to map into
    # a non-dimensional OF mesh. Set via env var FH_H_NORM (default 1.0 = no rescale).
    H_NORM = float(os.environ.get('H_NORM', '1.0'))
    if H_NORM != 1.0:
        print(f'[H_NORM={H_NORM} m -> dividing experiment coords by this length]')

    for csv_in in sorted(glob.glob(os.path.join(hf_dir, '*.csv'))):
        df = pd.read_csv(csv_in)
        bn = os.path.basename(csv_in)

        # Special-case Faith Hill PIV centerline: 2D plane data (x_mm, y_mm),
        # implicit z=0 (centerline). Coord remap: (x_mm, y_mm)/h_mm -> OF (x, y), z=0.
        if 'PIV_centerline' in bn:
            x_mm = df['x_mm'].values
            y_mm = df['y_mm'].values
            # convert mm -> m -> divide by H_NORM
            xyz = np.column_stack([x_mm * 1e-3 / H_NORM,
                                    y_mm * 1e-3 / H_NORM,
                                    np.zeros(len(df))])
            print(f'  [Faith Hill PIV] {bn}')
            fields = probe_at_points(grid, xyz)
            out = pd.DataFrame({'x_mm': x_mm, 'y_mm': y_mm})
            if 'U' in fields:
                U = fields['U'].reshape(-1, 3)
                out['U_mean'] = U[:, 0]; out['V_mean'] = U[:, 1]; out['W_mean'] = U[:, 2]
            for f in ['k', 'omega', 'p', 'nut']:
                if f in fields:
                    out[f] = fields[f]
            if all(f in fields for f in ['U', 'k', 'nut', 'gradU']):
                stresses = reynolds_from_boussinesq(
                    fields['U'].reshape(-1, 3), fields['gradU'],
                    fields['k'], fields['nut'])
                for k, v in stresses.items():
                    out[k] = v
            out.to_csv(os.path.join(out_dir, bn), index=False)
            print(f'  {bn:40s} -> {bn} ({len(out)} rows)')
            continue

        # Special-case Faith Hill PSP centerline: 1D, x_in only. z=0 (sym).
        # The wall follows a cosine bump h(r)=3*cos(pi*r/9)+3 [in] for |r|<=9 in.
        # Probe just above the wall surface (y_wall + epsilon).
        if 'PSP_centerline' in bn:
            x_in = df['x_in'].values
            # bump height in inches at each x (centerline so r=|x|)
            r = np.abs(x_in)
            y_in_wall = np.where(r <= 9.0, 3.0 * np.cos(np.pi * r / 9.0) + 3.0, 0.0)
            # convert wall coord to OF mesh frame, add small offset
            y_offset_OF = 0.005  # ~0.5% of hill in non-dim units
            xyz = np.column_stack([
                x_in * 0.0254 / H_NORM,
                y_in_wall * 0.0254 / H_NORM + y_offset_OF,
                np.zeros(len(df))
            ])
            print(f'  [Faith Hill PSP, bump-aware] {bn}')
            fields = probe_at_points(grid, xyz)
            out = pd.DataFrame({'x_in': x_in})
            if 'p' in fields:
                out['p'] = fields['p']
                # Cp = (p - p_inf) / (0.5 * U_inf^2). For non-dim case U_inf=1 -> Cp = 2*p (since rho=1).
                out['Cp'] = 2.0 * fields['p']
            out.to_csv(os.path.join(out_dir, bn), index=False)
            print(f'  {bn:40s} -> {bn} ({len(out)} rows)')
            continue

        # Special-case Faith Hill FISF surface: (X, Y, Z) where Y=spanwise -> OF z, Z=wallnormal -> OF y.
        if 'FISF' in bn:
            X = df['X'].values
            Yspan = df['Y'].values
            Znorm = df['Z'].values
            xyz = np.column_stack([X * 0.0254 / H_NORM,
                                    Znorm * 0.0254 / H_NORM,  # FISF Z -> OF y
                                    Yspan * 0.0254 / H_NORM])  # FISF Y -> OF z
            print(f'  [Faith Hill FISF (Y/Z swap)] {bn}')
            fields = probe_at_points(grid, xyz)
            out = pd.DataFrame({'X': X, 'Y': Yspan, 'Z': Znorm})
            if 'U' in fields:
                U = fields['U'].reshape(-1, 3)
                out['U'] = U[:, 0]; out['V'] = U[:, 1]; out['W'] = U[:, 2]
            for f in ['k', 'omega', 'p', 'nut']:
                if f in fields:
                    out[f] = fields[f]
            out.to_csv(os.path.join(out_dir, bn), index=False)
            print(f'  {bn:40s} -> {bn} ({len(out)} rows)')
            continue

        # Special-case WingBody profile_midplane files: x station encoded in filename,
        # z=0 (symmetry plane), y varies. Columns: y, u, v, Re_xx, ..., k.
        prof_match = re.match(r'profile_midplane_([-+]?\d*\.?\d+)\.csv$',
                              os.path.basename(csv_in))
        if prof_match:
            T = 0.0717  # WingBody DNS thickness scale
            x_over_T = float(prof_match.group(1))
            xyz = np.column_stack([
                np.full(len(df), x_over_T * T),
                df['y'].values * T,
                np.zeros(len(df)),
            ])
            print(f'  [profile_midplane x/T={x_over_T}] {os.path.basename(csv_in)}')
            fields = probe_at_points(grid, xyz)
            out = pd.DataFrame({'y': df['y']})
            if 'U' in fields:
                U = fields['U'].reshape(-1, 3)
                out['u'] = U[:, 0] / 27.0  # u_ref = 27 m/s
                out['v'] = U[:, 1] / 27.0
                out['w'] = U[:, 2] / 27.0
            # WingBody DNS normalises by u_ref = 27 m/s
            U_REF = 27.0
            if 'k' in fields:
                out['k'] = fields['k'] / U_REF**2
            if 'omega' in fields:
                out['omega'] = fields['omega']
            if 'p' in fields:
                out['p'] = fields['p']
            if 'nut' in fields:
                out['nut'] = fields['nut']
            if all(f in fields for f in ['U', 'k', 'nut', 'gradU']):
                stresses = reynolds_from_boussinesq(
                    fields['U'].reshape(-1, 3), fields['gradU'],
                    fields['k'], fields['nut'])
                for kk, v in stresses.items():
                    out[kk] = v / U_REF**2
            out.to_csv(os.path.join(out_dir, os.path.basename(csv_in)), index=False)
            print(f'  {os.path.basename(csv_in):40s} -> {os.path.basename(csv_in)} '
                  f'({len(out)} rows)')
            continue

        cols = {c.lower(): c for c in df.columns}

        # Resolve x / y / z column names (case-insensitive, allow common suffixes)
        def _find(prefixes):
            for p in prefixes:
                if p in cols:
                    return cols[p]
            return None

        xname = _find(['x', 'x_mm', 'x_in', 'x_over_t'])
        yname = _find(['y', 'y_mm', 'y_in', 'y_over_t'])
        zname = _find(['z', 'z_mm', 'z_in', 'z_over_t'])
        # If z missing (2D plane data), assume z=0
        z_implicit = zname is None
        if not (xname and yname):
            print(f'  skip {os.path.basename(csv_in)} - no x/y columns')
            continue

        # Detect coord scaling from magnitude + column-name hint.
        x_vals = df[xname].abs().values
        max_abs = x_vals.max() if len(x_vals) else 0
        if 'mm' in xname.lower():
            scale = 1e-3
        elif 'in' in xname.lower():
            scale = 0.0254
        elif 'over_t' in xname.lower():
            scale = 0.0717  # WingBody DNS reference thickness T = 71.7 mm
        elif max_abs > 100:
            scale = 1e-3   # likely mm
        elif max_abs > 1.5:
            scale = 0.0254 # likely inches
        else:
            scale = 1.0    # assume meters

        if z_implicit:
            xyz = np.column_stack([df[xname].values * scale,
                                    df[yname].values * scale,
                                    np.zeros(len(df))])
        else:
            xyz = df[[xname, yname, zname]].values * scale
        # detect Wing-body surface CSVs (have x_over_T columns) and compute Cp from OF p
        is_wbj_surface = ('over_t' in xname.lower())
        print(f'  [scale={scale:g}, z_implicit={z_implicit}, wbj={is_wbj_surface}] {os.path.basename(csv_in)}')

        fields = probe_at_points(grid, xyz)
        cols_keep = {xname: df[xname], yname: df[yname]}
        if not z_implicit:
            cols_keep[zname] = df[zname]
        out = pd.DataFrame(cols_keep)
        if is_wbj_surface and 'p' in fields:
            U_REF = 27.0
            out['Cp'] = 2.0 * fields['p'] / U_REF**2
        if 'U' in fields:
            U = fields['U'].reshape(-1, 3)
            out['U'] = U[:, 0]; out['V'] = U[:, 1]; out['W'] = U[:, 2]
        for f in ['k', 'omega', 'p', 'nut']:
            if f in fields:
                out[f] = fields[f]
        if all(f in fields for f in ['U', 'k', 'nut', 'gradU']):
            stresses = reynolds_from_boussinesq(
                fields['U'].reshape(-1, 3),
                fields['gradU'],
                fields['k'],
                fields['nut'])
            for k, v in stresses.items():
                out[k] = v

        out_csv = os.path.join(out_dir, os.path.basename(csv_in))
        out.to_csv(out_csv, index=False)
        print(f'  {os.path.basename(csv_in):40s} -> {out_csv} ({len(out)} rows, {len(out.columns)} cols)')


if __name__ == '__main__':
    main()