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

import math
import os
import re
import struct
from pathlib import Path


FLOAT_RE = re.compile(r"(?<![A-Za-z0-9_])[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?(?![A-Za-z0-9_])")
REL_TOL = 1e-2
ABS_TOL = 1e-4
REQUIRED_FILES = ['summary.txt', 'postprocess.py', 'wind_8ms.inp', 'wind_8ms.bts', 'turbsim.log',
                  'case_turb.fst', 'inflow_turb_base.dat', 'case_turb.out', 'openfast.log']
EXPECTED_ROWS = [[1970.977618, 475.357979]]
SUMMARY_FILE = 'summary.txt'


def parse_floats(text: str) -> list[float]:
    values: list[float] = []
    for token in FLOAT_RE.findall(text):
        try:
            values.append(float(token))
        except ValueError:
            continue
    return values


def parse_numeric_rows(path: Path) -> list[list[float]]:
    rows: list[list[float]] = []
    for raw in path.read_text(encoding='utf-8', errors='ignore').splitlines():
        line = raw.strip()
        if (not line) or line.startswith('#'):
            continue
        vals = parse_floats(line)
        if vals:
            rows.append(vals)
    return rows


def file_ok(path: Path) -> bool:
    return path.exists() and path.is_file() and path.stat().st_size > 0


def close_enough(actual: float, expected: float) -> bool:
    return abs(actual - expected) <= max(ABS_TOL, REL_TOL * max(1.0, abs(expected)))


def keyed_value(text: str, key: str) -> str:
    for line in text.splitlines():
        parts = line.split()
        if len(parts) >= 2 and parts[1] == key:
            return parts[0].strip('"')
    raise KeyError(key)


def bts_ok(path: Path) -> bool:
    header = path.read_bytes()[:42]
    if len(header) != 42:
        return False
    _, nz, ny, _, nt, _, _, dt, uhub, zhub, _ = struct.unpack('<h4i6f', header)
    return nz == 31 and ny == 31 and nt >= 1200 and abs(dt - 0.05) < 1e-4 and abs(uhub - 8.0) < 0.05 and abs(zhub - 90.0) < 0.05


def output_stats(path: Path) -> tuple[float, float]:
    lines = path.read_text(encoding='utf-8', errors='ignore').splitlines()
    header = next(i for i, line in enumerate(lines) if line.split() and line.split()[0] == 'Time')
    names = lines[header].split()
    time_i, power_i = names.index('Time'), names.index('GenPwr')
    rows = [[float(value) for value in line.split()] for line in lines[header + 2:] if line.split()]
    if not rows or rows[-1][time_i] < 59.9:
        raise ValueError('incomplete OpenFAST output')
    power = [row[power_i] for row in rows]
    mean = sum(power) / len(power)
    return mean, math.sqrt(sum((value - mean) ** 2 for value in power) / len(power))


def check_task(root: Path) -> bool:
    for rel in REQUIRED_FILES:
        if not file_ok(root / rel):
            return False

    actual = parse_numeric_rows(root / SUMMARY_FILE)
    if len(actual) != len(EXPECTED_ROWS):
        return False

    for row_a, row_e in zip(actual, EXPECTED_ROWS):
        if len(row_a) != len(row_e):
            return False
        for a, e in zip(row_a, row_e):
            if not close_enough(a, e):
                return False

    ts = (root / 'wind_8ms.inp').read_text(encoding='utf-8', errors='ignore')
    if keyed_value(ts, 'IECturbc') != 'B' or float(keyed_value(ts, 'RefHt')) != 90 or float(keyed_value(ts, 'URef')) != 8:
        return False
    inflow = (root / 'inflow_turb_base.dat').read_text(encoding='utf-8', errors='ignore')
    if float(keyed_value(inflow, 'WindType')) != 3 or keyed_value(inflow, 'FileName_BTS') != 'wind_8ms.bts':
        return False
    if not bts_ok(root / 'wind_8ms.bts'):
        return False
    if 'OpenFAST terminated normally' not in (root / 'openfast.log').read_text(errors='ignore'):
        return False
    if 'TurbSim terminated normally' not in (root / 'turbsim.log').read_text(errors='ignore'):
        return False
    mean, std = output_stats(root / 'case_turb.out')
    if not close_enough(mean, actual[0][0]) or not close_enough(std, actual[0][1]):
        return False

    return True


def evaluate() -> int:
    root = Path(os.environ.get('EVAL_OUTPUT_ROOT', '/home/user/Desktop'))
    try:
        ok = check_task(root)
    except Exception:
        ok = False
    return 1 if ok else 0


def main() -> int:
    result = evaluate()
    print('True' if result == 1 else 'False')
    return 0


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