"""
概要:
    Brent法を使用して1次元シュレディンガー方程式の固有値を精密化するスクリプトです。

詳細説明:
    シュレディンガー方程式の解から境界条件を満たすかどうかを評価し、
    Brent法を用いて目的の固有値を高精度に探索します。

関連リンク:
    refineE_schrodinger1d_usage
"""

import os
import argparse
import numpy as np
from scipy.optimize import brentq
from schrodinger1d import solve_schrodinger

# ----------------------------------------
# residual(E): ψ(L) を返す関数
# ----------------------------------------
def residual(E, args, print_level = 0):
    """
    概要:
        指定されたエネルギーEに対する終端位置での波動関数の値 psi(L) を計算して返します。

    詳細説明:
        schrodinger1d.solve_schrodinger を呼び出して計算を実行します。
        print_level がゼロより大きい場合は進行状況を標準出力に出力します。

    引数:
        :param E: 評価するエネルギー値
        :type E: float
        :param args: コマンドライン引数を格納したNamespace
        :type args: argparse.Namespace
        :param print_level: ログ出力のレベル、デフォルトは 0
        :type print_level: int

    戻り値:
        :returns: 位置 L における波動関数の値
        :rtype: float
    """
    x, psi, info = solve_schrodinger(
        E=E,
        L=args.L,
        nx=args.nx,
        psi_max=args.psi_max,
        report_step=0,
        bc=args.bc,
        eps=args.eps
    )
    
    if print_level:
        print(f"E={E:12.8g}  psi(L)={psi[-1]:14.6e}")

    return psi[-1]  # ψ(L)


# ----------------------------------------
# 初期値 E0 から符号反転区間を自動探索
# ----------------------------------------
def find_bracket(E0, args, max_expand=20, direction='both'):
    """
    概要:
        初期のエネルギー値付近で波動関数の終端値の符号が反転する区間を探索します。

    詳細説明:
        探索方向の指定に基づき、徐々に探索幅を広げながら符号反転区間を探します。

    引数:
        :param E0: 探索を開始する初期エネルギー値
        :type E0: float
        :param args: コマンドライン引数を格納したNamespace
        :type args: argparse.Namespace
        :param max_expand: 区間を拡大する最大回数、デフォルトは 20
        :type max_expand: int
        :param direction: 探索方向を upper、lower、both のいずれかで指定、デフォルトは both
        :type direction: str

    戻り値:
        :returns: 符号反転が確認されたエネルギーの下限と上限のタプル
        :rtype: tuple

    例外:
        :raises ValueError: directionに不正な値が指定された場合
        :raises RuntimeError: 符号反転区間が見つからなかった場合
    """
    delta = 0.05 * abs(E0) + 0.01

    # 初期値の符号
    f0 = residual(E0, args)

    for _ in range(max_expand):

        if direction == 'upper':
            E_low  = E0
            E_high = E0 + delta

        elif direction == 'lower':
            E_low  = E0 - delta
            E_high = E0

        elif direction == 'both':
            E_low  = E0 - delta
            E_high = E0 + delta

        else:
            raise ValueError("direction must be 'upper', 'lower', or 'both'")

        f_low  = residual(E_low, args)
        f_high = residual(E_high, args)

        if f_low * f_high < 0:
            print(f"[INFO] Found bracket: [{E_low}, {E_high}]")
            return E_low, E_high

        delta *= 2

    raise RuntimeError("Could not find sign change interval.")

# ----------------------------------------
# Brent 法の maxiter を自動計算
# ----------------------------------------
def compute_maxiter(E_low, E_high, E_tol):
    """
    概要:
        Brent法の最大反復回数を区間幅と許容誤差から自動的に計算します。

    引数:
        :param E_low: 探索区間の下限エネルギー値
        :type E_low: float
        :param E_high: 探索区間の上限エネルギー値
        :type E_high: float
        :param E_tol: 目標とするエネルギー値の許容誤差
        :type E_tol: float

    戻り値:
        :returns: 計算された最大反復回数
        :rtype: int
    """
    width = abs(E_high - E_low)
    return int(np.ceil(np.log2(width / E_tol))) + 5


# ----------------------------------------
# main
# ----------------------------------------
def main():
    """
    概要:
        コマンドライン引数を解析し、Brent法による固有値の精密化処理を実行します。

    詳細説明:
        初期値から符号反転区間を探索し、Brent法を用いて固有値を計算します。
        計算結果は標準出力に表示されるとともに、refineE.csv ファイルに追記されます。
    """
    parser = argparse.ArgumentParser(
        description="Refine eigenvalue using Brent method"
    )

    parser.add_argument("--E", type=float, required=True,
                        help="Initial guess for eigenvalue")
    parser.add_argument("--E_tol", type=float, default=1e-6,
                        help="Target precision for eigenvalue")
    parser.add_argument("--maxiter", type=int, default=None,
                        help="Max iterations for Brent method (optional)")

    # schrodinger1d.py と同じ引数を流用
    parser.add_argument("--L", type=float, default=10.0)
    parser.add_argument("--nx", type=int, default=2000)
    parser.add_argument("--psi_max", type=float, default=1e10)
    parser.add_argument("--bc", choices=["asymptotic", "zero"], default="asymptotic")
    parser.add_argument("--eps", type=float, default=1e-6)

    args = parser.parse_args()

    # 1. 初期値 E0 から符号反転区間を探す
    E_low, E_high = find_bracket(args.E, args, direction = 'upper')

    # 2. maxiter を自動設定
    if args.maxiter is None:
        args.maxiter = compute_maxiter(E_low, E_high, args.E_tol)
        print(f"[INFO] maxiter set to {args.maxiter}")

    # 3. Brent 法で固有値を精密化
    E_root, result = brentq(
        lambda E: residual(E, args, print_level=1),
        E_low, E_high,
        xtol=args.E_tol,
        maxiter=args.maxiter,
        full_output=True
    )

    print("====================================")
    print(" Refined eigenvalue:")
    print(f"   E = {E_root:.12f}")
    print("====================================")
    
    # f_low, f_high を計算
    f_low  = residual(E_low, args)
    f_high = residual(E_high, args)

    log_csv = "refineE.csv"
    print()
    if not os.path.exists(log_csv):
        print(f"{log_csv} does not exist. Add header labels.")
        with open(log_csv, "a") as fp:
            fp.write("E0, E_low, E_high, E_root, f_low, f_high, iterations, funcalls\n")

    print(f"Append the result to {log_csv}")
    with open(log_csv, "a") as fp:
        fp.write(
            f"{args.E},"
            f"{E_low},{E_high},"
            f"{E_root},"
            f"{f_low},{f_high},"
            f"{result.iterations},{result.function_calls}\n"
        )


if __name__ == "__main__":
    main()