#!/usr/bin/env python3
from __future__ import annotations

import csv
import math
import re
import subprocess
from pathlib import Path


ROOT = Path("/home/user/Desktop")
CASE = ROOT / "cavity_graph"
SAMPLES = CASE / "postProcessing/sampleDict/30"


def read(path: Path) -> str:
    return path.read_text(encoding="utf-8", errors="ignore")


def named_block(text: str, name: str) -> str:
    text = re.sub(r"/\*.*?\*/|//[^\n]*", "", text, flags=re.S)
    match = re.search(rf"(?m)^\s*{re.escape(name)}\s*\{{", text)
    if not match:
        raise ValueError(f"missing block {name}")
    start = text.find("{", match.start())
    depth = 0
    for index in range(start, len(text)):
        depth += text[index] == "{"
        depth -= text[index] == "}"
        if depth == 0:
            return text[start + 1 : index]
    raise ValueError(f"unterminated block {name}")


def has_entry(block: str, key: str, value: str) -> bool:
    return re.search(rf"(?<!\w){re.escape(key)}\s+{value}\s*;", block) is not None


def patch(text: str, name: str) -> str:
    return named_block(named_block(text, "boundaryField"), name)


def field(path: Path, kind: str) -> list:
    text = read(path)
    header = named_block(text, "FoamFile")
    if not (
        has_entry(header, "format", r"ascii")
        and has_entry(header, "class", rf"vol{kind.capitalize()}Field")
        and has_entry(header, "object", re.escape(path.name))
    ):
        raise ValueError(f"field is not ASCII: {path}")
    match = re.search(
        rf"internalField\s+nonuniform\s+List<{kind}>\s+(\d+)\s*\((.*?)\)\s*;",
        text,
        re.S,
    )
    if not match:
        raise ValueError(f"missing nonuniform {kind} field")
    if kind == "vector":
        values = [
            tuple(float(value) for value in item.split())
            for item in re.findall(r"\(([^()]+)\)", match.group(2))
        ]
        valid = all(
            len(value) == 3 and all(math.isfinite(component) for component in value)
            for value in values
        )
    else:
        values = [float(value) for value in match.group(2).split()]
        valid = all(math.isfinite(value) for value in values)
    if len(values) != int(match.group(1)) or not valid:
        raise ValueError(f"invalid {kind} field")
    return values


def log_finished(path: Path) -> bool:
    text = read(path)
    return "FOAM FATAL" not in text and text.rstrip().endswith("End")


def profile(path: Path) -> list[tuple[float, float, float]]:
    rows = []
    for line in read(path).splitlines():
        stripped = line.strip()
        if not stripped or stripped.startswith("#"):
            continue
        values = [float(value) for value in stripped.split()]
        if len(values) != 4 or not all(math.isfinite(value) for value in values):
            raise ValueError("invalid sampled profile")
        rows.append((values[0], values[1], values[2]))
    if len(rows) != 99:
        raise ValueError("unexpected profile length")
    expected_coordinates = [0.01 * index for index in range(1, 100)]
    if any(abs(row[0] - expected) > 1e-9 for row, expected in zip(rows, expected_coordinates)):
        raise ValueError("unexpected profile coordinates")
    return rows


def csv_profile(path: Path, keys: tuple[str, str, str]) -> list[tuple[float, float, float]]:
    with path.open(encoding="utf-8", newline="") as stream:
        rows = list(csv.DictReader(stream))
    if len(rows) != 99 or set(rows[0]) != set(keys):
        raise ValueError("invalid CSV profile")
    values = [tuple(float(row[key]) for key in keys) for row in rows]
    if any(not all(math.isfinite(value) for value in row) for row in values):
        raise ValueError("non-finite CSV profile")
    return values


def check_case() -> bool:
    mesh = read(CASE / "system/blockMeshDict")
    velocity = read(CASE / "0/U")
    pressure = read(CASE / "0/p")
    physical = read(CASE / "constant/physicalProperties")
    control = read(CASE / "system/controlDict")
    sampling = read(CASE / "system/sampleDict")
    return all(
        (
            re.search(r"convertToMeters\s+1\s*;", mesh) is not None,
            "(64 64 1)" in mesh,
            re.search(r"\binternalField\s+uniform\s+\(0(?:\.0+)?\s+0(?:\.0+)?\s+0(?:\.0+)?\)\s*;", velocity) is not None,
            has_entry(patch(velocity, "movingWall"), "value", r"uniform\s+\(1(?:\.0+)?\s+0(?:\.0+)?\s+0(?:\.0+)?\)"),
            has_entry(patch(velocity, "fixedWalls"), "type", r"noSlip"),
            has_entry(patch(velocity, "frontAndBack"), "type", r"empty"),
            has_entry(patch(pressure, "movingWall"), "type", r"zeroGradient"),
            has_entry(patch(pressure, "fixedWalls"), "type", r"zeroGradient"),
            has_entry(patch(pressure, "frontAndBack"), "type", r"empty"),
            re.search(r"\bnu\s+\[0 2 -1 0 0 0 0\]\s+0\.01\s*;", physical) is not None,
            "application icoFoam;" in control,
            re.search(r"\bendTime\s+30\s*;", control) is not None,
            re.search(r"\bdeltaT\s+0\.005\s*;", control) is not None,
            re.search(r"\bwriteFormat\s+ascii\s*;", control) is not None,
            "interpolationScheme cellPoint;" in sampling,
            "setFormat raw;" in sampling,
            "start (0.5 0.01 0.005);" in sampling,
            "end (0.5 0.99 0.005);" in sampling,
            "start (0.01 0.5 0.005);" in sampling,
            "end (0.99 0.5 0.005);" in sampling,
            sampling.count("nPoints 99;") == 2,
        )
    )


def check() -> bool:
    required = (
        ROOT / "build_case.py",
        ROOT / "postprocess.py",
        ROOT / "summary.txt",
        ROOT / "vertical_centerline.csv",
        ROOT / "horizontal_centerline.csv",
        CASE / "log.blockMesh",
        CASE / "log.checkMesh",
        CASE / "log.icoFoam",
        CASE / "log.sample",
        CASE / "30/U",
        CASE / "30/p",
    )
    if any(not path.is_file() or path.stat().st_size == 0 for path in required):
        return False
    mesh_log = read(CASE / "log.checkMesh")
    solve_log = read(CASE / "log.icoFoam")
    if not (
        log_finished(CASE / "log.blockMesh")
        and log_finished(CASE / "log.sample")
        and "Mesh OK." in mesh_log
        and log_finished(CASE / "log.checkMesh")
        and "Time = 30" in solve_log
        and log_finished(CASE / "log.icoFoam")
    ):
        return False
    mesh_check = subprocess.run(
        [
            "bash",
            "--noprofile",
            "--norc",
            "-c",
            "trap - CHLD; . /opt/openfoam11/etc/bashrc && checkMesh -case /home/user/Desktop/cavity_graph",
        ],
        stdout=subprocess.PIPE,
        stderr=subprocess.STDOUT,
        text=True,
        timeout=120,
    )
    if mesh_check.returncode != 0 or "Mesh OK." not in mesh_check.stdout or not check_case():
        return False
    sampler = subprocess.run(
        [
            "bash",
            "--noprofile",
            "--norc",
            "-c",
            "trap - CHLD; . /opt/openfoam11/etc/bashrc && postProcess -case /home/user/Desktop/cavity_graph -func sampleDict -latestTime",
        ],
        stdout=subprocess.PIPE,
        stderr=subprocess.STDOUT,
        text=True,
        timeout=120,
    )
    if (
        sampler.returncode != 0
        or "FOAM FATAL" in sampler.stdout
        or not sampler.stdout.rstrip().endswith("End")
    ):
        return False

    velocity = field(CASE / "30/U", "vector")
    pressure = field(CASE / "30/p", "scalar")
    if not (
        len(velocity) == len(pressure) == 4096
        and max(math.sqrt(sum(component**2 for component in value)) for value in velocity) > 0.5
        and max(pressure) - min(pressure) > 0.1
    ):
        return False

    vertical = profile(SAMPLES / "vertical.xy")
    horizontal = profile(SAMPLES / "horizontal.xy")
    stored_vertical = csv_profile(ROOT / "vertical_centerline.csv", ("y_m", "ux_mps", "uy_mps"))
    stored_horizontal = csv_profile(ROOT / "horizontal_centerline.csv", ("x_m", "ux_mps", "uy_mps"))
    for stored, actual in ((stored_vertical, vertical), (stored_horizontal, horizontal)):
        if any(any(abs(left - right) > 5e-7 for left, right in zip(row, expected)) for row, expected in zip(stored, actual)):
            return False

    ux_center = next(row[1] for row in vertical if abs(row[0] - 0.5) < 1e-9)
    uy_center = next(row[2] for row in horizontal if abs(row[0] - 0.5) < 1e-9)
    profile_speed = max(
        math.hypot(row[1], row[2])
        for row in vertical + horizontal
    )
    if not (-0.5 < ux_center < -0.02 and 0.005 < uy_center < 0.3 and profile_speed > 0.1):
        return False
    lines = [line.strip() for line in read(ROOT / "summary.txt").splitlines() if line.strip()]
    if len(lines) != 1:
        return False
    parts = [float(value.strip()) for value in lines[0].split(",")]
    return len(parts) == 2 and all(math.isfinite(value) for value in parts) and all(
        abs(value - expected) <= 5e-7 for value, expected in zip(parts, (ux_center, uy_center))
    )


def main() -> int:
    try:
        result = check()
    except Exception:
        result = False
    print("True" if result else "False")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())