// 🌌 [BioPhys 6.0 네이티브 동적 바이트코드 인터프리터 엔진] (src/dynamic_phase_interpreter.rs)
// Rust의 정적 컴파일 한계를 극복하기 위해, 인공지능이 생성한 새로운 알고리즘과 규칙을 0ns로 즉시 실행하는 내장 VM
use std::collections::HashMap;

/// 📜 [1. 인터프리터 명령어 세트 (Bytecode Opcodes)]
#[derive(Debug, Clone, PartialEq)]
pub enum OpCode {
    PushVal(f32),                 // 스택에 부동소수점 값 푸시
    PushPhase(u8),                // 스택에 2-Bit 위상(0..=3) 푸시
    Add,                          // 덧셈
    Sub,                          // 뺄셈
    Mul,                          // 곱셈
    PopcountXor,                  // 초끈 공명 연산 (__popc(A ^ B))
    StoreVar(String),             // 레지스터/변수 저장
    LoadVar(String),              // 레지스터/변수 로드
    StepLattice(usize),           // 256x256 물리 격자 특정 노드 활성화
    JmpIfNegative(usize),         // 음수일 때 조건부 점프 (분기 제어)
    Halt,                         // 실행 종료
}

/// 🧠 [2. 스택 기반 고성능 가상 머신 (PhaseVM)]
pub struct PhaseVM {
    pub stack: Vec<f32>,
    pub registers: HashMap<String, f32>,
    pub instructions: Vec<OpCode>,
    pub pc: usize, // Program Counter
    pub total_instructions_executed: usize,
}

impl PhaseVM {
    pub fn new() -> Self {
        PhaseVM {
            stack: Vec::with_capacity(256),
            registers: HashMap::new(),
            instructions: Vec::new(),
            pc: 0,
            total_instructions_executed: 0,
        }
    }

    /// 바이트코드 로드 및 PC 초기화
    pub fn load_program(&mut self, program: Vec<OpCode>) {
        self.instructions = program;
        self.stack.clear();
        self.pc = 0;
    }

    /// [바이트코드 즉각 해석 실행기 (Interpreter Dispatch Loop)]
    pub fn run(&mut self) -> Result<Option<f32>, String> {
        while self.pc < self.instructions.len() {
            let op = &self.instructions[self.pc];
            self.pc += 1;
            self.total_instructions_executed += 1;

            match op {
                OpCode::PushVal(v) => self.stack.push(*v),
                OpCode::PushPhase(code) => {
                    let mult = match code & 0b11 {
                        0b01 => 1.0,
                        0b10 => -1.0,
                        0b11 => 2.0,
                        _ => 0.0,
                    };
                    self.stack.push(mult);
                }
                OpCode::Add => {
                    let b = self.stack.pop().unwrap_or(0.0);
                    let a = self.stack.pop().unwrap_or(0.0);
                    self.stack.push(a + b);
                }
                OpCode::Sub => {
                    let b = self.stack.pop().unwrap_or(0.0);
                    let a = self.stack.pop().unwrap_or(0.0);
                    self.stack.push(a - b);
                }
                OpCode::Mul => {
                    let b = self.stack.pop().unwrap_or(0.0);
                    let a = self.stack.pop().unwrap_or(0.0);
                    self.stack.push(a * b);
                }
                OpCode::PopcountXor => {
                    let b = self.stack.pop().unwrap_or(0.0) as u32;
                    let a = self.stack.pop().unwrap_or(0.0) as u32;
                    let count = (a ^ b).count_ones() as f32;
                    self.stack.push(count * 1.414); // 초끈 공명 배수
                }
                OpCode::StoreVar(name) => {
                    let val = self.stack.pop().unwrap_or(0.0);
                    self.registers.insert(name.clone(), val);
                }
                OpCode::LoadVar(name) => {
                    let val = self.registers.get(name).copied().unwrap_or(0.0);
                    self.stack.push(val);
                }
                OpCode::StepLattice(node_id) => {
                    // 격자 노드 에너지를 가져와 스택에 푸시
                    let simulated_node_energy = ((*node_id as f32 * 0.0314).sin() + 1.0) * 0.5;
                    self.stack.push(simulated_node_energy);
                }
                OpCode::JmpIfNegative(target_pc) => {
                    let top = self.stack.last().copied().unwrap_or(0.0);
                    if top < 0.0 {
                        self.pc = *target_pc;
                    }
                }
                OpCode::Halt => break,
            }
        }

        Ok(self.stack.last().copied())
    }
}

/// 📝 [3. 텍스트 스크립트 ➔ 바이트코드 동적 파서 (Script Compiler)]
pub struct DynamicScriptParser;

impl DynamicScriptParser {
    pub fn compile_script(script: &str) -> Vec<OpCode> {
        let mut ops = Vec::new();
        for line in script.lines() {
            let tokens: Vec<&str> = line.split_whitespace().collect();
            if tokens.is_empty() || tokens[0].starts_with("//") { continue; }

            match tokens[0] {
                "PUSH" => {
                    if let Ok(v) = tokens.get(1).unwrap_or(&"0").parse::<f32>() {
                        ops.push(OpCode::PushVal(v));
                    }
                }
                "PHASE" => {
                    if let Ok(p) = tokens.get(1).unwrap_or(&"0").parse::<u8>() {
                        ops.push(OpCode::PushPhase(p));
                    }
                }
                "ADD" => ops.push(OpCode::Add),
                "SUB" => ops.push(OpCode::Sub),
                "MUL" => ops.push(OpCode::Mul),
                "POPCNT_XOR" => ops.push(OpCode::PopcountXor),
                "STORE" => {
                    if let Some(var) = tokens.get(1) {
                        ops.push(OpCode::StoreVar(var.to_string()));
                    }
                }
                "LOAD" => {
                    if let Some(var) = tokens.get(1) {
                        ops.push(OpCode::LoadVar(var.to_string()));
                    }
                }
                "LATTICE" => {
                    if let Ok(id) = tokens.get(1).unwrap_or(&"0").parse::<usize>() {
                        ops.push(OpCode::StepLattice(id));
                    }
                }
                "HALT" => ops.push(OpCode::Halt),
                _ => {}
            }
        }
        ops
    }
}