#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
概要:
    エッジケースや極端な条件を含むフェルミ・ディラック積分（非正規化）のテストとベンチマークを行います。
詳細説明:
    Fj(j, eta) = 積分(0から無限大) x^j * f(eta - x) dx をテストします。
    ここで f(z) = 1/(1+exp(-z)) = expit(z) です。
    j = -1 の場合、積分形式は x が 0 に近づくにつれ発散するため、解析的な同一性を利用します。
    F0(eta) = 積分(0から無限大) f(eta-x) dx = log(1+exp(eta)) となり、
    これを eta で微分すると expit(eta) になります。
    そのため、再帰関係の dFj/deta = Fj-1 との整合性から Fj(-1, eta) は expit(eta) と定義します。
    他の j > -1 については、保守的な有限の上限を用いた数値積分 quad を使用します。
    また、eta が非常に小さい非縮退の極限、T=0K のステップ極限、eta が非常に大きい縮退の極限である
    ゾンマーフェルト展開などとの比較も実装しています。
"""

import time
import math
import numpy as np
from scipy.special import expit, log1p, gamma
from scipy.integrate import quad

from tkfermi_integral import FermiIntegral_fast


# ============================================================
# Core implementations
# ============================================================
def _upper_bound(eta: float) -> float:
    """
    概要:
        数値積分 quad のためのヒューリスティックな有限の上限値を計算します。
    詳細説明:
        大きな正の eta に対して被積分関数は x が eta より小さいときに x^j に比例するため、
        上限値は eta を超える必要があります。また、大きな x に対しては占有確率が exp(eta-x) 
        のように減衰するため、倍精度計算では余裕を持たせた値を上限として使用します。
    引数:
        :param eta: フェルミ準位に関連する無次元パラメータ
        :type eta: float
    戻り値:
        :returns: 積分計算のための上限値
        :rtype: float
    """
    return float(max(eta + 60.0, 120.0))


def Fj_expit(j: float, eta: float) -> float:
    """
    概要:
        被積分関数に expit を用いて quad による数値積分を行います。
    詳細説明:
        j が -1 の場合は例外的に解析値 expit(eta) を返します。
        j が -1 未満の場合はサポート外として例外を発生させます。
    引数:
        :param j: 積分の次数
        :type j: float
        :param eta: フェルミ準位に関連する無次元パラメータ
        :type eta: float
    戻り値:
        :returns: 積分の計算結果
        :rtype: float
    例外:
        :raises ValueError: j が -1 未満の場合
    """
    if j == -1:
        return float(expit(eta))
    if j <= -1:
        raise ValueError("This implementation supports j > -1, except j=-1 (handled analytically).")

    upper = _upper_bound(eta)
    integrand = lambda x: (x ** j) * expit(eta - x)
    res, _ = quad(integrand, 0.0, upper, epsabs=1e-12, epsrel=1e-12, limit=200)
    return float(res)


def Fj_raw(j: float, eta: float) -> float:
    """
    概要:
        被積分関数に生の exp を用いて quad による数値積分を行います。
    詳細説明:
        j が -1 の場合は例外的に解析値 expit(eta) を返します。
        j が -1 未満の場合はサポート外として例外を発生させます。
    引数:
        :param j: 積分の次数
        :type j: float
        :param eta: フェルミ準位に関連する無次元パラメータ
        :type eta: float
    戻り値:
        :returns: 積分の計算結果
        :rtype: float
    例外:
        :raises ValueError: j が -1 未満の場合
    """
    if j == -1:
        # d/deta log(1+exp(eta)) = expit(eta)
        return float(expit(eta))
    if j <= -1:
        raise ValueError("This implementation supports j > -1, except j=-1 (handled analytically).")

    upper = _upper_bound(eta)
    integrand = lambda x: (x ** j) / (1.0 + np.exp(x - eta))
    res, _ = quad(integrand, 0.0, upper, epsabs=1e-12, epsrel=1e-12, limit=200)
    return float(res)


def Fj_fast(j: float, eta: float):
    """
    概要:
        高速実装版のフェルミ・ディラック積分を呼び出すラッパー関数です。
    詳細説明:
        内部で FermiIntegral_fast を呼び出します。未対応の場合やエラーが発生した場合は None を返します。
    引数:
        :param j: 積分の次数
        :type j: float
        :param eta: フェルミ準位に関連する無次元パラメータ
        :type eta: float
    戻り値:
        :returns: 積分の計算結果、または計算できない場合は None
        :rtype: float または None
    """
    try:
        return float(FermiIntegral_fast(eta, j))
    except Exception:
        return None


# ============================================================
# Asymptotic / limit reference checks
# ============================================================
def Fj_nondegenerate_approx(j: float, eta: float) -> float:
    """
    概要:
        eta が非常に小さい負の値をとる場合の非縮退近似値を計算します。
    詳細説明:
        eta が十分小さいとき、Fj は exp(eta) と ガンマ関数(j+1) の積で近似できます。
        j が -1 の場合は exp(eta) を返します。
    引数:
        :param j: 積分の次数
        :type j: float
        :param eta: フェルミ準位に関連する無次元パラメータ
        :type eta: float
    戻り値:
        :returns: 非縮退近似による計算結果
        :rtype: float
    """
    if j == -1:
        # expit(eta) ~ exp(eta) for eta<<0
        return float(np.exp(eta))
    return float(np.exp(eta) * gamma(j + 1.0))


def Fj_0K_step(j: float, eta: float) -> float:
    """
    概要:
        絶対零度への極限におけるステップ関数の積分結果を計算します。
    詳細説明:
        eta が正の場合は eta の j+1 乗を j+1 で割った値を返します。
        j が -1 の場合はステップ関数の極限として eta が 0 より大きいときに 1.0 を返します。
    引数:
        :param j: 積分の次数
        :type j: float
        :param eta: フェルミ準位に関連する無次元パラメータ
        :type eta: float
    戻り値:
        :returns: 0K極限における計算結果
        :rtype: float
    """
    if j == -1:
        return float(1.0 if eta > 0 else 0.0)
    if eta <= 0:
        return 0.0
    return float((eta ** (j + 1.0)) / (j + 1.0))


def Fj_sommerfeld(j: float, eta: float) -> float:
    """
    概要:
        eta が十分大きい正の値をとる場合のゾンマーフェルト展開による近似値を計算します。
    詳細説明:
        j が -1 の場合は 1.0 を返します。eta が 0 以下の場合は 0K極限の結果をそのまま返します。
        それ以外の場合は、円周率の2乗や4乗の項を含む展開式を用いて高精度の近似値を計算します。
    引数:
        :param j: 積分の次数
        :type j: float
        :param eta: フェルミ準位に関連する無次元パラメータ
        :type eta: float
    戻り値:
        :returns: ゾンマーフェルト展開による近似結果
        :rtype: float
    """
    if j == -1:
        # expit(eta) -> 1 for eta>>1
        return 1.0
    if eta <= 0:
        # not a good regime; still return 0K limit
        return Fj_0K_step(j, eta)

    term0 = (eta ** (j + 1.0)) / (j + 1.0)
    term2 = (math.pi**2 / 6.0) * j * (eta ** (j - 1.0)) if j > 0 else 0.0

    # π^4 term requires j-3 power; for small j this diverges / is meaningless.
    if j > 2.0:
        term4 = (7.0 * math.pi**4 / 360.0) * j * (j - 1.0) * (j - 2.0) * (eta ** (j - 3.0))
    else:
        term4 = 0.0

    return float(term0 + term2 + term4)


# ============================================================
# Test helpers
# ============================================================
def rel_err(a: float, b: float, tiny: float = 1e-300) -> float:
    """
    概要:
        2つの値の間の相対誤差を計算します。
    詳細説明:
        ゼロ除算を防ぐために tiny の値を使用して分母の最小値を制限し、安全に誤差を評価します。
    引数:
        :param a: 比較する最初の値
        :type a: float
        :param b: 比較する基準となる値
        :type b: float
        :param tiny: 分母の下限となる微小値
        :type tiny: float
    戻り値:
        :returns: 計算された相対誤差
        :rtype: float
    """
    return abs(a - b) / max(abs(b), tiny)


def print_header(title: str):
    """
    概要:
        指定されたタイトルをコンソールに整形して出力します。
    詳細説明:
        前後に区切り線を入れて見やすく表示するための補助関数です。
    引数:
        :param title: 出力するタイトル文字列
        :type title: str
    戻り値:
        :returns: なし
        :rtype: None
    """
    print("\n" + "=" * 78)
    print(title)
    print("=" * 78)


# ============================================================
# Main tests
# ============================================================
def main():
    """
    概要:
        フェルミ・ディラック積分の各種テストとベンチマークを実行するメイン関数です。
    詳細説明:
        数値積分、高速実装、非縮退近似、0K極限、ゾンマーフェルト展開の各結果を比較検証し、
        さらに計算時間のベンチマークと極端な eta での健全性チェックを行います。
    引数:
        なし
    戻り値:
        :returns: なし
        :rtype: None
    """
    # Requested j list including -1
    j_values = [-1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0]

    # Baseline sweep
    eta_values = np.array([-20, -10, -5, -2, -1, -0.1, 0.0, 0.1, 1, 2, 5, 10, 20], dtype=float)

    # Extreme / edge cases
    eta_extreme = np.array([-100, -50, -40, 40, 50, 100], dtype=float)

    # Tolerance for cross-implementation numeric agreement (quad expit vs quad raw)
    tol_abs = 1e-10

    print_header("A) Consistency check: quad(expit) vs quad(raw) vs fast (if available)")
    print(f"abs diff tolerance (quad vs quad): {tol_abs:g}")
    print("-" * 78)
    print("   j      eta        quad_expit         quad_raw        |diff|        fast          status")
    print("-" * 78)

    for j in j_values:
        for eta in eta_values:
            v1 = Fj_expit(j, float(eta))
            v2 = Fj_raw(j, float(eta))
            d12 = abs(v1 - v2)

            v3 = Fj_fast(j, float(eta))
            if v3 is None:
                status = "PASS" if d12 < tol_abs else "FAIL"
                v3s = "  (n/a)"
            else:
                d13 = abs(v1 - v3)
                status = "PASS" if (d12 < tol_abs and d13 < tol_abs) else "FAIL"
                v3s = f"{v3: .6e}"

            print(f"{j:6.1f}  {eta:8.2f}  {v1: .6e}  {v2: .6e}  {d12: .2e}  {v3s:>12}   {status}")
        print("-" * 78)

    # ------------------------------------------------------------
    # Edge / limit checks
    # ------------------------------------------------------------
    print_header("B) Edge/limit checks: nondegenerate (eta<<0), 0K-step, Sommerfeld (eta>>0)")
    print("We compare quad(expit) against asymptotic/limit formulae.\n"
          "For very negative eta:  Fj ≈ exp(eta)*Gamma(j+1)\n"
          "For large positive eta: use 0K step and Sommerfeld expansion as references.\n")
    print("-" * 78)
    print("   j     eta      quad_expit        approx_type        approx_value      rel.err")
    print("-" * 78)

    # 1) nondegenerate checks
    for j in j_values:
        for eta in [-40.0, -50.0]:
            v = Fj_expit(j, eta)
            a = Fj_nondegenerate_approx(j, eta)
            print(f"{j:5.1f}  {eta:7.1f}  {v: .6e}    nondegenerate   {a: .6e}    {rel_err(v,a):.2e}")

    print("-" * 78)

    # 2) 0K-step check (finite eta, compare to step integral)
    for j in [x for x in j_values if x != -1.0]:
        for eta in [-5.0, -1.0, 0.0, 1.0, 5.0, 10.0]:
            v = Fj_expit(j, eta)
            a = Fj_0K_step(j, eta)
            print(f"{j:5.1f}  {eta:7.1f}  {v: .6e}    0K step        {a: .6e}    {rel_err(v,a):.2e}")

    print("-" * 78)

    # 3) Sommerfeld check (eta large)
    for j in [x for x in j_values if x not in (-1.0, 0.0)]:  # j=0 has special exact form; skip
        for eta in [20.0, 40.0]:
            v = Fj_expit(j, eta)
            a = Fj_sommerfeld(j, eta)
            print(f"{j:5.1f}  {eta:7.1f}  {v: .6e}    Sommerfeld     {a: .6e}    {rel_err(v,a):.2e}")

    # Special exact identity for j=0
    print("-" * 78)
    for eta in [-40.0, -10.0, 0.0, 10.0, 40.0]:
        v = Fj_expit(0.0, eta)
        a = float(np.log1p(np.exp(eta)))  # exact: ∫ f(eta-x) dx = log(1+exp(eta))
        print(f"{0.0:5.1f}  {eta:7.1f}  {v: .6e}    exact log1p    {a: .6e}    {rel_err(v,a):.2e}")

    # ------------------------------------------------------------
    # Benchmark
    # ------------------------------------------------------------
    print_header("C) Benchmark (per-call time)")
    N = 30  # repeat count

    j_bench = [0.5, 1.5]
    eta_bench = [-10.0, -1.0, 0.0, 1.0, 10.0, 50.0]

    for j in j_bench:
        print(f"\n[j={j}]")
        print("-" * 78)
        for eta in eta_bench:
            # expit quad
            t0 = time.perf_counter()
            for _ in range(N):
                Fj_expit(j, eta)
            t1 = time.perf_counter()
            time_expit = (t1 - t0) / N

            # raw quad
            t0 = time.perf_counter()
            for _ in range(N):
                Fj_raw(j, eta)
            t1 = time.perf_counter()
            time_raw = (t1 - t0) / N

            # fast (if any)
            t_fast = None
            ok_fast = True
            try:
                t0 = time.perf_counter()
                for _ in range(N * 20):
                    FermiIntegral_fast(eta, j)
                t1 = time.perf_counter()
                t_fast = (t1 - t0) / (N * 20)
            except Exception:
                ok_fast = False

            print(f"eta={eta:6.1f} | quad(expit)={time_expit*1e3:8.3f} ms  quad(raw)={time_raw*1e3:8.3f} ms"
                  + (f"  fast={t_fast*1e6:8.3f} µs" if ok_fast else "  fast=(n/a)"))
        print("-" * 78)

    # ------------------------------------------------------------
    # Extreme eta quick sanity (avoid too much time)
    # ------------------------------------------------------------
    print_header("D) Extreme eta sanity (quick)")
    print("We only run quad(expit) once per point for extreme eta to avoid long runtimes.")
    print("-" * 78)
    print("   j      eta        Fj_expit")
    print("-" * 78)
    for j in j_values:
        for eta in eta_extreme:
            v = Fj_expit(j, float(eta))
            print(f"{j:6.1f}  {eta:8.1f}  {v: .6e}")
        print("-" * 78)


if __name__ == "__main__":
    main()