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

import math
import re
from pathlib import Path


ROOT = Path("/home/user/Desktop")
EXPECTED = (4755.905895, 2868.318485, 0.2)
REL_TOL = 2e-3
ABS_TOL = 2e-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{re.escape(name)}\s+-", text, re.MULTILINE)
    if not match:
        raise ValueError(f"missing parameter {name}")
    return match.group(1).strip('"').rstrip(",")


def read_output(path: Path) -> tuple[list[str], list[str], list[list[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(i for i, line in enumerate(lines) if line.split()[:1] == ["Time"])
    headers = lines[header_index].split()
    units = lines[header_index + 1].split()
    rows: list[list[float]] = []
    for line in lines[header_index + 2 :]:
        fields = line.split()
        if len(fields) != len(headers):
            continue
        try:
            rows.append([float(value) for value in fields])
        except ValueError:
            continue
    if not rows or not close(rows[-1][headers.index("Time")], 60.0):
        raise ValueError("incomplete 60-second output")
    return headers, units, rows


def calculate(path: Path) -> tuple[float, float, float]:
    headers, units, rows = read_output(path)
    names = ("Time", "BldPitch1", "BldPitch2", "BldPitch3", "GenPwr")
    indexes = {name: headers.index(name) for name in names}
    if units[indexes["Time"]] != "(s)" or units[indexes["GenPwr"]] != "(kW)":
        raise ValueError("unexpected channel units")

    pre_rows = [row for row in rows if 20.0 <= row[indexes["Time"]] < 30.0]
    post_rows = [row for row in rows if 40.0 <= row[indexes["Time"]] <= 50.0]
    if len(pre_rows) < 90 or len(post_rows) < 90:
        raise ValueError("insufficient averaging samples")
    pre_power = sum(row[indexes["GenPwr"]] for row in pre_rows) / len(pre_rows)
    post_power = sum(row[indexes["GenPwr"]] for row in post_rows) / len(post_rows)
    pre_pitch = sum(
        sum(row[indexes[name]] for name in names[1:4]) / 3.0 for row in pre_rows
    ) / len(pre_rows)
    low = pre_pitch + 0.1 * (10.0 - pre_pitch)
    high = pre_pitch + 0.9 * (10.0 - pre_pitch)
    maneuver = [
        (
            row[indexes["Time"]],
            sum(row[indexes[name]] for name in names[1:4]) / 3.0,
        )
        for row in rows
        if row[indexes["Time"]] >= 30.0
    ]
    t10 = next(time for time, pitch in maneuver if pitch >= low)
    t90 = next(time for time, pitch in maneuver if pitch >= high)
    if any(not close(maneuver[-1][1], 10.0) for _ in (0,)):
        raise ValueError("final collective pitch is not 10 degrees")
    return pre_power, post_power, t90 - t10


def parse_summary(path: Path) -> tuple[float, float, float]:
    rows = [line.strip() for line in read(path).splitlines() if line.strip()]
    if len(rows) != 1:
        raise ValueError("summary must contain one row")
    values = tuple(float(value.strip()) for value in rows[0].split(","))
    if len(values) != 3:
        raise ValueError("summary must contain three values")
    return values


def check() -> bool:
    required = (
        "build_case.py",
        "postprocess.py",
        "servo_step.dat",
        "elasto_step.dat",
        "aero_step.dat",
        "case.fst",
        "case.out",
        "case.log",
        "summary.txt",
    )
    if any(not (ROOT / name).is_file() or (ROOT / name).stat().st_size == 0 for name in required):
        return False
    if "OpenFAST terminated normally." not in read(ROOT / "case.log"):
        return False

    servo = read(ROOT / "servo_step.dat")
    for blade in (1, 2, 3):
        for name, expected in (
            (f"TPitManS({blade})", 30.0),
            (f"PitManRat({blade})", 10.0),
            (f"BlPitchF({blade})", 10.0),
        ):
            if not close(float(parameter(servo, name)), expected):
                return False
    fst = read(ROOT / "case.fst")
    expected_main = {
        "TMax": "60.0",
        "DT_Out": "0.1",
        "OutFileFmt": "1",
        "EDFile": "elasto_step.dat",
        "AeroFile": "aero_step.dat",
        "ServoFile": "servo_step.dat",
    }
    if any(parameter(fst, name) != value for name, value in expected_main.items()):
        return False
    elasto = read(ROOT / "elasto_step.dat")
    if any(f'"BldPitch{blade}"' not in elasto for blade in (1, 2, 3)):
        return False
    if '"../5MW_Baseline/' in elasto or '"../5MW_Baseline/' in read(ROOT / "aero_step.dat"):
        return False

    calculated = calculate(ROOT / "case.out")
    reported = parse_summary(ROOT / "summary.txt")
    return all(close(a, e) for a, e in zip(calculated, EXPECTED)) and all(
        close(a, e) for a, e in zip(reported, EXPECTED)
    )


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


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