use std::collections::VecDeque;

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

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

pub fn simulate(v: &mut Vec<i32>, input: &mut VecDeque<i32>, output: &mut Vec<i32>, start: usize) -> Result {
    let mut pos = start;
    loop {
        let mut code = v[pos];
        // Opcodes are ABCDE, where the op is DE
        // the modes for params 1, 2, and 3 as C, B, A
        // respectively.
        let op = code % 100;
        //println!("pos {}, code {}, op {}", pos, code, op);
        let param_3_mode = code / 10000;
        if param_3_mode == 1 {
            code -= 10000;
        }
        let param_2_mode = code / 1000;
        if param_2_mode == 1 {
            code -= 1000;
        }
        let param_1_mode = code / 100;
        if param_1_mode == 1 {
            code -= 100;
        }
        if op == 1 {
            // Add d1 + d2 -> dest
            let d1: i32 = if param_1_mode == 1 {
                v[pos+1]
            } else {
                v[v[pos+1] as usize]
            };
            let d2: i32 = if param_2_mode == 1 {
                v[pos+2]
            } else {
                v[v[pos+2] as usize]
            };
            let dest = v[pos+3] as usize;
            v[dest] = d1 + d2;
            pos += 4;
            continue;
        }
        else if op == 2 {
            // Mult d1 * d2 -> dest
            let d1: i32 = if param_1_mode == 1 {
                v[pos+1]
            } else {
                v[v[pos+1] as usize]
            };
            let d2: i32 = if param_2_mode == 1 {
                v[pos+2]
            }
            else {
                v[v[pos+2] as usize]
            };
            let dest = v[pos+3] as usize;
            v[dest] = d1 * d2;
            pos += 4;
            continue;
        }
        else if op == 3 {
            // Input
            let dest = v[pos+1] as usize;
            v[dest] = if input.len() == 0 {
                return Result {
                    status: Status::WaitingForInput,
                    instruction: pos
                };
            } else {
                input.pop_front().expect("Input stack empty... weird")
            };
            println!("Input: {}", v[dest]);
            pos += 2;
        }
        else if op == 4 {
            // Output
            let d = if param_1_mode == 1 {
                v[pos+1]
            }
            else {
                v[v[pos+1] as usize]
            };
            println!("Output: {}", d);
            output.push(d);
            pos += 2;
        }
        else if op == 5 {
            // Jump if true
            let d1 = if param_1_mode == 1 {
                v[pos+1] as usize
            }
            else {
                v[v[pos+1] as usize] as usize
            };
            let d2 = if param_2_mode == 1 {
                v[pos+2] as usize
            }
            else {
                v[v[pos+2] as usize] as usize
            };
            if d1 != 0 {
                pos = d2;
            }
            else {
                pos += 3;
            }
        }
        else if op == 6 {
            // Jump if false
            let d1 = if param_1_mode == 1 {
                v[pos+1] as usize
            }
            else {
                v[v[pos+1] as usize] as usize
            };
            let d2 = if param_2_mode == 1 {
                v[pos+2] as usize
            }
            else {
                v[v[pos+2] as usize] as usize
            };
            if d1 == 0 {
                pos = d2;
            }
            else {
                pos += 3;
            }
        }
        else if op == 7 {
            // Less than
            let d1: i32 = if param_1_mode == 1 {
                v[pos+1]
            } else {
                v[v[pos+1] as usize]
            };
            let d2: i32 = if param_2_mode == 1 {
                v[pos+2]
            }
            else {
                v[v[pos+2] as usize]
            };
            let dest = v[pos+3] as usize;
            v[dest] = if d1 < d2 { 1 } else { 0 };
            pos += 4;
        }
        else if op == 8 {
            // equals
            let d1: i32 = if param_1_mode == 1 {
                v[pos+1]
            } else {
                v[v[pos+1] as usize]
            };
            let d2: i32 = if param_2_mode == 1 {
                v[pos+2]
            }
            else {
                v[v[pos+2] as usize]
            };
            let dest = v[pos+3] as usize;
            v[dest] = if d1 == d2 { 1 } else { 0 };
            pos += 4;
        }
        else if op == 99 {
            break;
        }
        else {
            panic!("Unknown opcode: {}", code);
        }
    }
    return Result {
        status: Status::Finished,
        instruction: 0
    };
}

#[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);
    }
}