hakorune/src/runner/mir_json_v0.rs

use crate::mir::{
    function::{FunctionSignature, MirFunction, MirModule},
    BasicBlock, BasicBlockId, ConstValue, EffectMask, MirInstruction, MirType, ValueId,
};
use serde_json::Value;
use super::mir_json::common as mirjson_common;

/// Parse minimal MIR JSON v0 (no schema_version, root has `functions` and each function has `blocks`).
/// Supported ops (minimal): const(i64), copy, compare(op/lhs/rhs), branch(cond/then/else), jump(target), phi(dst,incoming), ret(value?).
pub fn parse_mir_v0_to_module(json: &str) -> Result<MirModule, String> {
    let value: Value = serde_json::from_str(json).map_err(|e| format!("invalid JSON: {}", e))?;
    let functions = value
        .get("functions")
        .and_then(|f| f.as_array())
        .ok_or_else(|| "JSON missing functions array".to_string())?;

    let mut module = MirModule::new("mir_json_v0".to_string());

    for func in functions {
        let func_name = func
            .get("name")
            .and_then(|n| n.as_str())
            .unwrap_or("main")
            .to_string();

        let blocks = func
            .get("blocks")
            .and_then(|b| b.as_array())
            .ok_or_else(|| format!("function '{}' missing blocks array", func_name))?;

        if blocks.is_empty() {
            return Err(format!("function '{}' has no blocks", func_name));
        }

        let entry_id = blocks
            .get(0)
            .and_then(|b| b.get("id"))
            .and_then(|id| id.as_u64())
            .ok_or_else(|| format!("function '{}' entry block missing id", func_name))? as u32;
        let entry_bb = BasicBlockId::new(entry_id);

        let mut signature = FunctionSignature {
            name: func_name.clone(),
            params: Vec::new(),
            return_type: MirType::Unknown,
            effects: crate::mir::EffectMask::PURE,
        };
        let mut mir_fn = MirFunction::new(signature.clone(), entry_bb);
        let mut max_value_id: u32 = 0;

        for block in blocks {
            let block_id = block
                .get("id")
                .and_then(|id| id.as_u64())
                .ok_or_else(|| format!("function '{}' block missing id", func_name))? as u32;
            let bb_id = BasicBlockId::new(block_id);
            if mir_fn.get_block(bb_id).is_none() {
                mir_fn.add_block(BasicBlock::new(bb_id));
            }
            let block_ref = mir_fn
                .get_block_mut(bb_id)
                .expect("block must exist after insertion");

            let instructions = block
                .get("instructions")
                .and_then(|insts| insts.as_array())
                .ok_or_else(|| format!("function '{}' block {} missing instructions array", func_name, block_id))?;

            for inst in instructions {
                let op = inst
                    .get("op")
                    .and_then(|o| o.as_str())
                    .ok_or_else(|| format!("function '{}' block {} missing op field", func_name, block_id))?;
                match op {
                    "const" => {
                        let dst = require_u64(inst, "dst", "const dst")? as u32;
                        let vobj = inst.get("value").ok_or_else(|| "const missing value".to_string())?;
                        let val = parse_const_value(vobj)?;
                        block_ref.add_instruction(MirInstruction::Const { dst: ValueId::new(dst), value: val });
                        max_value_id = max_value_id.max(dst + 1);
                    }
                    "copy" => {
                        let dst = require_u64(inst, "dst", "copy dst")? as u32;
                        let src = require_u64(inst, "src", "copy src")? as u32;
                        block_ref.add_instruction(MirInstruction::Copy { dst: ValueId::new(dst), src: ValueId::new(src) });
                        max_value_id = max_value_id.max(dst + 1);
                    }
                    "binop" => {
                        let dst = require_u64(inst, "dst", "binop dst")? as u32;
                        let lhs = require_u64(inst, "lhs", "binop lhs")? as u32;
                        let rhs = require_u64(inst, "rhs", "binop rhs")? as u32;
                        let operation = inst.get("operation").and_then(Value::as_str).ok_or_else(|| "binop missing operation".to_string())?;
                        let bop = parse_binop(operation)?;
                        block_ref.add_instruction(MirInstruction::BinOp { dst: ValueId::new(dst), op: bop, lhs: ValueId::new(lhs), rhs: ValueId::new(rhs) });
                        max_value_id = max_value_id.max(dst + 1);
                    }
                    "compare" => {
                        let dst = require_u64(inst, "dst", "compare dst")? as u32;
                        let lhs = require_u64(inst, "lhs", "compare lhs")? as u32;
                        let rhs = require_u64(inst, "rhs", "compare rhs")? as u32;
                        let operation = inst.get("operation").and_then(Value::as_str).unwrap_or("==");
                        let cop = parse_compare(operation)?;
                        block_ref.add_instruction(MirInstruction::Compare { dst: ValueId::new(dst), op: cop, lhs: ValueId::new(lhs), rhs: ValueId::new(rhs) });
                        max_value_id = max_value_id.max(dst + 1);
                    }
                    "branch" => {
                        let cond = require_u64(inst, "cond", "branch cond")? as u32;
                        let then_bb = require_u64(inst, "then", "branch then")? as u32;
                        let else_bb = require_u64(inst, "else", "branch else")? as u32;
                        block_ref.add_instruction(MirInstruction::Branch { condition: ValueId::new(cond), then_bb: BasicBlockId::new(then_bb), else_bb: BasicBlockId::new(else_bb) });
                    }
                    "jump" => {
                        let target = require_u64(inst, "target", "jump target")? as u32;
                        block_ref.add_instruction(MirInstruction::Jump { target: BasicBlockId::new(target) });
                    }
                    "phi" => {
                        let dst = require_u64(inst, "dst", "phi dst")? as u32;
                        let incoming = inst.get("incoming").and_then(Value::as_array).ok_or_else(|| "phi incoming missing".to_string())?;
                        let mut pairs = Vec::with_capacity(incoming.len());
                        for entry in incoming {
                            let pair = entry.as_array().ok_or_else(|| "phi incoming entry must be array".to_string())?;
                            if pair.len() != 2 { return Err("phi incoming entry must have 2 elements".into()); }
                            let val = pair[0].as_u64().ok_or_else(|| "phi incoming value must be integer".to_string())? as u32;
                            let bb = pair[1].as_u64().ok_or_else(|| "phi incoming block must be integer".to_string())? as u32;
                            pairs.push((BasicBlockId::new(bb), ValueId::new(val)));
                        }
                        block_ref.add_instruction(MirInstruction::Phi { dst: ValueId::new(dst), inputs: pairs });
                        max_value_id = max_value_id.max(dst + 1);
                    }
                    "ret" => {
                        let value = inst.get("value").and_then(|v| v.as_u64()).map(|v| ValueId::new(v as u32));
                        block_ref.add_instruction(MirInstruction::Return { value });
                        if let Some(val) = value { signature.return_type = MirType::Integer; max_value_id = max_value_id.max(val.as_u32() + 1); } else { signature.return_type = MirType::Void; }
                    }
                    "newbox" => {
                        let dst = require_u64(inst, "dst", "newbox dst")? as u32;
                        let ty = inst.get("type").and_then(Value::as_str).ok_or_else(|| "newbox missing type".to_string())?.to_string();
                        let args_v = inst.get("args").and_then(Value::as_array).cloned().unwrap_or_default();
                        let mut args: Vec<ValueId> = Vec::with_capacity(args_v.len());
                        for a in args_v {
                            let id = a.as_u64().ok_or_else(|| "newbox arg must be integer".to_string())? as u32;
                            args.push(ValueId::new(id));
                        }
                        block_ref.add_instruction(MirInstruction::NewBox { dst: ValueId::new(dst), box_type: ty, args });
                        max_value_id = max_value_id.max(dst + 1);
                    }
                    "boxcall" => {
                        // { op:"boxcall", box:<vid>, method:"name", args:[vid...], dst?:<vid> }
                        let box_id = require_u64(inst, "box", "boxcall box")? as u32;
                        let method = inst.get("method").and_then(Value::as_str).ok_or_else(|| "boxcall missing method".to_string())?.to_string();
                        let dst_opt = inst.get("dst").and_then(Value::as_u64).map(|v| ValueId::new(v as u32));
                        let args_v = inst.get("args").and_then(Value::as_array).cloned().unwrap_or_default();
                        let mut args: Vec<ValueId> = Vec::with_capacity(args_v.len());
                        for a in args_v {
                            let id = a.as_u64().ok_or_else(|| "boxcall arg must be integer".to_string())? as u32;
                            args.push(ValueId::new(id));
                        }
                        block_ref.add_instruction(MirInstruction::BoxCall {
                            dst: dst_opt,
                            box_val: ValueId::new(box_id),
                            method,
                            method_id: None,
                            args,
                            effects: EffectMask::READ,
                        });
                        if let Some(dv) = dst_opt { max_value_id = max_value_id.max(dv.as_u32() + 1); }
                    }
                    other => {
                        return Err(format!("unsupported op '{}' in mir_json_v0 loader", other));
                    }
                }
            }
        }

        // Set max value id (best effort)
        mir_fn.next_value_id = max_value_id;
        module.functions.insert(func_name.clone(), mir_fn);
    }

    Ok(module)
}

fn require_u64(node: &Value, key: &str, context: &str) -> Result<u64, String> {
    node.get(key).and_then(Value::as_u64).ok_or_else(|| format!("{} missing field '{}'", context, key))
}

fn parse_const_value(value_obj: &Value) -> Result<ConstValue, String> {
    // Delegate to common generic parser (int/float/bool/string/handle(StringBox))
    // Keeps behavior superset of previous (int-only) without changing existing callers.
    mirjson_common::parse_const_value_generic(value_obj).map_err(|e| format!("{}", e))
}

fn parse_compare(op: &str) -> Result<crate::mir::types::CompareOp, String> {
    use crate::mir::types::CompareOp;
    Ok(match op {
        "==" => CompareOp::Eq,
        "!=" => CompareOp::Ne,
        "<" => CompareOp::Lt,
        "<=" => CompareOp::Le,
        ">" => CompareOp::Gt,
        ">=" => CompareOp::Ge,
        s => return Err(format!("unsupported compare op '{}'", s)),
    })
}

fn parse_binop(op: &str) -> Result<crate::mir::types::BinaryOp, String> {
    use crate::mir::types::BinaryOp;
    Ok(match op {
        "+" => BinaryOp::Add,
        "-" => BinaryOp::Sub,
        "*" => BinaryOp::Mul,
        "/" => BinaryOp::Div,
        "%" => BinaryOp::Mod,
        s => return Err(format!("unsupported binary op '{}'", s)),
    })
}