"""refactored版を基準に、指定プログラムの計算結果を比較する。

実行例:
    python test_vdPauw_compare.py vdPauw_verbose.py
    python test_vdPauw_compare.py vdPauw_verbose.py --rtol 1e-8

基準ファイルvdPauw_refactored.pyは、このテストと同じフォルダーに置く。
対象の仕様: vdp_factor(r)、calculate_factors(r_values)
対象をimportして実行するので、信頼できるプログラムだけを指定する。
"""

import argparse
import importlib.util
from pathlib import Path
import sys

import numpy as np


def load_module(path, name):
    """パスを指定してモジュールを読み込む。実行ガード内のmainは動かない。"""
    path = Path(path).resolve()
    spec = importlib.util.spec_from_file_location(name, path)
    if spec is None or spec.loader is None:
        raise ImportError(f"モジュールを読み込めません: {path}")
    module = importlib.util.module_from_spec(spec)
    sys.modules[name] = module
    spec.loader.exec_module(module)
    return module


def compare_results(reference, target, r_values, *, rtol, atol):
    """スカラー関数と配列関数を比較し、不一致ならAssertionErrorを送出する。"""
    for name in ("vdp_factor", "calculate_factors"):
        if not callable(getattr(target, name, None)):
            raise AssertionError(f"対象に必要な関数がありません: {name}")

    for name in ("vdp_factor", "calculate_factors"):
        if name == "vdp_factor":
            expected = np.array([reference.vdp_factor(r) for r in r_values])
            actual = np.array([target.vdp_factor(r) for r in r_values])
        else:
            # 一方の関数が入力を書き換えても、他方の入力に影響させない。
            expected = np.asarray(reference.calculate_factors(r_values.copy()))
            actual = np.asarray(target.calculate_factors(r_values.copy()))
        if actual.shape != expected.shape:
            raise AssertionError(f"{name}: 配列形状が不一致 "
                                 f"{actual.shape} != {expected.shape}")
        if not (np.isfinite(expected).all() and np.isfinite(actual).all()):
            raise AssertionError(f"{name}: NaNまたは無限大を検出しました")
        abs_diff = np.abs(actual - expected)
        relative_diff = abs_diff / np.maximum(np.abs(expected), np.finfo(float).tiny)
        worst = int(np.argmax(relative_diff))
        print(f"{name}: 最大絶対差={np.max(abs_diff):.3e}, "
              f"最大相対差={relative_diff[worst]:.3e} (R={r_values[worst]:.6g})",
              flush=True)
        np.testing.assert_allclose(actual, expected, rtol=rtol, atol=atol,
                                   equal_nan=False, err_msg=f"{name}: 基準と不一致")
        print(f"  PASS: {len(r_values)}点が許容誤差内で一致", flush=True)


def initialize(argv=None):
    parser = argparse.ArgumentParser(description=__doc__,
                                    formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument("program", type=Path, help="比較対象のPythonプログラム")
    parser.add_argument("--min_R", type=float, default=1e-8)
    parser.add_argument("--max_R", type=float, default=1e8)
    parser.add_argument("--npoints", type=int, default=161)
    parser.add_argument("--rtol", type=float, default=1e-8)
    parser.add_argument("--atol", type=float, default=1e-12)
    args = parser.parse_args(argv)
    if not (np.isfinite(args.min_R) and np.isfinite(args.max_R)
            and 0 < args.min_R < args.max_R and args.npoints >= 2):
        parser.error("有限の0 < min_R < max_R、npoints >= 2が必要です")
    if not (np.isfinite(args.rtol) and np.isfinite(args.atol)
            and args.rtol >= 0 and args.atol >= 0):
        parser.error("rtolとatolは有限の非負値にしてください")
    return args


def main(argv=None):
    args = initialize(argv)
    reference_path = Path(__file__).resolve().with_name("vdPauw_refactored.py")
    print(f"基準: {reference_path}", flush=True)
    print(f"対象: {args.program.resolve()}", flush=True)
    print(f"設定: min_R={args.min_R:g}, max_R={args.max_R:g}, "
          f"npoints={args.npoints}, rtol={args.rtol:g}, atol={args.atol:g}", flush=True)
    reference = load_module(reference_path, "_vdp_reference")
    target = load_module(args.program, "_vdp_target")
    r_values = np.geomspace(args.min_R, args.max_R, args.npoints)
    compare_results(reference, target, r_values, rtol=args.rtol, atol=args.atol)
    print("全比較に合格しました。")


if __name__ == "__main__":
    main()
