"""Tutorial 1, part 2 — heat a doped MoS2 bilayer and watch the dopants move.

The paper heated 3,111-atom supercells from 300 K to 1000 K over 20 ps (NPT, UMA small) and
tracked clustering, interlayer diffusion and compound formation. This laptop version heats a
small Cu-intercalated bilayer with a Langevin thermostat and reports each species' mean
squared displacement (MSD). Fast-moving dopants show up as a steep MSD curve.

Run:   python heat_md.py --dopant Cu --n-dopant 4          (~2-4 min CPU with MACE small)
Output: out/heat_<dopant>.extxyz (open in OVITO or ase gui), out/msd_<dopant>.png
"""
import argparse
import sys
from pathlib import Path

import numpy as np
from ase import Atoms, units
from ase.build import mx2
from ase.io import write
from ase.md.langevin import Langevin
from ase.md.velocitydistribution import MaxwellBoltzmannDistribution

sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "common"))
from models import get_calc  # noqa: E402

OUT = Path(__file__).parent / "out"
OUT.mkdir(exist_ok=True)


def doped_bilayer(n, dopant, k, seed=0, gap=7.0, dmin=2.2):
    """Two MoS2 layers `gap` Å apart (pristine 2H spacing is 6.15 Å; intercalants push it open),
    periodic along z, with `k` dopant atoms placed at random in the gap at least `dmin` Å from any atom."""
    layer = mx2("MoS2", kind="2H", a=3.18, thickness=3.19, size=(n, n, 1), vacuum=0)
    top = layer.copy()
    top.translate([0, 0, gap])
    sys_ = layer + top
    sys_.cell[2] = [0, 0, 2 * gap]  # periodic stack of bilayers
    sys_.pbc = True
    rng = np.random.default_rng(seed)
    z = layer.positions[:, 2].max() + (gap - 3.19) / 2  # middle of the van der Waals gap
    placed = 0
    for _ in range(5000):
        if placed == k:
            break
        f = rng.random(2)
        p = f[0] * sys_.cell[0] + f[1] * sys_.cell[1] + [0, 0, z]
        trial = sys_ + Atoms(dopant, positions=[p])
        if trial.get_distances(len(trial) - 1, range(len(trial) - 1), mic=True).min() >= dmin:
            sys_ = trial
            placed += 1
    sys_.wrap()
    return sys_


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--model", default="mace-small")
    ap.add_argument("--dopant", default="Cu")
    ap.add_argument("--n-dopant", type=int, default=4)
    ap.add_argument("--size", type=int, default=4)
    ap.add_argument("--steps", type=int, default=3000, help="1 fs steps")
    ap.add_argument("--t0", type=float, default=300)
    ap.add_argument("--t1", type=float, default=1000)
    args = ap.parse_args()

    atoms = doped_bilayer(args.size, args.dopant, args.n_dopant)
    atoms.calc = get_calc(args.model, dtype="float32")
    MaxwellBoltzmannDistribution(atoms, temperature_K=args.t0, rng=np.random.default_rng(1))
    dyn = Langevin(atoms, 1.0 * units.fs, temperature_K=args.t0, friction=0.02, rng=np.random.default_rng(2))

    ref = atoms.get_positions().copy()
    prev = ref.copy()
    unwrapped = ref.copy()
    sym = np.array(atoms.get_chemical_symbols())
    kinds = sorted(set(sym), key=lambda s: {"Mo": 0, "S": 1}.get(s, 2))
    msd = {k: [] for k in kinds}
    times, temps, frames = [], [], []
    every = 30

    def record():
        nonlocal prev, unwrapped
        pos = atoms.get_positions()
        d = pos - prev
        frac = np.linalg.solve(atoms.cell.T, d.T).T
        frac -= np.round(frac)
        unwrapped = unwrapped + frac @ atoms.cell
        prev = pos.copy()
        for k in kinds:
            m = sym == k
            msd[k].append(np.mean(np.sum((unwrapped[m] - ref[m]) ** 2, axis=1)))
        times.append(dyn.get_number_of_steps() * 1e-3)
        temps.append(atoms.get_temperature())
        frames.append(atoms.copy())

    for step in range(0, args.steps, every):
        dyn.set_temperature(temperature_K=args.t0 + (args.t1 - args.t0) * step / args.steps)
        dyn.run(every)
        record()
        if len(times) % 10 == 0:
            print(f"t = {times[-1]:5.2f} ps   T = {temps[-1]:6.0f} K   MSD({args.dopant}) = {msd[args.dopant][-1]:6.2f} A^2", flush=True)

    write(OUT / f"heat_{args.dopant}.extxyz", frames)
    import matplotlib
    matplotlib.use("Agg")
    import matplotlib.pyplot as plt
    col = {"Mo": "#1f6fa8", "S": "#d9a20b"}
    fig, ax = plt.subplots(figsize=(6, 4))
    for k in kinds:
        ax.plot(times, msd[k], label=k, color=col.get(k, "#c2414f"), lw=2)
    ax.set_xlabel("Time (ps)")
    ax.set_ylabel("MSD (Å$^2$)")
    ax.set_title(f"{args.dopant}-intercalated MoS$_2$ bilayer, {args.t0:.0f}→{args.t1:.0f} K")
    ax.legend(frameon=False)
    fig.tight_layout()
    fig.savefig(OUT / f"msd_{args.dopant}.png", dpi=160)
    print("wrote", OUT / f"msd_{args.dopant}.png")


if __name__ == "__main__":
    main()
