use std::collections::HashMap;
use std::fmt;
use std::fs;

struct UMState {
    program_counter: u32,
    regs: [u32; 8],
    mem: Vec<u32>
}



enum UMOp {
    ConditionalMove(u8, u8, u8),
    ArrayIndex(u8, u8, u8),
    ArrayAmend(u8, u8, u8),
    Add(u8, u8, u8),
    Mult(u8, u8, u8),
    Div(u8, u8, u8),
    NotAnd(u8, u8, u8),

    Halt,
    Allocate(u8, u8),
    Abandon(u8),
    Output(u8),
    Input(u8),
    Load(u8, u8),

    Value(u8, u32),
}


fn reg(i:u8) -> &'static str {
    match i {
        0 => "A",
        1 => "B",
        2 => "C",
        3 => "D",
        4 => "E",
        5 => "F",
        6 => "G",
        7 => "H",
        _ => panic!("Bad register! {}",i)
    }
}

impl fmt::Display for UMOp {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let repr = match self {
            UMOp::ConditionalMove(a, b, c) =>
                format!("Conditional #{} <- {} ? #{} : #{}",
                        reg(*a),
                        reg(*c),
                        reg(*b),
                        reg(*a)),
            UMOp::ArrayIndex(a, b, c) =>
                format!("ArrIndex #{} <- #{}[#{}]",
                        reg(*a),
                        reg(*b),
                        reg(*c)),
            UMOp::ArrayAmend(a, b, c) =>
                format!("ArrAmend #{}[#{}] <- #{}",
                        reg(*a),
                        reg(*b),
                        reg(*c)),
            UMOp::Add(a, b, c) =>
                format!("Add #{} <- #{} + #{}",
                        reg(*a),
                        reg(*b),
                        reg(*c)),
            UMOp::Mult(a, b, c) =>
                format!("Mult #{} <- #{} * #{}",
                        reg(*a),
                        reg(*b),
                        reg(*c)),
            UMOp::Div(a, b, c) =>
                format!("Div #{} <- #{} / #{}",
                        reg(*a),
                        reg(*b),
                        reg(*c)),
            UMOp::NotAnd(a, b, c) =>
                format!("NotAnd #{} <- #{} !&& #{}",
                        reg(*a),
                        reg(*b),
                        reg(*c)),
            UMOp::Halt =>
                format!("Halt!"),
            UMOp::Allocate(b, c) =>
                format!("Alloc #{} <- [#{}]",
                        reg(*b),
                        reg(*c)),
            UMOp::Abandon(c) =>
                format!("Abandon @#{}",
                        reg(*c)),
            UMOp::Output(c) =>
                format!("Output #{}",
                        reg(*c)),
            UMOp::Input(c) =>
                format!("Output #{} <-",
                        reg(*c)),
            UMOp::Load(b, c) =>
                format!("Load <- #{}[#{}]",
                        reg(*b),
                        reg(*c)),
            UMOp::Value(a, val) =>
                format!("Value <- #{} <- $#{}",
                        reg(*a),
                        val),
        };
        write!(f, "{}", repr)
    }
}

fn num_extract(masks_map: &HashMap<&str, (u32,u32)>,
               num: u32, mask_name: &str) -> u32 {
    let masktup = masks_map.get(mask_name).unwrap();
    (num & masktup.0) >> masktup.1
}

fn parse_instr(masks_map: HashMap<&str, (u32,u32)>,
               instr: u32) -> UMOp {
    let opcode = num_extract(&masks_map, instr, "op_mask");
    let rega   = num_extract(&masks_map, instr, "rega_mask") as u8;
    let regb   = num_extract(&masks_map, instr, "regb_mask") as u8;
    let regc   = num_extract(&masks_map, instr, "regc_mask") as u8;
    let alta   = num_extract(&masks_map, instr, "alta_mask") as u8;
    let val    = num_extract(&masks_map, instr, "val_mask");
    match opcode {
        0  => UMOp::ConditionalMove(rega, regb, regc),
        1  => UMOp::ArrayIndex(rega, regb, regc),
        2  => UMOp::ArrayAmend(rega, regb, regc),
        3  => UMOp::Add(rega, regb, regc),
        4  => UMOp::Mult(rega, regb, regc),
        5  => UMOp::Div(rega, regb, regc),
        6  => UMOp::NotAnd(rega, regb, regc),
        7  => UMOp::Halt,
        8  => UMOp::Allocate(regb, regc),
        9  => UMOp::Abandon(regc),
        10 => UMOp::Output(regc),
        11 => UMOp::Input(regc),
        12 => UMOp::Load(regb, regc),
        13 => UMOp::Value(alta, val),
        _  => panic!("Bad Instruction! ({})", instr)
    }
}


fn main() {

    let mut masks_map: HashMap<&str, (u32,u32)> = HashMap::new();
    masks_map.insert("op_mask",   (0b11110000000000000000000000000000, 28));
    masks_map.insert("rega_mask", (0b00000000000000000000000111000000,  6));
    masks_map.insert("regb_mask", (0b00000000000000000000000000111000,  3));
    masks_map.insert("regc_mask", (0b00000000000000000000000000000111,  0));
    masks_map.insert("alta_mask", (0b00001110000000000000000000000000, 25));
    masks_map.insert("val_mask",  (0b00000001111111111111111111111111,  0));


    let codex8 = &fs::read("data/codex.umz").unwrap();

    let mut codex = vec![0u32; codex8.len() / 4];

    for i in 0..codex.len() {
        codex[i] = u32::from_be_bytes([
            codex8[i*4],
            codex8[i*4+1],
            codex8[i*4+2],
            codex8[i*4+3] ]);
    }


    let instr = codex[0];




    


    let full_op = parse_instr(masks_map, instr);


    println!("Hello, world! - {}", full_op);
}