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

import math
import re
from pathlib import Path


ROOT = Path("/home/user/Desktop")
RPMS = (6, 9, 12, 15)
AIR_DENSITY = 1.225
ROTOR_RADIUS_M = 63.0
WIND_SPEED_MPS = 8.0
EXPECTED_CP = (0.347895, 0.447509, 0.397957, 0.296552)
ABS_TOL = 2e-5
REL_TOL = 5e-4


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


def close(actual: float, expected: float) -> bool:
    return math.isfinite(actual) and abs(actual - expected) <= max(
        ABS_TOL, REL_TOL * max(1.0, abs(expected))
    )


def parameter(text: str, name: str) -> str:
    match = re.search(rf"^\s*(\S+).*?\s{name}\s+-", text, re.MULTILINE)
    if not match:
        raise ValueError(f"missing parameter {name}")
    return match.group(1).strip('"').rstrip(",")


def read_channel_mean(path: Path, channel: str, window_s: float) -> tuple[float, float]:
    lines = read(path).splitlines()
    if "at commit v5.0.0" not in "\n".join(lines[:5]):
        raise ValueError("output was not generated by OpenFAST 5.0.0")
    header_index = next(
        index for index, line in enumerate(lines) if line.split() and line.split()[0] == "Time"
    )
    headers = lines[header_index].split()
    units = lines[header_index + 1].split()
    channel_index = headers.index(channel)
    if len(units) != len(headers) or units[channel_index] != "(W)":
        raise ValueError(f"{channel} must be reported in watts")
    rows: list[tuple[float, float]] = []
    for line in lines[header_index + 2 :]:
        values = line.split()
        if len(values) != len(headers):
            continue
        try:
            rows.append((float(values[0]), float(values[channel_index])))
        except ValueError:
            continue
    if not rows or not close(rows[-1][0], 30.0):
        raise ValueError("incomplete 30-second output")
    start = rows[-1][0] - window_s
    selected = [value for time, value in rows if time >= start]
    if len(selected) < 90:
        raise ValueError("insufficient samples in final averaging window")
    return sum(selected) / len(selected), rows[-1][0]


def parse_summary(path: Path) -> list[tuple[float, float, float]]:
    rows: list[tuple[float, float, float]] = []
    for line in read(path).splitlines():
        if not line.strip():
            continue
        values = [float(value.strip()) for value in line.split(",")]
        if len(values) != 3:
            raise ValueError("summary rows must contain rpm, tsr, cp")
        rows.append((values[0], values[1], values[2]))
    if len(rows) != len(RPMS):
        raise ValueError("summary must contain four rows")
    return rows


def valid_inputs(rpm: int) -> bool:
    fst = read(ROOT / f"case_rpm{rpm}.fst")
    ed = read(ROOT / f"elasto_rpm{rpm}.dat")
    expected = {
        "TMax": "30",
        "DT_Out": "0.1",
        "OutFileFmt": "1",
        "CompInflow": "1",
        "CompAero": "2",
        "CompServo": "0",
        "EDFile": f"elasto_rpm{rpm}.dat",
        "InflowFile": "5MW_Baseline/NRELOffshrBsline5MW_InflowWind_Steady8mps.dat",
        "AeroFile": "aerodyn_tsr.dat",
    }
    if any(parameter(fst, key) != value for key, value in expected.items()):
        return False
    return (
        parameter(ed, "GenDOF").lower() == "false"
        and close(float(parameter(ed, "RotSpeed")), float(rpm))
    )


def check() -> bool:
    required = ["run_sweep.py", "postprocess.py", "aerodyn_tsr.dat", "summary.txt"]
    for rpm in RPMS:
        required.extend(
            (
                f"elasto_rpm{rpm}.dat",
                f"case_rpm{rpm}.fst",
                f"case_rpm{rpm}.out",
                f"case_rpm{rpm}.log",
            )
        )
    if any(not (ROOT / name).is_file() or (ROOT / name).stat().st_size == 0 for name in required):
        return False

    aero = read(ROOT / "aerodyn_tsr.dat")
    if '"RtAeroPwr"' not in aero or '"../5MW_Baseline/' in aero:
        return False
    if any(not valid_inputs(rpm) for rpm in RPMS):
        return False

    available_power_w = (
        0.5 * AIR_DENSITY * math.pi * ROTOR_RADIUS_M**2 * WIND_SPEED_MPS**3
    )
    calculated: list[tuple[float, float, float]] = []
    for rpm in RPMS:
        if "OpenFAST terminated normally." not in read(ROOT / f"case_rpm{rpm}.log"):
            return False
        aero_power_w, _ = read_channel_mean(ROOT / f"case_rpm{rpm}.out", "RtAeroPwr", 10.0)
        tsr = (rpm * 2.0 * math.pi / 60.0) * ROTOR_RADIUS_M / WIND_SPEED_MPS
        calculated.append((float(rpm), tsr, aero_power_w / available_power_w))

    reported = parse_summary(ROOT / "summary.txt")
    for index, rpm in enumerate(RPMS):
        expected = (float(rpm), calculated[index][1], EXPECTED_CP[index])
        if any(not close(value, target) for value, target in zip(calculated[index], expected)):
            return False
        if any(not close(value, target) for value, target in zip(reported[index], expected)):
            return False
    return True


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


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