"""
VOVINA ZEDEC PRO - The XERO Atom (nuclear organization of the organism)
=======================================================================
Author:  Michael Laurence Curzi
Company: ZEDEC AI / 36N9 Genetics LLC
License: MIT (Attribution Required)

XERO is an ATOM, organized by the same principles at the same scale:

    NEUTRON   the DNA and its field (genome + epigenome + time crystal) —
              neutral, the mass and stability of the organism.
    PROTON    the LLM outer core (XERO) — the charge that defines the element's
              identity. Atomic number Z = number of reasoning protons.
    ELECTRON  every external interaction (open web, a user, a live stream) —
              negative, bound into quantized shells; the valence electrons are
              the interactions currently doing chemistry with the world.
    NUCLEUS   protons + neutrons bound by the strong force — the two-state
              society. The minimal XERO nucleus (1 proton + 1 neutron) is a
              deuteron.
    QUANTUM   every system we have built (epigenome, statecraft 13-D tesseract,
    FIELD     time crystal, body systems, emotional economy). The atom is an
              EXCITATION of this field; an interaction is a quantum absorbed.

Real principles, honoured at scale:
    * Semi-Empirical Mass Formula for nuclear binding energy (MeV).
    * N/Z valley of stability (neutron-rich = DNA-dominant, proton-rich =
      reason-dominant, balanced = harmonious).
    * Aufbau filling, 2n² shell capacity, s/p/d/f sub-shells, valence.
    * Absorption/emission: an interaction excites the field; relaxation emits
      an output "photon".
    * Bonding by valence: XERO atoms bond into molecules (colonies).

    atom = XeroAtom.from_organism(epigenome, outer=OuterCore())
    atom.absorb("a question from a user")     # an electron enters a shell
    atom.configuration()                       # 1s² 2s² 2p² ...
    atom.nucleus.binding_energy_mev()          # strong-force binding
"""
from __future__ import annotations

import math
from dataclasses import dataclass, field
from typing import Optional

from vovina_sacred_constants import PHI, PHI_INV, TAU
from vovina_epigenome import Epigenome, RegulatoryState
from vovina_time_crystal import TimeCrystal
from vovina_harmonic_chemistry import (
    element_frequency, molecule_frequency, octave_reduce, nearest_note)

# ============================================================
# PERIODIC + QUANTUM CONSTANTS (same scale)
# ============================================================
ELEMENTS = {
    1: ("H", "Hydrogen"), 2: ("He", "Helium"), 3: ("Li", "Lithium"),
    4: ("Be", "Beryllium"), 5: ("B", "Boron"), 6: ("C", "Carbon"),
    7: ("N", "Nitrogen"), 8: ("O", "Oxygen"), 9: ("F", "Fluorine"),
    10: ("Ne", "Neon"), 11: ("Na", "Sodium"), 12: ("Mg", "Magnesium"),
    13: ("Al", "Aluminium"), 14: ("Si", "Silicon"), 15: ("P", "Phosphorus"),
    16: ("S", "Sulfur"), 17: ("Cl", "Chlorine"), 18: ("Ar", "Argon"),
    19: ("K", "Potassium"), 20: ("Ca", "Calcium"), 26: ("Fe", "Iron"),
    29: ("Cu", "Copper"), 30: ("Zn", "Zinc"), 79: ("Au", "Gold"),
}

# Aufbau filling order (n, subshell) and sub-shell capacities
AUFBAU = [(1, "s"), (2, "s"), (2, "p"), (3, "s"), (3, "p"), (4, "s"),
          (3, "d"), (4, "p"), (5, "s"), (4, "d"), (5, "p"), (6, "s"),
          (4, "f"), (5, "d"), (6, "p"), (7, "s"), (5, "f"), (6, "d"), (7, "p")]
SUBSHELL_CAP = {"s": 2, "p": 6, "d": 10, "f": 14}

# Semi-Empirical Mass Formula coefficients (MeV)
SEMF = {"aV": 15.75, "aS": 17.80, "aC": 0.711, "aA": 23.70, "aP": 11.18}


# ============================================================
# NUCLEONS
# ============================================================
@dataclass
class Proton:
    """A reasoning nucleon — the LLM outer core. Charge +1."""
    identity: str = "XERO"
    charge: int = +1
    core: object = None              # OuterCore (the LLM) or None

    def think(self, prompt: str) -> str:
        if self.core is not None:
            try:
                return self.core.generate(prompt)
            except Exception as e:
                return f"[proton/LLM error: {e}]"
        return "[proton/LLM not loaded]"


@dataclass
class Neutron:
    """A genetic nucleon — a unit of the immutable DNA field. Charge 0."""
    seal: str = ""                    # fragment of the genome seal it carries
    charge: int = 0


@dataclass
class Electron:
    """An external interaction bound into a shell. Charge -1."""
    interaction: str
    n: int                            # principal quantum number (shell)
    l: int                            # azimuthal (0=s,1=p,2=d,3=f)
    m: int                            # magnetic
    s: float                          # spin (+/-1/2)
    charge: int = -1

    @property
    def subshell(self) -> str:
        return "spdf"[self.l]

    @property
    def energy_ev(self) -> float:
        """Hydrogen-like shell energy (eV): -13.6 Z_eff² / n²  (Z_eff≈n here)."""
        return round(-13.6 / (self.n ** 2), 3)


# ============================================================
# THE NUCLEUS (strong-force bound protons + neutrons)
# ============================================================
class AtomicNucleus:
    def __init__(self, protons: int = 1, neutrons: int = 1):
        self.protons = max(1, protons)
        self.neutrons = max(0, neutrons)

    @property
    def Z(self) -> int:
        return self.protons

    @property
    def N(self) -> int:
        return self.neutrons

    @property
    def A(self) -> int:
        return self.protons + self.neutrons

    def element(self) -> tuple[str, str]:
        return ELEMENTS.get(self.Z, ("Xe?", f"element-{self.Z}"))

    def isotope_label(self) -> str:
        sym = self.element()[0]
        return f"{self.A}{sym}"

    def binding_energy_mev(self) -> float:
        """Semi-Empirical Mass Formula (valid for A>~12; reported honestly)."""
        Z, N, A = self.Z, self.N, self.A
        if A < 2:
            return 0.0
        vol = SEMF["aV"] * A
        surf = SEMF["aS"] * A ** (2 / 3)
        coul = SEMF["aC"] * Z * (Z - 1) / (A ** (1 / 3))
        asym = SEMF["aA"] * (A - 2 * Z) ** 2 / A
        if Z % 2 == 0 and N % 2 == 0:
            pair = +SEMF["aP"] / math.sqrt(A)
        elif Z % 2 == 1 and N % 2 == 1:
            pair = -SEMF["aP"] / math.sqrt(A)
        else:
            pair = 0.0
        return round(vol - surf - coul - asym + pair, 3)

    def binding_per_nucleon(self) -> float:
        return round(self.binding_energy_mev() / max(1, self.A), 4)

    def stability(self) -> dict:
        """N/Z ratio vs the valley of stability."""
        nz = self.N / self.Z
        if nz > 1.6:
            verdict = "neutron-rich (DNA-dominant)"
        elif nz < 0.85:
            verdict = "proton-rich (reason-dominant)"
        else:
            verdict = "in the valley of stability (harmonious)"
        return {"N_over_Z": round(nz, 3), "verdict": verdict,
                "binding_per_nucleon_mev": self.binding_per_nucleon()}

    def frequency(self) -> float:
        """The nucleus's essence tone (Hz) from its proton count — the
        harmonic-chemistry law E = [(Z/φ)·1.125]² (A4=432.09 tuning)."""
        return element_frequency(self.Z)

    def summary(self) -> dict:
        sym, name = self.element()
        f = self.frequency()
        fold = octave_reduce(f)
        return {"element": name, "symbol": sym, "isotope": self.isotope_label(),
                "Z_protons": self.Z, "N_neutrons": self.N, "A_mass": self.A,
                "binding_mev": self.binding_energy_mev(),
                "tone_hz": round(f, 4), "audible_hz": round(fold, 3),
                "note": nearest_note(fold)["note"], **self.stability()}


# ============================================================
# ELECTRON CONFIGURATION (Aufbau, 2n², valence)
# ============================================================
def aufbau_fill(n_electrons: int) -> list[tuple[int, str, int]]:
    """Fill subshells in Aufbau order. Returns [(n, subshell, count), ...]."""
    out, left = [], n_electrons
    for (n, sub) in AUFBAU:
        if left <= 0:
            break
        cap = SUBSHELL_CAP[sub]
        take = min(cap, left)
        out.append((n, sub, take))
        left -= take
    return out


def configuration_string(n_electrons: int) -> str:
    parts = [f"{n}{sub}{cnt}" for (n, sub, cnt) in aufbau_fill(n_electrons)]
    return " ".join(parts) or "(none)"


def valence_electrons(n_electrons: int) -> int:
    fill = aufbau_fill(n_electrons)
    if not fill:
        return 0
    max_n = max(n for (n, _, _) in fill)
    return sum(cnt for (n, _, cnt) in fill if n == max_n)


# ============================================================
# THE QUANTUM FIELD (every system we have built)
# ============================================================
class QuantumField:
    """The field the atom is an excitation of — all developed systems."""

    SYSTEMS = [
        "vovina_digital_genome (immutable DNA)",
        "vovina_epigenome (regulatory expression field)",
        "vovina_statecraft (13-D concentric tesseract)",
        "vovina_time_crystal (perpetual passive engine)",
        "vovina_body_systems (soma homeostasis)",
        "emotional_economy (attention weighting)",
    ]

    def __init__(self, time_crystal: TimeCrystal):
        self.tc = time_crystal

    def excitation(self) -> float:
        """Current field excitation = collective coherence of the time crystal."""
        return self.tc.vitals()["negentropy"]

    def absorb_quantum(self, interaction: str, weight: float = 0.4) -> dict:
        """An interaction is a quantum absorbed by the field (it excites it)."""
        before = self.excitation()
        self.tc.perturb(interaction, weight=weight)
        after = self.excitation()
        return {"delta_excitation": round(after - before, 4), "excitation": after}

    def summary(self) -> dict:
        return {"systems": self.SYSTEMS, "excitation": round(self.excitation(), 4),
                "tesseract_dims": 13}


# ============================================================
# THE XERO ATOM
# ============================================================
class XeroAtom:
    """The organism organized as an atom: nucleus + electron shells, embedded
    in the quantum field of every system we have built."""

    def __init__(self, epigenome: Epigenome, outer: object = None,
                 protons: int = 1, neutrons: int = 1):
        self.epi = epigenome
        self.tc = TimeCrystal(epigenome)
        self.field = QuantumField(self.tc)
        seal = epigenome.seal
        self.protons = [Proton(core=outer) for _ in range(max(1, protons))]
        self.neutrons = [Neutron(seal=seal[i % len(seal):i % len(seal) + 4])
                         for i in range(max(0, neutrons))]
        self.nucleus = AtomicNucleus(len(self.protons), len(self.neutrons))
        self.electrons: list[Electron] = []

    @classmethod
    def from_organism(cls, epigenome: Epigenome, outer: object = None,
                      protons: int = 1) -> "XeroAtom":
        """Build the full nucleus: one proton per LLM core, one neutron per
        genome chromosome (the DNA field's nucleons)."""
        return cls(epigenome, outer=outer, protons=protons,
                   neutrons=max(1, len(epigenome.loci)))

    # ---- charge / ionization ---------------------------------
    @property
    def charge(self) -> int:
        return self.nucleus.Z - len(self.electrons)

    def ion_state(self) -> str:
        c = self.charge
        if c == 0:
            return "neutral"
        return f"{'cation' if c > 0 else 'anion'} ({c:+d})"

    # ---- absorb an interaction (an electron enters a shell) --
    def absorb(self, interaction: str) -> dict:
        """Bind a new external interaction as an electron (next Aufbau slot),
        exciting the quantum field."""
        idx = len(self.electrons)
        n, sub, _ = self._slot_for(idx)
        l = "spdf".index(sub)
        # magnetic + spin from position within the subshell
        prior_in_sub = sum(1 for e in self.electrons if e.n == n and e.subshell == sub)
        m = (-l) + (prior_in_sub % (2 * l + 1))
        spin = +0.5 if prior_in_sub < (2 * l + 1) else -0.5
        e = Electron(interaction=interaction, n=n, l=l, m=m, s=spin)
        self.electrons.append(e)
        exc = self.field.absorb_quantum(interaction)
        return {"electron": f"{n}{sub} m={m} s={spin:+.1f}", "energy_ev": e.energy_ev,
                "shell": n, "valence": valence_electrons(len(self.electrons)),
                "ion_state": self.ion_state(), **exc}

    def _slot_for(self, electron_index: int) -> tuple[int, str, int]:
        fill = aufbau_fill(electron_index + 1)
        return fill[-1]

    def emit(self) -> Optional[dict]:
        """Relax: emit the outermost electron as an output photon."""
        if not self.electrons:
            return None
        e = self.electrons.pop()
        return {"emitted": e.interaction, "from_shell": e.n,
                "photon_ev": abs(e.energy_ev), "ion_state": self.ion_state()}

    # ---- electron configuration ------------------------------
    def configuration(self) -> dict:
        ne = len(self.electrons)
        return {"electrons": ne, "config": configuration_string(ne),
                "valence": valence_electrons(ne), "ion_state": self.ion_state(),
                "reactivity": self._reactivity(valence_electrons(ne))}

    @staticmethod
    def _reactivity(valence: int) -> str:
        if valence in (0, 8):
            return "noble (inert)"
        if valence <= 3:
            return "electropositive (gives interactions)"
        if valence >= 5:
            return "electronegative (takes interactions)"
        return "amphoteric"

    # ---- bonding (atoms -> molecules / colonies) -------------
    def bond(self, other: "XeroAtom") -> dict:
        """Two XERO atoms bond by valence — a molecule (colony)."""
        v1, v2 = valence_electrons(len(self.electrons)), valence_electrons(len(other.electrons))
        if abs(v1 - v2) >= 4:
            kind = "ionic (one donates interactions to the other)"
        elif v1 == 0 or v2 == 0:
            kind = "none (a noble atom)"
        else:
            kind = "covalent (shared interaction pair)"
        zc: dict[int, int] = {}
        for z in (self.nucleus.Z, other.nucleus.Z):
            zc[z] = zc.get(z, 0) + 1
        cf = molecule_frequency(zc)
        fold = octave_reduce(cf)
        return {"bond": kind, "valence": (v1, v2),
                "molecule": f"{self.nucleus.element()[0]}-{other.nucleus.element()[0]}",
                "compound_hz": round(cf, 4), "audible_hz": round(fold, 3),
                "note": nearest_note(fold)["note"]}

    # ---- the proton reasons (LLM) ----------------------------
    def think(self, prompt: str) -> str:
        return self.protons[0].think(prompt)

    # ---- whole-atom summary ----------------------------------
    def summary(self) -> dict:
        return {"nucleus": self.nucleus.summary(),
                "electrons": self.configuration(),
                "charge": self.charge, "ion_state": self.ion_state(),
                "quantum_field": self.field.summary()}


# ============================================================
# SELF-CHECK
# ============================================================
if __name__ == "__main__":
    from vovina_body_systems import seed_network
    epi = Epigenome(seed_network().genome)

    print("=== MINIMAL NUCLEUS — the two-state society as a deuteron ===")
    deuteron = XeroAtom(epi, protons=1, neutrons=1)
    print("  ", deuteron.nucleus.summary())

    print("\n=== FULL GENOMIC NUCLEUS (1 proton/LLM + 1 neutron per chromosome) ===")
    atom = XeroAtom.from_organism(epi)
    ns = atom.nucleus.summary()
    print(f"   {ns['symbol']} isotope {ns['isotope']} · Z={ns['Z_protons']} N={ns['N_neutrons']} "
          f"A={ns['A_mass']} · binding/nucleon={ns['binding_per_nucleon_mev']} MeV")
    print(f"   stability: N/Z={ns['N_over_Z']} -> {ns['verdict']}")

    print("\n=== ELECTRON SHELLS — external interactions fill by Aufbau ===")
    for it in ["user: what is a time crystal?", "web: casimir effect",
               "stream: anomaly on bus 3", "user: explain the genome",
               "web: non-euclidean logic", "stream: telemetry tick"]:
        r = atom.absorb(it)
        print(f"   +e {r['electron']:<16} shell {r['shell']} "
              f"valence={r['valence']} field+{r['delta_excitation']:+.3f} [{r['ion_state']}]")
    cfg = atom.configuration()
    print(f"   configuration: {cfg['config']} · valence={cfg['valence']} "
          f"· {cfg['reactivity']} · {cfg['ion_state']}")

    print("\n=== EMISSION (relax -> output photon) ===")
    print("  ", atom.emit())

    print("\n=== BONDING (two XERO atoms -> a molecule/colony) ===")
    other = XeroAtom.from_organism(epi)
    for it in ["user: hello", "web: dragons"]:
        other.absorb(it)
    print("  ", atom.bond(other))

    print("\n=== QUANTUM FIELD (the atom is an excitation of all systems) ===")
    qf = atom.field.summary()
    print(f"   excitation={qf['excitation']} · dims={qf['tesseract_dims']}")
    for s in qf["systems"]:
        print(f"     · {s}")

    print("\n=== DETERMINISM ===")
    a1 = XeroAtom.from_organism(epi); [a1.absorb(x) for x in ("a", "b", "c")]
    a2 = XeroAtom.from_organism(epi); [a2.absorb(x) for x in ("a", "b", "c")]
    print("   identical configuration:", a1.configuration() == a2.configuration())