#!/usr/bin/env python3
"""Accelerated Monte Carlo simulation of one-dimensional hard rods.

This version preserves the sequential single-particle Metropolis-style update
used by ``hard_rods_MC.py`` but compiles the simulation kernel with Numba.

Default files:
    hard_rods_MC.par   simulation parameters
    hard_rods_MC.dat   run summary
    hard_rods_MC.out   final rod coordinates
    hard_rods_MC.prof  density profile
"""

from __future__ import annotations

import argparse
from dataclasses import dataclass
from pathlib import Path
import time

import numpy as np

try:
    from numba import njit
except ImportError as exc:  # pragma: no cover
    raise SystemExit(
        "This accelerated version requires Numba. Install it with:\n"
        "    python -m pip install numba"
    ) from exc


N_BINS = 600


@dataclass(frozen=True)
class SimulationParameters:
    n_rods: int
    mc_steps: int
    equilibration_steps: int
    eta: float
    dx: float


def read_parameters(filename: Path) -> SimulationParameters:
    """Read N, production sweeps, equilibration sweeps, eta, and dx."""
    values: list[str] = []
    with filename.open("r", encoding="utf-8") as input_file:
        for line in input_file:
            line = line.split("#", 1)[0].split("!", 1)[0].strip()
            if line:
                values.append(line.split()[0])

    if len(values) < 5:
        raise ValueError(
            f"{filename} must contain at least five values: "
            "N, MCS, S_equil, eta, and dx."
        )

    p = SimulationParameters(
        n_rods=int(values[0]),
        mc_steps=int(values[1]),
        equilibration_steps=int(values[2]),
        eta=float(values[3]),
        dx=float(values[4]),
    )

    if p.n_rods <= 0:
        raise ValueError("The number of rods must be positive.")
    if p.mc_steps <= 0:
        raise ValueError("The number of production MC steps must be positive.")
    if p.equilibration_steps < 0:
        raise ValueError("The number of equilibration steps cannot be negative.")
    if not 0.0 < p.eta < 1.0:
        raise ValueError("eta must lie strictly between 0 and 1.")
    if p.dx < 0.0:
        raise ValueError("dx cannot be negative.")
    return p


@njit(cache=True)
def _simulation_kernel(
    n: int,
    mc_steps: int,
    equilibration_steps: int,
    eta: float,
    dx: float,
    seed: int,
) -> tuple[np.ndarray, np.ndarray, float, float, int]:
    """Compiled sequential Monte Carlo kernel."""
    np.random.seed(seed)

    free_length = (1.0 - eta) / eta
    box_length = n * (free_length + 1.0)
    bin_width = (box_length - 1.0) / N_BINS

    positions = np.empty(n, dtype=np.float64)
    spacing = free_length + 1.0
    for i in range(n):
        positions[i] = 0.5 + i * spacing

    histogram = np.zeros(N_BINS, dtype=np.float64)
    accepted_moves = 0
    total_steps = equilibration_steps + mc_steps
    right_wall = box_length - 0.5

    for step in range(total_steps):
        # Sequential visits are essential: a move changes the admissible
        # interval for the following rod in the same sweep.
        for i in range(n):
            trial = positions[i] + dx * (2.0 * np.random.random() - 1.0)

            if trial < 0.5 or trial > right_wall:
                continue
            if i > 0 and trial - positions[i - 1] < 1.0:
                continue
            if i < n - 1 and positions[i + 1] - trial < 1.0:
                continue

            positions[i] = trial
            if step >= equilibration_steps:
                accepted_moves += 1

        if step >= equilibration_steps:
            # Direct scalar histogram update is faster inside compiled code
            # than returning all configurations to Python.
            for i in range(n):
                index = int((positions[i] - 0.5) / bin_width)
                if index < 0:
                    index = 0
                elif index >= N_BINS:
                    index = N_BINS - 1
                histogram[index] += 1.0

    return positions, histogram, box_length, bin_width, accepted_moves


def run_simulation(
    parameters: SimulationParameters,
    seed: int | None = None,
) -> tuple[np.ndarray, np.ndarray, float, float, float]:
    """Run the accelerated simulation and return final data."""
    # Numba's legacy RNG accepts a 32-bit seed. Generate one from system
    # entropy when the user does not request reproducibility.
    if seed is None:
        seed = int(np.random.SeedSequence().generate_state(1, dtype=np.uint32)[0])
    seed32 = int(seed) % (2**32 - 1)

    positions, histogram, box_length, bin_width, accepted_moves = _simulation_kernel(
        parameters.n_rods,
        parameters.mc_steps,
        parameters.equilibration_steps,
        parameters.eta,
        parameters.dx,
        seed32,
    )

    acceptance_ratio = 100.0 * accepted_moves / (
        parameters.n_rods * parameters.mc_steps
    )
    return positions, histogram, box_length, bin_width, acceptance_ratio


def write_results(
    parameters: SimulationParameters,
    positions: np.ndarray,
    histogram: np.ndarray,
    box_length: float,
    bin_width: float,
    acceptance_ratio: float,
    output_prefix: Path,
) -> None:
    """Write files compatible with the original translation."""
    summary_file = output_prefix.with_suffix(".dat")
    configuration_file = output_prefix.with_suffix(".out")
    profile_file = output_prefix.with_suffix(".prof")

    output_prefix.parent.mkdir(parents=True, exist_ok=True)
    packing_fraction = parameters.n_rods / box_length

    with summary_file.open("w", encoding="utf-8") as output:
        output.write(f"N   :{parameters.n_rods:3d}\n")
        output.write(f"MCS total :{parameters.mc_steps:8d}\n")
        output.write(f"MCS equil :{parameters.equilibration_steps:8d}\n")
        output.write(f"dx  : {parameters.dx:6.3f}\n")
        output.write(f"eta : {packing_fraction:6.3f}\n")
        output.write(f"Box : {box_length:6.3f}\n")
        output.write(f"Acceptance ratio: {acceptance_ratio:6.1f}\n")

    np.savetxt(configuration_file, positions)
    bin_centres = 0.5 + (np.arange(N_BINS) + 0.5) * bin_width
    density = histogram / (bin_width * parameters.mc_steps)
    np.savetxt(profile_file, np.column_stack((bin_centres, density)))


def parse_arguments() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Accelerated Monte Carlo simulation of 1D hard rods."
    )
    parser.add_argument(
        "--parameters", type=Path, default=Path("hard_rods_MC.par"),
        help="parameter file (default: hard_rods_MC.par)",
    )
    parser.add_argument(
        "--output-prefix", type=Path, default=Path("hard_rods_MC"),
        help="prefix for .dat, .out, and .prof files",
    )
    parser.add_argument(
        "--seed", type=int, default=None,
        help="optional random seed for reproducibility",
    )
    parser.add_argument(
        "--timing", action="store_true",
        help="print elapsed simulation time",
    )
    return parser.parse_args()


def main() -> None:
    args = parse_arguments()
    parameters = read_parameters(args.parameters)

    start = time.perf_counter()
    result = run_simulation(parameters, args.seed)
    elapsed = time.perf_counter() - start

    positions, histogram, box_length, bin_width, acceptance_ratio = result
    write_results(
        parameters, positions, histogram, box_length, bin_width,
        acceptance_ratio, args.output_prefix,
    )

    print(f"Simulation completed. Acceptance ratio: {acceptance_ratio:.1f}%")
    if args.timing:
        print(f"Simulation time: {elapsed:.6f} s")


if __name__ == "__main__":
    main()
