code/spec_rag/cot_system2.py

"""
System 2 CoT: Deductive Spectral Reasoning.
Generates structured, step-by-step reasoning traces deriving structure from spectrum.
Key components:
1. Precursor Analysis: ExactMass, Nitrogen Rule, DoU.
2. Neutral Loss Analysis: Delta mass attribution (Causal).
3. Fragment Analysis: Substructure validation (Anti-Hallucination).
4. Scaffold Inference: Aglycone/Core deduction.
5. Assembly: Coherent narrative.
"""
from __future__ import annotations

import json
import math
import re
from typing import Any, Optional, List, Dict, Tuple

# --- KNOWLEDGE BASES ---

# (Fragment Name, SMARTS, Approx m/z, Formula/Cation)
DIAGNOSTIC_FRAGMENTS = [
    ("Indole", "[nH]1cccc2ccccc12", 130, "C9H8N+"),
    ("3-alkyl-indole", "c1ccc2c(c1)[nH]cc2C", 130, "C9H8N+"),
    ("Tropylium", "[CH2]c1ccccc1", 91, "C7H7+"),
    ("Phenyl cation", "c1ccccc1", 77, "C6H5+"),
    ("Phenol", "c1ccc(O)cc1", 94, "C6H6O"), 
    ("Aniline", "c1ccc(N)cc1", 93, "C6H7N"),
    ("Pyridine", "n1ccccc1", 79, "C5H5N+"),
    ("Imidazole", "c1cncn1", 68, "C3H4N2"),
    ("Quinoline/Isoquinoline", "c1ccc2ncccc2c1", 129, "C9H7N+"),
    ("Naphthalene", "c1ccc2ccccc2c1", 128, "C10H8+"),
    ("Acetyl", "CC(=O)", 43, "C2H3O+"),
    ("Methoxy", "CO", 31, "CH3O+"),
    ("Carboxyl", "C(=O)O", 45, "CHO2+"),
    ("Glucuronic Acid", "OC1C(O)C(O)C(O)C(O)O1", 176, "C6H9O6+"),
    ("Rhamnose", "CC1OC(O)C(O)C(O)C1O", 147, "C6H11O4+"),
    ("Hexose (Glucose/Galactose)", "OCC1OC(O)C(O)C(O)C1O", 163, "C6H11O5+"),
    ("Quercetin aglycone", "c1c(O)cc(O)c2c1(=O)c(O)c(c1ccc(O)c(O)c1)o2", 303, "C15H11O7+"),
    ("Kaempferol aglycone", "c1c(O)cc(O)c2c1(=O)c(O)c(c1ccc(O)cc1)o2", 287, "C15H11O6+"),
    ("Apigenin aglycone", "c1c(O)cc(O)c2c1(=O)cc(c1ccc(O)cc1)o2", 271, "C15H11O5+"),
    ("Luteolin aglycone", "c1c(O)cc(O)c2c1(=O)cc(c1ccc(O)c(O)c1)o2", 287, "C15H11O6+"),
    ("Coumarin", "O=C1C=Cc2ccccc2O1", 147, "C9H7O2+"),
    ("Ferulic acid moiety", "COc1cc(C=CC(=O)O)ccc1O", 195, "C10H11O4+"),
]

NEUTRAL_LOSSES_MAP = {
    162.05: "hexose moiety (e.g., glucose/galactose, -162 Da)",
    146.06: "deoxyhexose moiety (e.g., rhamnose, -146 Da)",
    132.04: "pentose moiety (e.g., xylose/arabinose, -132 Da)",
    176.03: "glucuronic acid moiety (-176 Da)",
    308.11: "rutinose (rhamnose-glucose, -308 Da)",
    18.01: "water (H2O, -18 Da)",
    28.00: "CO (-28 Da)",
    44.00: "CO2 (-44 Da)",
    15.02: "methyl group (-15 Da)",
    17.03: "ammonia (NH3, -17 Da)",
    31.02: "methoxy group (-31 Da)",
    32.03: "methanol (-32 Da)",
    42.01: "acetyl group (ketene loss, -42 Da)",
    46.01: "H2O + CO / formic acid (-46 Da)",
    56.03: "C4H8 / retro-Diels-Alder fragment",
    79.96: "sulfate / phosphate loss (approx 80 Da)",
    # Halogen losses
    36.00: "HCl (hydrogen chloride, -36 Da)",
    38.00: "HCl (isotope, -38 Da)",
    80.91: "HBr (hydrogen bromide, -81 Da)",
    78.92: "HBr (isotope, -79 Da)",
    127.90: "HI (hydrogen iodide, -128 Da)",
    19.99: "HF (hydrogen fluoride, -20 Da)"
}

TOLERANCE = 0.5

# --- HELPER FUNCTIONS ---

def match_substructures(smiles: str) -> List[str]:
    """Return list of fragment names present in the molecule."""
    try:
        from rdkit import Chem
        mol = Chem.MolFromSmiles(smiles)
        if mol is None: return []
        found = []
        for name, smarts, _, _ in DIAGNOSTIC_FRAGMENTS:
            try:
                pat = Chem.MolFromSmarts(smarts)
                if pat and mol.HasSubstructMatch(pat):
                    found.append(name)
            except:
                continue
        return found
    except ImportError:
        return []

def calc_dou(formula_str: str) -> float:
    """
    Calculate Degree of Unsaturation.
    DoU = C - H/2 - X/2 + N/2 + 1
    (Where X = F, Cl, Br, I)
    """
    if not formula_str: return 0.0
    
    atoms = {}
    # Parse elements and counts: "C16H17NO4Cl" -> [('C', '16'), ('H', '17')...]
    for match in re.finditer(r"([A-Z][a-z]?)(\d*)", formula_str):
        elem = match.group(1)
        count = int(match.group(2)) if match.group(2) else 1
        atoms[elem] = atoms.get(elem, 0) + count
    
    c = atoms.get('C', 0)
    h = atoms.get('H', 0)
    n = atoms.get('N', 0)
    p = atoms.get('P', 0) # P often treated similar to N in simple heuristics
    
    # Halogens count as H for saturation
    x = atoms.get('F', 0) + atoms.get('Cl', 0) + atoms.get('Br', 0) + atoms.get('I', 0)
    
    # DoU = C + 1 - (H + X)/2 + (N + P)/2
    return c + 1 - (h + x)/2 + (n + p)/2

def precursor_interpretation_deductive(
    found_in_spectrum: bool, 
    mz: float, 
    exact_mw: float, 
    formula: str, 
    adduct: str = "[M+H]+"
) -> List[str]:
    """Generate deductive text about precursor, carefully distinguishing Neutral vs Ion."""
    steps = []
    
    nominal_mass = round(exact_mw)
    
    # 1. Mass Match statement
    if found_in_spectrum:
        delta = mz - exact_mw
        steps.append(f"The precursor ion is observed at m/z {mz:.4f}, consistent with an {adduct} adduct of a neutral molecule with mass {exact_mw:.4f} Da.")
    else:
        steps.append(f"The precursor ion is not observed in the spectrum. The theoretical mass is {exact_mw:.4f} Da.")

    # 2. Nitrogen Rule & Complexity (DoU)
    try:
        dou = calc_dou(formula)
        is_odd_mass = (nominal_mass % 2 != 0)
        
        # Explicitly discuss the NEUTRAL molecule first
        steps.append(f"The neutral nominal mass is {nominal_mass} Da.")
        
        if "N" in formula:
            steps.append(f"Based on the Nitrogen Rule, this {'odd' if is_odd_mass else 'even'} neutral mass indicates an {'odd' if is_odd_mass else 'even'} number of nitrogen atoms.")
        else:
            steps.append(f"The {'even' if not is_odd_mass else 'odd'} neutral mass is consistent with the absence of nitrogen.")
            
        steps.append(f"The calculated Degree of Unsaturation (DoU) is {dou:.1f}, suggesting significant structural complexity (rings/double bonds).")
    except Exception as e:
        pass
        
    return steps

def neutral_loss_analysis(
    precursor_mz: float, 
    peaks: List[Tuple[float, float]], 
    formula: Optional[str]
) -> List[str]:
    """Identify direct neutral losses from precursor with Formula Validation."""
    steps = []
    
    # Parse formula to check for allowed losses
    # Simple count of atoms in the parent formula
    atom_counts = {}
    if formula:
        import re
        for match in re.finditer(r"([A-Z][a-z]?)(\d*)", formula):
            elem = match.group(1)
            count = int(match.group(2)) if match.group(2) else 1
            atom_counts[elem] = atom_counts.get(elem, 0) + count

    # Helper: Can this formula lose this group?
    def is_loss_allowed(loss_name):
        if not formula: return True # Fallback if no formula
        
        loss_lower = loss_name.lower()
        
        # Halogen Checks
        if "chloride" in loss_lower or "hcl" in loss_lower:
            if atom_counts.get("Cl", 0) < 1: return False
        if "bromide" in loss_lower or "hbr" in loss_lower:
            if atom_counts.get("Br", 0) < 1: return False
        if "iodide" in loss_lower or "hi" in loss_lower:
            if atom_counts.get("I", 0) < 1: return False
        if "fluoride" in loss_lower or "hf" in loss_lower:
            if atom_counts.get("F", 0) < 1: return False
            
        # Sugar Checks (Sugars are O-rich)
        # Pentose/Hexose/Rhamnose usually require ~3-4+ Oxygens
        if any(x in loss_lower for x in ["hexose", "pentose", "rhamnose", "glucuronic", "rutinose"]):
            if atom_counts.get("O", 0) < 3: return False
            
        # Ammonia check
        if "ammonia" in loss_lower or "nh3" in loss_lower:
            if atom_counts.get("N", 0) < 1: return False
            
        return True

    # Analysis Loop
    sorted_peaks = sorted(peaks, key=lambda x: x[1], reverse=True)[:10]
    found_losses = []
    
    for mz, _int in sorted_peaks:
        if mz >= precursor_mz - 1.0: continue 
        loss = precursor_mz - mz
        
        best_match = None
        min_diff = 999.0
        
        for ref_loss, name in NEUTRAL_LOSSES_MAP.items():
            diff = abs(loss - ref_loss)
            # Check tolerance AND chemical feasibility
            if diff < TOLERANCE and diff < min_diff:
                if is_loss_allowed(name):
                    min_diff = diff
                    best_match = name
        
        if best_match:
            steps.append(f"A neutral loss of {loss:.2f} Da (m/z {precursor_mz:.2f} -> {mz:.2f}) corresponds to the loss of a {best_match}.")
            found_losses.append(mz)
            
    return steps, found_losses
# --- MAIN BUILDER ---

def build_system2_structured(
    smiles: str,
    peaks: List[List[float]],
    precursor_mz: Optional[float] = None,
    formula: Optional[str] = None,
    max_peaks: int = 20,
) -> Dict[str, Any]:
    """
    Build a structured dictionary containing the reasoning steps.
    """
    from rdkit import Chem
    from rdkit.Chem import Descriptors
    from rdkit.Chem.rdMolDescriptors import CalcMolFormula
    
    mol = Chem.MolFromSmiles(smiles)
    if not mol:
        return {"error": "Invalid SMILES"}
    
    exact_mw = Descriptors.ExactMolWt(mol)
    calc_formula = formula or CalcMolFormula(mol)
    
    # Filter and Sort Peaks
    max_int = max([p[1] for p in peaks]) if peaks else 1.0
    valid_peaks = [(p[0], p[1]) for p in peaks if p[1]/max_int > 0.01]
    valid_peaks.sort(key=lambda x: x[1], reverse=True)
    
    top_peaks = valid_peaks[:max_peaks]
    base_peak = top_peaks[0] if top_peaks else (0,0)
    
    # 1. Precursor Identification
    precursor_info = {
        "found": False, 
        "mz": 0.0, 
        "adduct": "", 
        "deduction": []
    }
    
    # Check spectrum for [M+H]+ or [M+Na]+
    found_in_spectrum = False
    observed_mz = 0.0
    
    if any(abs(mz - (exact_mw + 1.0078)) < TOLERANCE for mz, _ in top_peaks):
        observed_mz = next(mz for mz, _ in top_peaks if abs(mz - (exact_mw + 1.0078)) < TOLERANCE)
        precursor_info["mz"] = observed_mz
        precursor_info["adduct"] = "[M+H]+"
        found_in_spectrum = True
    elif any(abs(mz - (exact_mw + 22.989)) < TOLERANCE for mz, _ in top_peaks):
        observed_mz = next(mz for mz, _ in top_peaks if abs(mz - (exact_mw + 22.989)) < TOLERANCE)
        precursor_info["mz"] = observed_mz
        precursor_info["adduct"] = "[M+Na]+"
        found_in_spectrum = True
    
    # If not found in spectrum, use metadata or calculation, but flag as not found
    if not found_in_spectrum:
        if precursor_mz and precursor_mz > 0:
            precursor_info["mz"] = precursor_mz
            precursor_info["adduct"] = "[M+H]+" # Assume protonated if provided
        else:
            precursor_info["mz"] = exact_mw + 1.0078
            precursor_info["adduct"] = "[M+H]+"
    
    precursor_info["found"] = found_in_spectrum

    # Generate text for precursor
    precursor_info["deduction"] = precursor_interpretation_deductive(
        found_in_spectrum,
        precursor_info["mz"], 
        exact_mw, 
        calc_formula, 
        precursor_info["adduct"]
    )
    
    # 2. Neutral Loss Analysis
    loss_steps, loss_mzs = neutral_loss_analysis(precursor_info["mz"], top_peaks, calc_formula)
    
    # 3. Fragment Analysis (Strict Causal)
    present_substructures = match_substructures(smiles)
    fragment_steps = []
    
    for mz, _int in top_peaks:
        # Check if peak matches a diagnostic fragment
        for name, _smarts, hint_mz, hint_formula in DIAGNOSTIC_FRAGMENTS:
            if abs(mz - hint_mz) < 1.0:
                # CRITICAL: Only claim it if substructure is in molecule
                if name in present_substructures:
                     fragment_steps.append(f"The peak at m/z {mz:.2f} is diagnostic for {name}" + (f" ({hint_formula})." if hint_formula else "."))
                break 
                
    fragment_steps = list(dict.fromkeys(fragment_steps))
    
    # 4. Scaffold/Base Peak
    scaffold_text = ""
    if base_peak[0] > 0:
        if found_in_spectrum and abs(base_peak[0] - precursor_info["mz"]) < 1.0:
            scaffold_text = "The base peak corresponds to the intact precursor, suggesting a stable molecular ion."
        elif loss_mzs and abs(base_peak[0] - loss_mzs[-1]) < 1.0:
            scaffold_text = "The base peak represents the core scaffold after the loss of labile groups."
        else:
             scaffold_text = f"The base peak at m/z {base_peak[0]:.2f} represents the most stable fragment ion."

    return {
        "precursor": precursor_info,
        "losses": loss_steps,
        "fragments": fragment_steps,
        "scaffold": scaffold_text
    }

def format_structured_cot_as_text(structure: Dict[str, Any]) -> str:
    """Convert structured dict to narrative string."""
    parts = []
    
    # Precursor
    if structure.get("error"):
        return structure["error"]
        
    prec = structure["precursor"]
    parts.extend(prec["deduction"])
    
    # Losses
    if structure["losses"]:
        parts.append("Fragmentation analysis reveals characteristic neutral losses:")
        parts.extend(structure["losses"])
    else:
        parts.append("No common neutral losses were clearly identified.")
        
    # Fragments
    if structure["fragments"]:
        parts.append("Diagnostic fragment ions confirm the presence of specific substructures:")
        parts.extend(structure["fragments"])
        
    # Scaffold
    if structure["scaffold"]:
        parts.append(structure["scaffold"])
        
    return " ".join(parts)

def build_system2_thought(
    smiles: str,
    peaks: list[list[float]],
    precursor_mz: Optional[float] = None,
    formula: Optional[str] = None,
    max_peaks: int = 20,
    output_format: str = "text",
) -> str:
    """
    Entry point for generating CoT.
    """
    struct = build_system2_structured(smiles, peaks, precursor_mz, formula, max_peaks)
    
    if output_format == "json":
        return json.dumps(struct, indent=2)
    
    return format_structured_cot_as_text(struct)