//! 块级数据流迭代：gen/kill + reverse_postorder 不动点。
//!
//! gen/kill 直接消费 `oxide_ir::contract` 的 `def_reg`/`use_regs`，
//! None→0 / This→254 / NewTarget→255 / CALL 隐式 reg0 全内置，不重复建。
//! Exception 边当普通边参与迭代；Exception 目标块入口 reg 0 隐式 def
//! （异常展开写 regs[0]，vm_runtime.rs:204-205）在此建模：gen.remove(0)+kill.insert(0)。

use oxide_cfg::{Cfg, EdgeKind};
use oxide_ir::IRFunction;

/// 块级 liveness：返回 (block_live_in, block_live_out, reg_count)。
/// reg_count = 全部 def/use 最大 reg 号（bitset 长度 = reg_count+1）。
pub(super) fn block_liveness(f: &IRFunction, cfg: &Cfg) -> (Vec<Vec<bool>>, Vec<Vec<bool>>, usize) {
    // 1. reg_count 上界扫描（不信任 f.n_registers，动态求上界，照 iter_sweep 先例）
    let mut reg_count = 255usize; // 兜底 This/NewTarget 254/255
    for inst in &f.insts {
        if let Some(d) = inst.def_reg() {
            reg_count = reg_count.max(d as usize);
        }
        for u in inst.use_regs() {
            reg_count = reg_count.max(u as usize);
        }
    }

    let bits = reg_count + 1;
    let n = cfg.blocks.len();

    // 2. 每块 gen/kill
    let mut gen: Vec<Vec<bool>> = vec![vec![false; bits]; n];
    let mut kill: Vec<Vec<bool>> = vec![vec![false; bits]; n];
    for (b, block) in cfg.blocks.iter().enumerate() {
        // gen：块内反向扫描，kill 先于 gen（`live = (live − def) ∪ use`）。
        // 顺序理由：COMPOUND_ADD 等读-写同寄存器指令 use 含 rd（contract.rs:137），
        // gen 先于 kill 会把 rd 旧值从 live_before 错误剔除。
        let mut live = vec![false; bits];
        for i in block.inst_range.clone().rev() {
            if let Some(d) = f.insts[i].def_reg() {
                live[d as usize] = false;
            }
            for u in f.insts[i].use_regs() {
                live[u as usize] = true;
            }
        }
        gen[b] = live;

        // kill：块内正向扫描，def_reg 非 None 即插入
        for i in block.inst_range.clone() {
            if let Some(d) = f.insts[i].def_reg() {
                kill[b][d as usize] = true;
            }
        }

        // Exception 目标块：入口 reg 0 隐式 def（异常展开在块外写 regs[0]）。
        // gen 去 0 防"无 def use"把活度污染到函数入口；kill 插 0 防 0 从任何 pred 流入。
        // 注：preds 是 Vec<BBId>（无 EdgeKind），须从源块 succs 侧检测 Exception 边。
        let is_exception_target = cfg
            .blocks
            .iter()
            .any(|src| src.succs.iter().any(|&(dst, k)| dst == b && k == EdgeKind::Exception));
        if is_exception_target {
            gen[b][0] = false;
            kill[b][0] = true;
        }
    }

    // 3. reverse_postorder（确定性，禁 HashMap 迭代序）
    let rpo = reverse_postorder(cfg);

    // 4. 不动点迭代
    let mut live_in = vec![vec![false; bits]; n];
    let mut live_out = vec![vec![false; bits]; n];
    let mut iters = 0usize;
    loop {
        let mut changed = false;
        for &b in &rpo {
            // live_out[b] = ∪ live_in[s]（全部 succs，含 Exception 边当普通边）
            let mut out = vec![false; bits];
            for &(succ, _kind) in &cfg.blocks[b].succs {
                for (r, &v) in live_in[succ].iter().enumerate() {
                    if v {
                        out[r] = true;
                    }
                }
            }
            // live_in[b] = gen[b] | (live_out[b] − kill[b])
            let mut input = vec![false; bits];
            for r in 0..bits {
                input[r] = gen[b][r] || (out[r] && !kill[b][r]);
            }
            if input != live_in[b] || out != live_out[b] {
                changed = true;
                live_in[b] = input;
                live_out[b] = out;
            }
        }
        if !changed {
            break;
        }
        iters += 1;
        debug_assert!(iters < cfg.blocks.len() * 2 + 16, "liveness 不动点疑似不收敛");
    }

    (live_in, live_out, reg_count)
}

/// 从 entry 出发 DFS 沿 succs 存储序（确定序）收集 postorder 后反转；
/// 不可达块按升序追加在末尾。纯 Vec + visited 位图，保证确定性。
fn reverse_postorder(cfg: &Cfg) -> Vec<usize> {
    let n = cfg.blocks.len();
    let mut visited = vec![false; n];
    let mut postorder = Vec::with_capacity(n);
    fn dfs(cfg: &Cfg, visited: &mut [bool], postorder: &mut Vec<usize>, b: usize) {
        visited[b] = true;
        for &(succ, _) in &cfg.blocks[b].succs {
            if !visited[succ] {
                dfs(cfg, visited, postorder, succ);
            }
        }
        postorder.push(b);
    }
    dfs(cfg, &mut visited, &mut postorder, cfg.entry);
    postorder.reverse();
    for (b, &vis) in visited.iter().enumerate() {
        if !vis {
            postorder.push(b);
        }
    }
    postorder
}

#[cfg(test)]
mod tests {
    use super::*;
    use oxide_bytecode::opcode::OpCode;
    use oxide_ir::inst::Inst;
    use oxide_ir::operand::Operand;

    fn set(v: &[bool], regs: &[u32]) -> bool {
        regs.iter().all(|&r| v[r as usize])
    }

    fn empty_function() -> IRFunction {
        IRFunction::new()
    }

    #[test]
    fn linear_function_liveness() {
        let mut f = empty_function();
        f.insts
            .push(Inst::new(OpCode::ADD, Operand::Reg(2), Operand::Reg(0), Operand::Reg(1)));
        f.insts
            .push(Inst::new(OpCode::RETURN, Operand::Reg(2), Operand::None, Operand::None));
        let cfg = oxide_cfg::build_cfg(&f);
        let (live_in, live_out, reg_count) = block_liveness(&f, &cfg);
        assert!(reg_count >= 2);
        assert!(set(&live_in[0], &[0, 1]), "entry liveIn 应含 0、1");
        assert!(!live_in[0][2], "r2 是 def 不应在 liveIn");
        assert!(set(&live_out[0], &[]), "live_out 空");
        // exit 哨兵为空块，live 全空
        let exit = cfg.exit;
        assert!(live_in[exit].iter().all(|&v| !v));
        assert!(live_out[exit].iter().all(|&v| !v));
    }

    #[test]
    fn if_else_join_unions_live_sets() {
        // 0: jmp_if_false(1, L1)   cond=Reg(1)
        // 1: ADD r3=r3+r2           def 3 use {3,2}
        // 2: jmp L2
        // 3: SUB r4=r4+r5           def 4 use {4,5}
        // 4: NOP
        // 5: RETURN Reg(6)
        let mut f = empty_function();
        f.insts.push(Inst::jmp_if_false(1, 1));
        f.insts
            .push(Inst::new(OpCode::ADD, Operand::Reg(3), Operand::Reg(3), Operand::Reg(2)));
        f.insts.push(Inst::jmp(2));
        f.insts
            .push(Inst::new(OpCode::SUB, Operand::Reg(4), Operand::Reg(4), Operand::Reg(5)));
        f.insts
            .push(Inst::new(OpCode::NOP, Operand::None, Operand::None, Operand::None));
        f.insts
            .push(Inst::new(OpCode::RETURN, Operand::Reg(6), Operand::None, Operand::None));
        f.label_pos = vec![None, Some(3), Some(4)];
        f.label_count = 3;
        let cfg = oxide_cfg::build_cfg(&f);
        let (live_in, _, _) = block_liveness(&f, &cfg);
        // join 块（NOP 所在块）liveIn 含 6（RETURN 用）
        let join = cfg.blocks.iter().position(|b| b.inst_range == (4..6usize)).unwrap();
        assert!(live_in[join][6], "join 块 liveIn 应含 r6");
        // then 分支块 liveIn 含 2、3，不含 5
        let then = cfg.blocks.iter().position(|b| b.inst_range == (1..3usize)).unwrap();
        assert!(set(&live_in[then], &[2, 3]));
        assert!(!live_in[then][5]);
        // else 分支块 liveIn 含 4、5，不含 2
        let els = cfg.blocks.iter().position(|b| b.inst_range == (3..4usize)).unwrap();
        assert!(set(&live_in[els], &[4, 5]));
        assert!(!live_in[els][2]);
    }

    #[test]
    fn loop_back_edge_keeps_value_alive() {
        // 0: jmp_if_false(1, L1)
        // 1: ADD r3=r3+r2
        // 2: jmp L0
        // 3: NOP
        // 4: RETURN Reg(6)
        let mut f = empty_function();
        f.insts.push(Inst::jmp_if_false(1, 1));
        f.insts
            .push(Inst::new(OpCode::ADD, Operand::Reg(3), Operand::Reg(3), Operand::Reg(2)));
        f.insts.push(Inst::jmp(0));
        f.insts
            .push(Inst::new(OpCode::NOP, Operand::None, Operand::None, Operand::None));
        f.insts
            .push(Inst::new(OpCode::RETURN, Operand::Reg(6), Operand::None, Operand::None));
        f.label_pos = vec![Some(0), Some(3)];
        f.label_count = 2;
        let cfg = oxide_cfg::build_cfg(&f);
        let (live_in, _, _) = block_liveness(&f, &cfg);
        // header 块（含 inst 0）liveIn 含 2（r2 跨回边存活）与 1（cond）
        assert!(live_in[0][1], "header liveIn 应含 cond r1");
        assert!(live_in[0][2], "header liveIn 应含 r2（跨回边存活）");
        // body 块 liveIn 含 2
        let body = cfg.blocks.iter().position(|b| b.inst_range == (1..3usize)).unwrap();
        assert!(live_in[body][2]);
        // 测试通过本身即不动点收敛证明
    }

    #[test]
    fn try_catch_reg0_not_polluting_entry() {
        // 0: try_begin(L_catch)
        // 1: ADD r3=r3+r2
        // 2: RETURN Reg(3)
        // 3: STORE_VAR(Reg(5), None, None)   catch 入口：a=None→0 读 reg 0
        // 4: RETURN Reg(5)
        let mut f = empty_function();
        f.insts.push(Inst::try_begin(3));
        f.insts
            .push(Inst::new(OpCode::ADD, Operand::Reg(3), Operand::Reg(3), Operand::Reg(2)));
        f.insts
            .push(Inst::new(OpCode::RETURN, Operand::Reg(3), Operand::None, Operand::None));
        f.insts
            .push(Inst::new(OpCode::STORE_VAR, Operand::Reg(5), Operand::None, Operand::None));
        f.insts
            .push(Inst::new(OpCode::RETURN, Operand::Reg(5), Operand::None, Operand::None));
        f.label_pos = vec![None, None, None, Some(3)];
        f.label_count = 1;
        let cfg = oxide_cfg::build_cfg(&f);
        let (live_in, _, _) = block_liveness(&f, &cfg);
        // catch 块 liveIn 不含 0（隐式 def 截断）
        let catch = cfg.blocks.iter().position(|b| b.inst_range == (3..5usize)).unwrap();
        assert!(!live_in[catch][0], "catch 块入口 reg0 应被隐式 def 截断");
        // try 块（entry）liveIn 不含 0（未污染入口）
        assert!(!live_in[0][0], "reg0 use 不得污染函数入口");
        // try 块 liveIn 含 2（正常变量照常存活）
        assert!(live_in[0][2], "try 块 liveIn 应含 r2");
    }

    #[test]
    fn none_operand_maps_to_reg0() {
        // 0: LOAD_VAR(Reg(5), None, None)   def 5 use {0}
        // 1: HALT(None, None, None)          contract.rs HALT 读 regs[0]
        let mut f = empty_function();
        f.insts
            .push(Inst::new(OpCode::LOAD_VAR, Operand::Reg(5), Operand::None, Operand::None));
        f.insts
            .push(Inst::new(OpCode::HALT, Operand::None, Operand::None, Operand::None));
        let cfg = oxide_cfg::build_cfg(&f);
        let (live_in, _, _) = block_liveness(&f, &cfg);
        assert!(live_in[0][0], "None→0 映射由 contract.rs 消费生效");
    }
}