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

Python translation of ``hard_rods_MC.f90``.

The default input and output files are:
    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 numpy as np


N_BINS = 600


@dataclass(frozen=True)
class SimulationParameters:
    """Input parameters for the hard-rod simulation."""

    n_rods: int
    mc_steps: int
    equilibration_steps: int
    eta: float
    dx: float


def read_parameters(filename: Path) -> SimulationParameters:
    """Read the five simulation parameters from a text file.

    Blank lines and text following ``#`` or ``!`` are ignored.
    """
    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."
        )

    parameters = 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 parameters.n_rods <= 0:
        raise ValueError("The number of rods must be positive.")
    if parameters.mc_steps <= 0:
        raise ValueError("The number of production MC steps must be positive.")
    if parameters.equilibration_steps < 0:
        raise ValueError("The number of equilibration steps cannot be negative.")
    if not 0.0 < parameters.eta < 1.0:
        raise ValueError("eta must lie strictly between 0 and 1.")
    if parameters.dx < 0.0:
        raise ValueError("dx cannot be negative.")

    return parameters


def run_simulation(
    parameters: SimulationParameters,
    rng: np.random.Generator,
) -> tuple[np.ndarray, np.ndarray, float, float, float]:
    """Run the Monte Carlo simulation.

    Returns
    -------
    positions
        Final rod-centre coordinates.
    histogram
        Accumulated number-density histogram.
    box_length
        Length of the one-dimensional box.
    bin_width
        Histogram bin width.
    acceptance_ratio
        Percentage of accepted moves during production.
    """
    n = parameters.n_rods
    eta = parameters.eta

    # Mean free length per rod. Rod length is the unit of length.
    free_length = (1.0 - eta) / eta

    # Initial equally spaced configuration. Python uses zero-based indexing.
    positions = 0.5 + np.arange(n, dtype=float) * (free_length + 1.0)

    box_length = n * (free_length + 1.0)
    bin_width = (box_length - 1.0) / N_BINS
    histogram = np.zeros(N_BINS, dtype=np.float64)
    accepted_moves = 0

    total_steps = parameters.equilibration_steps + parameters.mc_steps

    for step in range(total_steps):
        # Visit all rods in sequence, as in the Fortran program.
        for i in range(n):
            trial_position = positions[i] + parameters.dx * (
                2.0 * rng.random() - 1.0
            )

            # Reject moves outside the hard walls. Rod radius is 0.5.
            if trial_position < 0.5 or trial_position > box_length - 0.5:
                continue

            # Since rods remain ordered in one dimension, only the immediate
            # neighbours need to be tested for overlap.
            if i > 0 and abs(trial_position - positions[i - 1]) < 1.0:
                continue
            if i < n - 1 and abs(trial_position - positions[i + 1]) < 1.0:
                continue

            positions[i] = trial_position
            if step >= parameters.equilibration_steps:
                accepted_moves += 1

        # Accumulate the density profile only during production.
        if step >= parameters.equilibration_steps:
            bin_indices = ((positions - 0.5) / bin_width).astype(int)

            # The rightmost possible centre can give index N_BINS because of
            # the original bin convention; clip it safely into the last bin.
            bin_indices = np.clip(bin_indices, 0, N_BINS - 1)
            np.add.at(histogram, bin_indices, 1.0)

    acceptance_ratio = (
        100.0 * accepted_moves / (n * 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 output files corresponding to those of the Fortran program."""
    summary_file = output_prefix.with_suffix(".dat")
    configuration_file = output_prefix.with_suffix(".out")
    profile_file = output_prefix.with_suffix(".prof")

    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="Monte Carlo simulation of one-dimensional 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-number seed for reproducibility",
    )
    return parser.parse_args()


def main() -> None:
    args = parse_arguments()
    parameters = read_parameters(args.parameters)
    rng = np.random.default_rng(args.seed)

    positions, histogram, box_length, bin_width, acceptance_ratio = run_simulation(
        parameters, rng
    )

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

    print(f"Simulation completed. Acceptance ratio: {acceptance_ratio:.1f}%")


if __name__ == "__main__":
    main()
