#!/usr/bin/env python3
"""
概要:
    ニュートン力学による惑星の運動について、オイラー法、ホイン法、RK4法、および速度ベルレ法を比較します。
詳細説明:
    惑星のデータベースはSI単位系を使用しています。内部的には、このプログラムは天文単位(AU)、日、太陽質量を使用します。
    デフォルトの太陽と地球の計算は重心系で初期化されるため、全体の線形運動量はゼロになります。
    このプログラムの目的は数値積分の比較であり、高精度な太陽系の位置推算ではありません。
"""

from __future__ import annotations

import argparse
import csv
from dataclasses import dataclass
from pathlib import Path

import matplotlib.pyplot as plt
import numpy as np


G_SI = 6.67259e-11
DAY = 24.0 * 60.0 * 60.0
AU = 1.49597870e11
M_SUN = 1.99e30
G = G_SI * DAY**2 * M_SUN / AU**3  # AU^3 / (solar mass day^2)


@dataclass(frozen=True)
class Body:
    """
    概要:
        天体の情報を保持するデータクラスです。
    詳細説明:
        データベースから読み込まれた天体の名前、質量、軌道半径、速度を格納します。
    引数:
        :param name: 天体の名前
        :type name: str
        :param mass: 太陽質量を単位とする天体の質量
        :type mass: float
        :param radius: 天文単位(AU)を単位とする初期の太陽との距離
        :type radius: float
        :param speed: AU/日を単位とする初期の相対的な接線速度
        :type speed: float
    """
    name: str
    mass: float  # solar masses
    radius: float  # AU, initial Sun-body separation
    speed: float  # AU/day, initial relative tangential speed


@dataclass
class Trajectory:
    """
    概要:
        計算された軌道データを保持するデータクラスです。
    詳細説明:
        数値積分によって得られた時間、位置、速度、エネルギー、角運動量の履歴を格納します。
    引数:
        :param name: 数値積分手法の名前
        :type name: str
        :param time: 経過時間の配列
        :type time: numpy.ndarray
        :param position: 各時刻における位置の配列
        :type position: numpy.ndarray
        :param velocity: 各時刻における速度の配列
        :type velocity: numpy.ndarray
        :param energy: 各時刻における総エネルギーの配列
        :type energy: numpy.ndarray
        :param angular_momentum: 各時刻におけるz軸周りの角運動量の配列
        :type angular_momentum: numpy.ndarray
    """
    name: str
    time: np.ndarray
    position: np.ndarray
    velocity: np.ndarray
    energy: np.ndarray
    angular_momentum: np.ndarray


def read_planet_db(filename: Path) -> dict[str, Body]:
    """
    概要:
        惑星のCSVデータベースを読み込みます。
    詳細説明:
        指定されたファイルから天体の情報を読み込み、内部単位系に変換してBodyオブジェクトの辞書を作成します。
    引数:
        :param filename: 読み込むCSVファイルのパス
        :type filename: pathlib.Path
    戻り値:
        :returns: 天体の名前をキーとし、Bodyオブジェクトを値とする辞書
        :rtype: dict
    """
    bodies: dict[str, Body] = {}
    with filename.open(newline="", encoding="utf-8") as stream:
        for row in csv.DictReader(stream):
            bodies[row["Name"]] = Body(
                row["Name"], float(row["Mass"]) / M_SUN,
                float(row["Revolution Radius"]) / AU,
                float(row["Revolution Velocity"]) * DAY / AU,
            )
    return bodies


def initial_state(database: dict[str, Body], selected_names: list[str]
                  ) -> tuple[list[str], np.ndarray, np.ndarray, np.ndarray]:
    """
    概要:
        指定された惑星と太陽の初期状態を設定します。
    詳細説明:
        意図的に単純化された初期条件を設定し、重心系に変換することで運動量と重心位置をゼロにします。
    引数:
        :param database: 読み込まれた天体データベース
        :type database: dict
        :param selected_names: シミュレーション対象として選択された惑星の名前のリスト
        :type selected_names: list
    戻り値:
        :returns: 天体の名前のリスト、質量の配列、初期位置の配列、初期速度の配列のタプル
        :rtype: tuple
    例外:
        :raises ValueError: 太陽がデータベースに存在しないか、未知の惑星名が指定された場合に発生します。
    """
    if "Sun" not in database:
        raise ValueError("planet database must contain Sun")
    missing = [name for name in selected_names if name not in database or name == "Sun"]
    if missing:
        raise ValueError(f"unknown planet name(s): {', '.join(missing)}")

    names = ["Sun", *selected_names]
    masses = np.asarray([database[name].mass for name in names])
    position = np.zeros((len(names), 2))
    velocity = np.zeros((len(names), 2))
    # Each planet begins at +x with a +y tangential velocity.  This is a
    # deliberately simple initial condition, not a real ephemeris.
    for i, name in enumerate(selected_names, start=1):
        body = database[name]
        position[i, 0] = body.radius
        velocity[i, 1] = body.speed
    # Shift to the centre-of-mass frame so momentum and centre of mass vanish.
    position -= np.average(position, axis=0, weights=masses)
    velocity -= np.average(velocity, axis=0, weights=masses)
    return names, masses, position, velocity


def acceleration(position: np.ndarray, masses: np.ndarray) -> np.ndarray:
    """
    概要:
        ニュートン力学に基づくN体の加速度を計算します。
    詳細説明:
        万有引力の法則を用いて各天体間の相互作用を計算し、加速度の配列を返します。単位はAU/day^2です。
    引数:
        :param position: 各天体の位置の配列
        :type position: numpy.ndarray
        :param masses: 各天体の質量の配列
        :type masses: numpy.ndarray
    戻り値:
        :returns: 加速度の配列
        :rtype: numpy.ndarray
    例外:
        :raises FloatingPointError: 2つの天体が同じ位置にあり衝突した場合に発生します。
    """
    nbody = len(masses)
    acc = np.zeros_like(position)
    for i in range(nbody - 1):
        for j in range(i + 1, nbody):
            dr = position[j] - position[i]
            r2 = float(np.dot(dr, dr))
            if r2 == 0.0:
                raise FloatingPointError("collision: two bodies occupy the same position")
            inv_r3 = r2 ** -1.5
            acc[i] += G * masses[j] * dr * inv_r3
            acc[j] -= G * masses[i] * dr * inv_r3
    return acc


def rhs(position: np.ndarray, velocity: np.ndarray, masses: np.ndarray
        ) -> tuple[np.ndarray, np.ndarray]:
    """
    概要:
        常微分方程式の右辺を計算します。
    詳細説明:
        位置の微分である速度と、速度の微分である加速度をまとめて返します。
    引数:
        :param position: 各天体の位置の配列
        :type position: numpy.ndarray
        :param velocity: 各天体の速度の配列
        :type velocity: numpy.ndarray
        :param masses: 各天体の質量の配列
        :type masses: numpy.ndarray
    戻り値:
        :returns: 速度の配列と加速度の配列のタプル
        :rtype: tuple
    """
    return velocity, acceleration(position, masses)


def step_euler(position: np.ndarray, velocity: np.ndarray, dt: float,
               masses: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
    """
    概要:
        オイラー法を用いて1ステップ分の時間積分を行います。
    引数:
        :param position: 現在の位置の配列
        :type position: numpy.ndarray
        :param velocity: 現在の速度の配列
        :type velocity: numpy.ndarray
        :param dt: 時間ステップ幅
        :type dt: float
        :param masses: 各天体の質量の配列
        :type masses: numpy.ndarray
    戻り値:
        :returns: 次のステップの位置と速度のタプル
        :rtype: tuple
    """
    _, acc = rhs(position, velocity, masses)
    return position + dt * velocity, velocity + dt * acc


def step_heun(position: np.ndarray, velocity: np.ndarray, dt: float,
              masses: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
    """
    概要:
        ホイン法を用いて1ステップ分の時間積分を行います。
    引数:
        :param position: 現在の位置の配列
        :type position: numpy.ndarray
        :param velocity: 現在の速度の配列
        :type velocity: numpy.ndarray
        :param dt: 時間ステップ幅
        :type dt: float
        :param masses: 各天体の質量の配列
        :type masses: numpy.ndarray
    戻り値:
        :returns: 次のステップの位置と速度のタプル
        :rtype: tuple
    """
    k1_r, k1_v = rhs(position, velocity, masses)
    k2_r, k2_v = rhs(position + dt * k1_r, velocity + dt * k1_v, masses)
    return position + 0.5 * dt * (k1_r + k2_r), velocity + 0.5 * dt * (k1_v + k2_v)


def step_rk4(position: np.ndarray, velocity: np.ndarray, dt: float,
             masses: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
    """
    概要:
        4次のルンゲクッタ法を用いて1ステップ分の時間積分を行います。
    引数:
        :param position: 現在の位置の配列
        :type position: numpy.ndarray
        :param velocity: 現在の速度の配列
        :type velocity: numpy.ndarray
        :param dt: 時間ステップ幅
        :type dt: float
        :param masses: 各天体の質量の配列
        :type masses: numpy.ndarray
    戻り値:
        :returns: 次のステップの位置と速度のタプル
        :rtype: tuple
    """
    k1_r, k1_v = rhs(position, velocity, masses)
    k2_r, k2_v = rhs(position + 0.5 * dt * k1_r, velocity + 0.5 * dt * k1_v, masses)
    k3_r, k3_v = rhs(position + 0.5 * dt * k2_r, velocity + 0.5 * dt * k2_v, masses)
    k4_r, k4_v = rhs(position + dt * k3_r, velocity + dt * k3_v, masses)
    return (position + dt * (k1_r + 2.0 * k2_r + 2.0 * k3_r + k4_r) / 6.0,
            velocity + dt * (k1_v + 2.0 * k2_v + 2.0 * k3_v + k4_v) / 6.0)


def step_velocity_verlet(position: np.ndarray, velocity: np.ndarray, dt: float,
                         masses: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
    """
    概要:
        速度ベルレ法を用いて1ステップ分の時間積分を行います。
    引数:
        :param position: 現在の位置の配列
        :type position: numpy.ndarray
        :param velocity: 現在の速度の配列
        :type velocity: numpy.ndarray
        :param dt: 時間ステップ幅
        :type dt: float
        :param masses: 各天体の質量の配列
        :type masses: numpy.ndarray
    戻り値:
        :returns: 次のステップの位置と速度のタプル
        :rtype: tuple
    """
    acc_old = acceleration(position, masses)
    position_new = position + dt * velocity + 0.5 * dt**2 * acc_old
    acc_new = acceleration(position_new, masses)
    velocity_new = velocity + 0.5 * dt * (acc_old + acc_new)
    return position_new, velocity_new


STEPPERS = {
    "Euler": step_euler,
    "Heun (RK2)": step_heun,
    "RK4": step_rk4,
    "velocity Verlet": step_velocity_verlet,
}


def total_energy(position: np.ndarray, velocity: np.ndarray, masses: np.ndarray) -> float:
    """
    概要:
        系の全エネルギーを計算します。
    詳細説明:
        運動エネルギーとポテンシャルエネルギーの合計を計算して返します。
    引数:
        :param position: 各天体の位置の配列
        :type position: numpy.ndarray
        :param velocity: 各天体の速度の配列
        :type velocity: numpy.ndarray
        :param masses: 各天体の質量の配列
        :type masses: numpy.ndarray
    戻り値:
        :returns: 計算された全エネルギー
        :rtype: float
    """
    kinetic = 0.5 * float(np.sum(masses[:, None] * velocity**2))
    potential = 0.0
    for i in range(len(masses) - 1):
        for j in range(i + 1, len(masses)):
            potential -= G * masses[i] * masses[j] / float(np.linalg.norm(position[j] - position[i]))
    return kinetic + potential


def angular_momentum_z(position: np.ndarray, velocity: np.ndarray, masses: np.ndarray) -> float:
    """
    概要:
        z軸周りの系の全角運動量を計算します。
    引数:
        :param position: 各天体の位置の配列
        :type position: numpy.ndarray
        :param velocity: 各天体の速度の配列
        :type velocity: numpy.ndarray
        :param masses: 各天体の質量の配列
        :type masses: numpy.ndarray
    戻り値:
        :returns: 計算されたz軸周りの角運動量
        :rtype: float
    """
    return float(np.sum(masses * (position[:, 0] * velocity[:, 1] - position[:, 1] * velocity[:, 0])))


def integrate(name: str, stepper, position0: np.ndarray, velocity0: np.ndarray,
              masses: np.ndarray, dt: float, nsteps: int) -> Trajectory:
    """
    概要:
        指定された積分手法を用いて系の時間発展を計算します。
    詳細説明:
        初期状態から指定されたステップ数だけシミュレーションを行い、結果をTrajectoryオブジェクトに格納します。
    引数:
        :param name: 積分手法の名称
        :type name: str
        :param stepper: 1ステップの積分を行う関数
        :type stepper: callable
        :param position0: 初期位置の配列
        :type position0: numpy.ndarray
        :param velocity0: 初期速度の配列
        :type velocity0: numpy.ndarray
        :param masses: 各天体の質量の配列
        :type masses: numpy.ndarray
        :param dt: 時間ステップ幅
        :type dt: float
        :param nsteps: 実行するステップ数
        :type nsteps: int
    戻り値:
        :returns: 計算結果を含むTrajectoryオブジェクト
        :rtype: Trajectory
    """
    nbody = len(masses)
    time = dt * np.arange(nsteps + 1)
    position = np.empty((nsteps + 1, nbody, 2))
    velocity = np.empty_like(position)
    energy = np.empty(nsteps + 1)
    angular_momentum = np.empty(nsteps + 1)
    position[0], velocity[0] = position0.copy(), velocity0.copy()
    energy[0] = total_energy(position[0], velocity[0], masses)
    angular_momentum[0] = angular_momentum_z(position[0], velocity[0], masses)
    for step in range(nsteps):
        position[step + 1], velocity[step + 1] = stepper(position[step], velocity[step], dt, masses)
        energy[step + 1] = total_energy(position[step + 1], velocity[step + 1], masses)
        angular_momentum[step + 1] = angular_momentum_z(position[step + 1], velocity[step + 1], masses)
    return Trajectory(name, time, position, velocity, energy, angular_momentum)


def print_summary(trajectories: list[Trajectory]) -> None:
    """
    概要:
        シミュレーション結果の概要をコンソールに出力します。
    詳細説明:
        各積分手法におけるエネルギーおよび角運動量の相対誤差を出力します。
    引数:
        :param trajectories: 各積分手法のTrajectoryオブジェクトを格納したリスト
        :type trajectories: list
    戻り値:
        :returns: なし
        :rtype: None
    """
    print("\n=== Planet integrator comparison ===")
    print(f"{'method':<18s} {'final dE/E0':>15s} {'max |dE/E0|':>16s} "
          f"{'final dL/L0':>15s}")
    print("-" * 70)
    for trajectory in trajectories:
        rel_e = (trajectory.energy - trajectory.energy[0]) / abs(trajectory.energy[0])
        rel_l = (trajectory.angular_momentum[-1] - trajectory.angular_momentum[0]) / abs(trajectory.angular_momentum[0])
        print(f"{trajectory.name:<18s} {rel_e[-1]:15.6e} {np.max(np.abs(rel_e)):16.6e} {rel_l:15.6e}")


def plot_results(trajectories: list[Trajectory], names: list[str], planet_index: int,
                 years: float, dt: float) -> plt.Figure:
    """
    概要:
        シミュレーション結果をグラフにプロットします。
    詳細説明:
        相対軌道、エネルギー誤差、角運動量誤差の比較グラフを生成します。
    引数:
        :param trajectories: 各積分手法のTrajectoryオブジェクトを格納したリスト
        :type trajectories: list
        :param names: 天体の名前のリスト
        :type names: list
        :param planet_index: 軌道をプロットする対象惑星のインデックス
        :type planet_index: int
        :param years: シミュレーションの期間
        :type years: float
        :param dt: 時間ステップ幅
        :type dt: float
    戻り値:
        :returns: 生成されたmatplotlibのFigureオブジェクト
        :rtype: matplotlib.figure.Figure
    """
    colors = {"Euler": "tab:red", "Heun (RK2)": "tab:orange",
              "RK4": "tab:green", "velocity Verlet": "tab:blue"}
    figure, axes = plt.subplots(2, 2, figsize=(12.5, 9.0))
    ax_orbit, ax_energy, ax_energy_abs, ax_momentum = axes.flat
    sun_index = 0
    for trajectory in trajectories:
        color = colors[trajectory.name]
        relative = trajectory.position[:, planet_index] - trajectory.position[:, sun_index]
        time_years = trajectory.time / 365.25
        rel_e = (trajectory.energy - trajectory.energy[0]) / abs(trajectory.energy[0])
        rel_l = (trajectory.angular_momentum - trajectory.angular_momentum[0]) / abs(trajectory.angular_momentum[0])
        ax_orbit.plot(relative[:, 0], relative[:, 1], label=trajectory.name, color=color, lw=1.5)
        ax_energy.plot(time_years, rel_e, label=trajectory.name, color=color, lw=1.3)
        ax_energy_abs.semilogy(time_years, np.maximum(np.abs(rel_e), 1e-18),
                               label=trajectory.name, color=color, lw=1.3)
        ax_momentum.plot(time_years, rel_l, label=trajectory.name, color=color, lw=1.3)

    ax_orbit.scatter([0.0], [0.0], c="gold", edgecolors="black", s=80, label="Sun")
    ax_orbit.set(aspect="equal", xlabel="relative x (AU)", ylabel="relative y (AU)",
                 title=f"{names[planet_index]} orbit relative to the Sun")
    ax_orbit.grid(alpha=0.25)
    ax_orbit.legend(fontsize=8)

    ax_energy.axhline(0.0, color="0.65", lw=0.8)
    ax_energy.set(xlabel="time (years)", ylabel=r"$(E-E_0)/|E_0|$",
                  title="Signed relative energy error")
    ax_energy.grid(alpha=0.25)
    ax_energy.legend(fontsize=8)

    ax_energy_abs.set(xlabel="time (years)", ylabel=r"$|(E-E_0)/E_0|$",
                      title="Absolute relative energy error (log scale)")
    ax_energy_abs.grid(alpha=0.25, which="both")
    ax_energy_abs.legend(fontsize=8)

    ax_momentum.axhline(0.0, color="0.65", lw=0.8)
    ax_momentum.set(xlabel="time (years)", ylabel=r"$(L_z-L_{z,0})/|L_{z,0}|$",
                    title="Relative angular-momentum error")
    ax_momentum.grid(alpha=0.25)
    ax_momentum.legend(fontsize=8)

    figure.suptitle(f"Newtonian planet integration: dt={dt:g} day, duration={years:g} year", fontsize=14)
    figure.tight_layout(rect=(0, 0, 1, 0.95))
    return figure


def parse_args() -> argparse.Namespace:
    """
    概要:
        コマンドライン引数を解析します。
    戻り値:
        :returns: 解析されたコマンドライン引数を格納したNamespaceオブジェクト
        :rtype: argparse.Namespace
    """
    default_db = Path(__file__).with_name("planet_db.csv")
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--db", type=Path, default=default_db, help="planet CSV database")
    parser.add_argument("--planets", type=str, default="Earth",
                        help="comma-separated planets besides Sun, e.g. Mercury,Earth,Mars")
    parser.add_argument("--plot-planet", type=str, default=None,
                        help="planet shown in the orbit panel (default: first selected)")
    parser.add_argument("--dt", type=float, default=5.0, help="common time step (days)")
    parser.add_argument("--years", type=float, default=30.0, help="simulation duration (years)")
    parser.add_argument("--output", type=Path, default=None, help="optional output figure")
    parser.add_argument("--dpi", type=int, default=160)
    parser.add_argument("--no-show", action="store_true")
    return parser.parse_args()


def main() -> None:
    """
    概要:
        プログラムのメイン処理を実行します。
    詳細説明:
        コマンドライン引数の解析、データベースの読み込み、初期状態の設定、各手法での時間積分、
        および結果のプロットを行います。
    戻り値:
        :returns: なし
        :rtype: None
    例外:
        :raises SystemExit: 不正な引数やデータベースの読み込みエラーが発生した場合に終了します。
    """
    args = parse_args()
    if args.dt <= 0.0 or args.years <= 0.0:
        raise SystemExit("--dt and --years must be positive")
    selected = [name.strip() for name in args.planets.split(",") if name.strip()]
    if not selected:
        raise SystemExit("select at least one planet")
    database = read_planet_db(args.db)
    try:
        names, masses, position0, velocity0 = initial_state(database, selected)
    except ValueError as exc:
        raise SystemExit(str(exc)) from exc
    plot_name = args.plot_planet or selected[0]
    if plot_name not in names:
        raise SystemExit(f"--plot-planet must be one of: {', '.join(selected)}")
    planet_index = names.index(plot_name)
    nsteps = int(round(args.years * 365.25 / args.dt))
    years = nsteps * args.dt / 365.25
    trajectories = [integrate(name, stepper, position0, velocity0, masses, args.dt, nsteps)
                    for name, stepper in STEPPERS.items()]
    print(f"Bodies: {', '.join(names)}; G={G:.10g} AU^3/(M_sun day^2)")
    print_summary(trajectories)
    figure = plot_results(trajectories, names, planet_index, years, args.dt)
    if args.output:
        figure.savefig(args.output, dpi=args.dpi, bbox_inches="tight")
        print(f"Saved figure: {args.output}")
    if args.no_show:
        plt.close(figure)
    else:
        plt.show()


if __name__ == "__main__":
    main()