use std::collections::VecDeque;
use std::collections::HashMap;

#[derive(Debug)]
#[derive(PartialEq)]
#[derive(Copy, Clone)]
pub enum Status {
    Running,
    Finished,
    WaitingForInput,
}

pub struct Result {
    pub status: Status,
    pub instruction: usize,
}

pub struct Computer {
    memory: HashMap<usize, i64>,
    position: usize,
    relative_base: i64,
    input: VecDeque<i64>,
    output: Vec<i64>,
}

#[derive(Debug)]
#[derive(Copy, Clone)]
enum Operation {
    Add,
    Mul,
    Input,
    Output,
    JumpIfTrue,
    JumpIfFalse,
    LessThan,
    Equals,
    AdjustRelativeBase,
    End, // 99
}

#[derive(Debug)]
#[derive(Copy, Clone)]
enum ParameterMode {
    Position,  // 0
    Immediate, // 1
    Relative,  // 2
}

impl ParameterMode {
    pub fn from_int(i: i64) -> ParameterMode {
        if i == 0 {
            ParameterMode::Position
        }
        else if i == 1 {
            ParameterMode::Immediate
        }
        else if i == 2 {
            ParameterMode::Relative
        }
        else {
            panic!("Unknown parameter mode integer value: {}", i);
        }
    }
}

impl Computer {
    pub fn initialize(program: Vec<i64>, input: Vec<i64>) -> Self {
        let mut computer = Computer {
            memory: HashMap::new(),
            position: 0,
            relative_base: 0,
            input: VecDeque::from(input),
            output: Vec::new(),
        };
        for i in 0..program.len() {
            computer.mem_put(i, program[i]);
        }
        return computer;
    }

    fn mem_put(&mut self, address: usize, value: i64) {
        self.memory.insert(address, value);
    }

    fn mem_get(&mut self, address: usize) -> i64 {
        let value = self.memory.get(&address);
        if value.is_none() {
            self.mem_put(address, 0);
            return 0;
        }
        return *value.unwrap();
    }

    pub fn run(&mut self) -> Status {
        loop {
            let (op, p1_mode, p2_mode, p3_mode) = Self::decode_instruction(
                self.mem_get(self.position)
            );
            match op {
                Operation::Add => {
                    let d1 = self.fetch(self.position + 1, p1_mode);
                    let d2 = self.fetch(self.position + 2, p2_mode);
                    // The original implementation didn't check p3_mode for the Add
                    // operation.
                    let dest = self.mem_get(self.position + 3) as usize;
                    self.mem_put(dest, d1 + d2);
                    self.position += 4;
                },
                Operation::Mul => {
                    let d1 = self.fetch(self.position + 1, p1_mode);
                    let d2 = self.fetch(self.position + 2, p2_mode);
                    // The original implementation didn't check p3_mode for the Mul
                    // operation
                    let dest = self.mem_get(self.position + 3) as usize;
                    self.mem_put(dest, d1 * d2);
                    self.position += 4;
                },
                Operation::Input => {
                    if self.input.len() == 0 {
                        return Status::WaitingForInput;
                    }
                    let dest = self.mem_get(self.position + 1) as usize;
                    let input = self.input.pop_front().expect("Input queue empty... weird");
                    self.mem_put(dest, input);
                    println!("Input: {}", input);
                    self.position += 2;
                },
                Operation::Output => {
                    let value = self.fetch(self.position + 1, p1_mode);
                    println!("Output: {}", value);
                    self.output.push(value);
                    self.position += 2;
                },
                Operation::JumpIfTrue => {
                    let d1 = self.fetch(self.position + 1, p1_mode);
                    let d2 = self.fetch(self.position + 2, p2_mode);
                    if d1 != 0 {
                        self.position = d2 as usize;
                    }
                    else {
                        self.position += 3;
                    }
                },
                Operation::JumpIfFalse => {
                    let d1 = self.fetch(self.position + 1, p1_mode);
                    let d2 = self.fetch(self.position + 2, p2_mode);
                    if d1 == 0 {
                        self.position = d2 as usize;
                    }
                    else {
                        self.position += 3;
                    }
                },
                Operation::LessThan => {
                    let d1 = self.fetch(self.position + 1, p1_mode);
                    let d2 = self.fetch(self.position + 2, p2_mode);
                    // The original implementation didn't check p3_mode
                    let dest = self.mem_get(self.position + 3) as usize;
                    self.mem_put(dest, if d1 < d2 { 1 } else { 0 });
                    self.position += 4;
                },
                Operation::Equals => {
                    let d1 = self.fetch(self.position + 1, p1_mode);
                    let d2 = self.fetch(self.position + 2, p2_mode);
                    // The original implementation didn't check p3_mode
                    let dest = self.mem_get(self.position + 3) as usize;
                    self.mem_put(dest, if d1 == d2 { 1 } else { 0 });
                    self.position += 4;
                },
                Operation::AdjustRelativeBase => {
                    self.relative_base += self.mem_get(self.position + 1);
                    self.position += 2;
                },
                Operation::End => {
                    break;
                },
                other => {
                    panic!("'{:?}' not implemented", other);
                },
            };
        }
        return Status::Finished;
    }

    fn fetch(&mut self, pos: usize, mode: ParameterMode) -> i64 {
        let addr = self.absolute_address(pos, mode);
        return self.mem_get(addr);
    }

    fn absolute_address(&mut self, pos: usize, mode: ParameterMode) -> usize {
        match mode {
            ParameterMode::Position => {
                self.mem_get(
                    pos
                ) as usize
            },
            ParameterMode::Immediate => {
                pos
            },
            ParameterMode::Relative => {
                let p = self.mem_get(pos) as i64 + self.relative_base;
                if p < 0 {
                    panic!("Attempting to resolve illegale address: {}", p);
                }
                return p as usize;
            }
        }
    }

    fn decode_instruction(code: i64) -> (Operation, ParameterMode, ParameterMode, ParameterMode) {
        // Opcodes are ABCDE, where the op is DE
        // the modes for params 1, 2, and 3 as C, B, A
        // respectively.
        let mut c = code;
        let op_int = code % 100;
        let op = if op_int == 1 {
            Operation::Add
        } else if op_int == 2 {
            Operation::Mul
        } else if op_int == 3 {
            Operation::Input
        } else if op_int == 4 {
            Operation::Output
        } else if op_int == 5 {
            Operation::JumpIfTrue
        } else if op_int == 6 {
            Operation::JumpIfFalse
        } else if op_int == 7 {
            Operation::LessThan
        } else if op_int == 8 {
            Operation::Equals
        } else if op_int == 9 {
            Operation::AdjustRelativeBase
        }else if op_int == 99 {
            Operation::End
        } else {
            panic!("Unknown opcode: {}", op_int);
        };

        let param_3_mode_int = c / 10000;
        c -= param_3_mode_int * 10000;
        let param_2_mode_int = c / 1000;
        c -= param_2_mode_int * 1000;
        let param_1_mode_int = c / 100;
        return (
            op,
            ParameterMode::from_int(param_1_mode_int),
            ParameterMode::from_int(param_2_mode_int),
            ParameterMode::from_int(param_3_mode_int),
        );
    }
}

pub fn simulate(v: &mut Vec<i32>, input: &mut VecDeque<i32>, output: &mut Vec<i32>, start: usize) -> Result {
    let mut program: Vec<i64> = Vec::new();
    for i in 0..v.len() {
        program.push(i64::from(v[i]));
    }
    let mut ip: VecDeque<i64> = VecDeque::new();
    for i in 0..input.len() {
        ip.push_front(i64::from(input[i]));
    }
    let mut computer = Computer::initialize(program, vec![]);
    computer.input = ip;
    computer.position = start;
    let r = computer.run();
    for i in 0..computer.output.len() {
        if computer.output[i] <= i64::from(i32::MAX) && computer.output[i] >= i64::from(i32::MIN) {
            output.push(computer.output[i] as i32);
        }
        else {
            panic!("Output value '{}' out of range for legacy i32 int-code computer", computer.output[i]);
        }
    }
    for i in 0..v.len() {
        v[i] = computer.mem_get(i) as i32;
    }
    return Result {
        status: r,
        instruction: computer.position,
    };
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_op_1() {
        let mut program = vec![1, 0, 0, 0, 99];
        let mut input: VecDeque<i32> = VecDeque::new();
        let mut output: Vec<i32> = Vec::new();
        simulate(&mut program, &mut input, &mut output, 0);
        assert_eq!(program[0], 2);
    }

    #[test]
    fn test_op_2() {
        let mut program = vec![2, 3, 0, 3, 99];
        let mut input: VecDeque<i32> = VecDeque::new();
        let mut output: Vec<i32> = Vec::new();
        simulate(&mut program, &mut input, &mut output, 0);
        assert_eq!(program[3], 6);
    }

    #[test]
    fn test_case_3() {
        let mut program = vec![2,4,4,5,99,0];
        let mut input: VecDeque<i32> = VecDeque::new();
        let mut output: Vec<i32> = Vec::new();
        simulate(&mut program, &mut input, &mut output, 0);
        assert_eq!(program[program.len() - 1], 9801);
    }

    #[test]
    fn test_case_4() {
        let mut program = vec![1,1,1,4,99,5,6,0,99];
        let mut input: VecDeque<i32> = VecDeque::new();
        let mut output: Vec<i32> = Vec::new();
        simulate(&mut program, &mut input, &mut output, 0);
        assert_eq!(program[0], 30);
        assert_eq!(program[4], 2);
    }

    #[test]
    fn immediate_mode_multiply() {
        let mut program = vec![1002,4,3,4,33];
        let mut input: VecDeque<i32> = VecDeque::new();
        let mut output: Vec<i32> = Vec::new();
        simulate(&mut program, &mut input, &mut output, 0);
        assert_eq!(program[4], 99);
    }

    #[test]
    fn negative_integers() {
        let mut program = vec![1101,100,-1,4,0];
        let mut input: VecDeque<i32> = VecDeque::new();
        let mut output: Vec<i32> = Vec::new();
        simulate(&mut program, &mut input, &mut output, 0);
        assert_eq!(program[4], 99);
    }

    #[test]
    fn position_mode_input_equal_to_8() {
        let mut program = vec![3,9,8,9,10,9,4,9,99,-1,8];
        let mut output: Vec<i32> = Vec::new();
        let backup = program.clone();
        simulate(&mut program, &mut VecDeque::from([8]), &mut output, 0);
        assert_eq!(output[0], 1);
        output.clear();
        program = backup.clone();
        simulate(&mut program, &mut VecDeque::from([7]), &mut output, 0);
        assert_eq!(output[0], 0);
    }

    #[test]
    fn position_mode_input_less_than_8() {
        let mut program = vec![3,9,7,9,10,9,4,9,99,-1,8];
        let mut output: Vec<i32> = Vec::new();
        let backup = program.clone();
        simulate(&mut program, &mut VecDeque::from([8]), &mut output, 0);
        assert_eq!(output[0], 0);
        output.clear();
        program = backup.clone();
        simulate(&mut program, &mut VecDeque::from([7]), &mut output, 0);
        assert_eq!(output[0], 1);
    }

    #[test]
    fn immediate_mode_input_equal_to_8() {
        let mut program = vec![3,3,1108,-1,8,3,4,3,99];
        let mut output: Vec<i32> = Vec::new();
        let backup = program.clone();
        simulate(&mut program, &mut VecDeque::from([8]), &mut output, 0);
        assert_eq!(output[0], 1);
        output.clear();
        program = backup.clone();
        simulate(&mut program, &mut VecDeque::from([7]), &mut output, 0);
        assert_eq!(output[0], 0);
    }

    #[test]
    fn immediate_mode_input_less_than_8() {
        let mut program = vec![3,3,1107,-1,8,3,4,3,99];
        let mut output: Vec<i32> = Vec::new();
        let backup = program.clone();
        simulate(&mut program, &mut VecDeque::from([8]), &mut output, 0);
        assert_eq!(output[0], 0);
        output.clear();
        program = backup.clone();
        simulate(&mut program, &mut VecDeque::from([7]), &mut output, 0);
        assert_eq!(output[0], 1);
    }

    #[test]
    fn position_mode_input_is_non_zero() {
        let mut program = vec![3,12,6,12,15,1,13,14,13,4,13,99,-1,0,1,9];
        let mut output: Vec<i32> = Vec::new();
        let backup = program.clone();
        simulate(&mut program, &mut VecDeque::from([8]), &mut output, 0);
        assert_eq!(output[0], 1);
        output.clear();
        program = backup.clone();
        simulate(&mut program, &mut VecDeque::from([0]), &mut output, 0);
        assert_eq!(output[0], 0);
    }

    #[test]
    fn immediate_mode_input_is_non_zero() {
        let mut program = vec![3,3,1105,-1,9,1101,0,0,12,4,12,99,1];
        let mut output: Vec<i32> = Vec::new();
        let backup = program.clone();
        simulate(&mut program, &mut VecDeque::from([9]), &mut output, 0);
        assert_eq!(output[0], 1);
        output.clear();
        program = backup.clone();
        simulate(&mut program, &mut VecDeque::from([0]), &mut output, 0);
        assert_eq!(output[0], 0);
    }

    #[test]
    fn multi_jump() {
        let mut program = vec![3,21,1008,21,8,20,1005,20,22,107,8,21,20,1006,20,31,1106,0,36,98,0,0,1002,21,125,20,4,20,1105,1,46,104,999,1105,1,46,1101,1000,1,20,4,20,1105,1,46,98,99];
        let mut output: Vec<i32> = Vec::new();
        let backup = program.clone();
        simulate(&mut program, &mut VecDeque::from([7]), &mut output, 0);
        assert_eq!(output[0], 999);
        output.clear();
        program = backup.clone();
        simulate(&mut program, &mut VecDeque::from([8]), &mut output, 0);
        assert_eq!(output[0], 1000);
        output.clear();
        program = backup.clone();
        simulate(&mut program, &mut VecDeque::from([9]), &mut output, 0);
        assert_eq!(output[0], 1001);
    }

    #[test]
    fn blocks_on_input() {
        let mut program = vec![3,26,1001,26,-4,26,3,27,1002,27,2,27,1,27,26,27,4,27,1001,28,-1,28,1005,28,6,99,0,0,5];
        let mut output: Vec<i32> = Vec::new();
        let result = simulate(&mut program, &mut VecDeque::from([9, 0]), &mut output, 0);
        assert_eq!(result.status, Status::WaitingForInput);
        assert_eq!(result.instruction, 6);
    }

    #[test]
    fn relative_base_adjust() {
        let mut c = Computer::initialize(vec![109, 1, 99], vec![]);
        c.run();
        assert_eq!(c.relative_base, 1);
    }

    #[test]
    #[should_panic]
    fn negative_memory_access() {
        let mut c = Computer::initialize(vec![109, -5000, 204, 0, 99], vec![]);
        c.run();
    }

    #[test]
    fn relative_example_1() {
        // The program produces an output of itself
        let program = vec![109,1,204,-1,1001,100,1,100,1008,100,16,101,1006,101,0,99];
        let mut c = Computer::initialize(program.clone(), vec![]);
        c.run();
        for i in 0..program.len() {
            assert_eq!(program[i], c.output[i]);
        }
    }

    #[test]
    fn relative_example_2() {
        // Outputs a 16 digit numbers
        let program = vec![1102,34915192,34915192,7,4,7,99,0];
        let mut c = Computer::initialize(program, vec![]);
        c.run();
        assert_eq!(c.output[0].to_string().len(), 16);
    }

    #[test]
    fn relative_example_3() {
        // Outputs 1125899906842624
        let program = vec![104,1125899906842624,99];
        let mut c = Computer::initialize(program, vec![]);
        c.run();
        assert_eq!(c.output[0], 1125899906842624);
    }
}