# RAIJINLANG // THE PHYSICS OF LANGUAGE
# Vowels = x5 Energy | Consonants = x2 Mass

RAIJIN_ALPHABET = {
    'A': 5,   'B': 4,   'C': 6,   'D': 8,   'E': 25,  'F': 12,  'G': 14,  'H': 16,
    'I': 45,  'J': 20,  'K': 22,  'L': 24,  'M': 26,  'N': 28,  'O': 75,  'P': 32,
    'Q': 34,  'R': 36,  'S': 38,  'T': 40,  'U': 105, 'V': 44,  'W': 46,  'X': 48,
    'Y': 50,  'Z': 52
}

# --- KEYWORD CHASSIS (ROBUST EDITION) ---
KEYWORDS = {
    # CORE
    "rise": 86, "fall": 65, "form": 115, "end": 57, "flow": 141,
    # VARIABLE
    "bind": 61, "shift": 143, "carry": 114, "hold": 119, "free": 76, "mark": 96, "trace": 131,
    # MATH
    "plus": 166, "minus": 145, "times": 154, "over": 128, "raise": 116, "root": 190, "merge": 139, "split": 151,
    # CONTROL
    "pulse": 224, "while": 143, "when": 73, "else": 83, "drift": 102, "surge": 182, "halt": 70,
    # I/O
    "echo": 122, "listen": 141, "call": 44, "send": 69, "draw": 72,
    # PHYSICS
    "charge": 105, "ground": 169, "spark": 102, "weigh": 154, "phase": 107, "align": 112, "storm": 215,
    # ERROR
    "static": 145, "noise": 139, "void": 229, "overload": 222, "silence": 164, "break": 107,
    # SYSTEM
    "core": 120, "meta": 111, "inner": 142, "outer": 184, "link": 95
}

class RaijinInterpreter:
    def __init__(self):
        self.registry = {}
        self.pressure = 0.0
        self.envelope_active = False

    @staticmethod
    def calc_energy(text: str) -> int:
        """Calculates total Raijin Energy Units (REUs) for a given text."""
        return sum(RAIJIN_ALPHABET.get(char.upper(), 0) for char in text if char.isalpha())

    @staticmethod
    def resonate(text: str) -> float:
        """Calculates the resonance frequency of a text."""
        energy = RaijinInterpreter.calc_energy(text)
        length = len([c for c in text if c.isalpha()])
        return energy / length if length > 0 else 0.0

    def execute(self, script: str):
        """Executes a RaijinLang script stochastically within an envelope."""
        tokens = script.lower().split()
        ptr = 0
        
        while ptr < len(tokens):
            token = tokens[ptr]
            
            # CORE: The Envelope
            if token == "rise":
                self.envelope_active = True
                ptr += 1
                continue
            elif token == "fall":
                self.envelope_active = False
                break
                
            if not self.envelope_active:
                print("[RaijinLang] ERROR: No signal detected. Program must start with 'rise'.")
                return

            # VARIABLE: The Spark
            if token == "spark":
                name = tokens[ptr+1]
                source = tokens[ptr+2]
                self.registry[name] = self.calc_energy(source)
                ptr += 2
            
            # STRUCTURE: The Form
            elif token == "form":
                name = tokens[ptr+1]
                self.registry[name] = {"_type": "form", "nodes": {}}
                ptr += 1
            elif token == "bind" and ptr > 0 and tokens[ptr-1] != "spark":
                # Inside a form: bind <key> to <source>
                key = tokens[ptr+1]
                # skip 'to'
                source = tokens[ptr+3]
                # Find the last defined form
                last_form = list(self.registry.keys())[-1]
                if isinstance(self.registry[last_form], dict):
                    self.registry[last_form]["nodes"][key] = self.calc_energy(source)
                ptr += 3
            
            # I/O: The Echo
            elif token == "echo":
                name = tokens[ptr+1]
                val = self.registry.get(name, "void")
                print(f"[RaijinLang] ECHO: {name} = {val}")
                ptr += 1
            
            # PHYSICS: Scaling and Superposition
            elif token == "charge":
                name = tokens[ptr+1]
                factor = int(tokens[ptr+2]) if ptr+2 < len(tokens) else 1
                if name in self.registry:
                    self.registry[name] *= factor
                ptr += 2
            elif token == "plus":
                target = tokens[ptr+1]
                source = tokens[ptr+2]
                # target += source (if source is variable) or target += energy(source)
                add_val = self.registry.get(source, self.calc_energy(source))
                if target in self.registry:
                    self.registry[target] += add_val
                ptr += 2
            
            ptr += 1

# --- TEST DRIVE v0.2 ---
if __name__ == "__main__":
    ri = RaijinInterpreter()
    # rise spark storm thunder plus storm lightning echo storm fall
    ri.execute("rise spark storm thunder plus storm lightning echo storm fall")
