//! # Day 2: 1202 Program Alarm
//!
//! On the way to your [gravity assist] around the Moon, your ship computer beeps angrily about a
//! "[1202 program alarm]". On the radio, an Elf is already explaining how to handle the situation:
//! "Don't worry, that's perfectly norma--" The ship computer [bursts into flames].
//!
//! You notify the Elves that the computer's [magic smoke] seems to have escaped. "That computer ran
//! **Intcode** programs like the gravity assist program it was working on; surely there are enough
//! spare parts up there to build a new Intcode computer!"
//!
//! An Intcode program is a list of [integers] separated by commas (like `1,0,0,3,99`). To run one,
//! start by looking at the first integer (called position 0). Here, you will find an **opcode** -
//! either `1`, `2`, or `99`. The opcode indicates what to do; for example, `99` means that the
//! program is finished and should immediately halt. Encountering an unknown opcode means something
//! went wrong.
//!
//! Opcode `1` **adds** together numbers read from two positions and stores the result in a third
//! position. The three integers **immediately after** the opcode tell you these three positions -
//! the first two indicate the **positions** from which you should read the input values, and the
//! third indicates the **position** at which the output should be stored.
//!
//! For example, if your Intcode computer encounters `1,10,20,30`, it should read the values at
//! positions `10` and `20`, add those values, and then overwrite the value at position `30` with
//! their sum.
//!
//! Opcode `2` works exactly like opcode `1`, except it **multiplies** the two inputs instead of
//! adding them. Again, the three integers after the opcode indicate **where** the inputs and
//! outputs are, not their values.
//!
//! Once you're done processing an opcode, **move to the next one** by stepping forward `4`
//! positions.
//!
//! For example, suppose you have the following program:
//!
//! ```txt
//! 1,9,10,3,2,3,11,0,99,30,40,50
//! ```
//!
//! For the purposes of illustration, here is the same program split into multiple lines:
//!
//! ```txt
//! 1,9,10,3,
//! 2,3,11,0,
//! 99,
//! 30,40,50
//! ```
//!
//! The first four integers, `1,9,10,3`, are at positions `0`, `1`, `2`, and `3`. Together, they
//! represent the first opcode (`1`, addition), the positions of the two inputs (`9` and `10`), and
//! the position of the output (`3`). To handle this opcode, you first need to get the values at the
//! input positions: position `9` contains `30`, and position `10` contains `40`. **Add** these
//! numbers together to get `70`. Then, store this value at the output position; here, the output
//! position (`3`) is **at** position `3`, so it overwrites itself. Afterward, the program looks
//! like this:
//!
//! ```txt
//! 1,9,10,70,
//! 2,3,11,0,
//! 99,
//! 30,40,50
//! ```
//!
//! Step forward `4` positions to reach the next opcode, `2`. This opcode works just like the
//! previous, but it multiplies instead of adding. The inputs are at positions `3` and `11`; these
//! positions contain `70` and `50` respectively. Multiplying these produces `3500`; this is stored
//! at position `0`:
//!
//! ```txt
//! 3500,9,10,70,
//! 2,3,11,0,
//! 99,
//! 30,40,50
//! ```
//!
//! Stepping forward `4` more positions arrives at opcode `99`, halting the program.
//!
//! Here are the initial and final states of a few more small programs:
//!
//! - `1,0,0,0,99` becomes `2,0,0,0,99` (`1 + 1 = 2`).
//! - `2,3,0,3,99` becomes `2,3,0,6,99` (`3 * 2 = 6`).
//! - `2,4,4,5,99,0` becomes `2,4,4,5,99,9801` (`99 * 99 = 9801`).
//! - `1,1,1,4,99,5,6,0,99` becomes `30,1,1,4,2,5,6,0,99`.
//!
//! Once you have a working computer, the first step is to restore the gravity assist program (your
//! puzzle input) to the "1202 program alarm" state it had just before the last computer caught
//! fire. To do this, **before running the program**, replace position `1` with the value `12` and
//! replace position `2` with the value `2`. **What value is left at position `0`** after the
//! program halts?
//!
//! [gravity assist]: https://en.wikipedia.org/wiki/Gravity_assist
//! [1202 program alarm]: https://www.hq.nasa.gov/alsj/a11/a11.landing.html#1023832
//! [bursts into flames]: https://en.wikipedia.org/wiki/Halt_and_Catch_Fire
//! [magic smoke]: https://en.wikipedia.org/wiki/Magic_smoke
//! [integers]: https://en.wikipedia.org/wiki/Integer
//!
//! ## Part Two
//!
//! "Good, the new computer seems to be working correctly! **Keep it nearby** during this mission -
//! you'll probably use it again. Real Intcode computers support many more features than your new
//! one, but we'll let you know what they are as you need them."
//!
//! "However, your current priority should be to complete your gravity assist around the Moon. For
//! this mission to succeed, we should settle on some terminology for the parts you've already
//! built."
//!
//! Intcode programs are given as a list of integers; these values are used as the initial state for
//! the computer's **memory**. When you run an Intcode program, make sure to start by initializing
//! memory to the program's values. A position in memory is called an **address** (for example, the
//! first value in memory is at "address 0").
//!
//! Opcodes (like `1`, `2`, or `99`) mark the beginning of an **instruction**. The values used
//! immediately after an opcode, if any, are called the instruction's **parameters**. For example,
//! in the instruction `1,2,3,4`, `1` is the opcode; `2`, `3`, and `4` are the parameters. The
//! instruction `99` contains only an opcode and has no parameters.
//!
//! The address of the current instruction is called the **instruction pointer**; it starts at `0`.
//! After an instruction finishes, the instruction pointer increases by **the number of values in
//! the instruction**; until you add more instructions to the computer, this is always `4` (`1`
//! opcode + `3` parameters) for the add and multiply instructions. (The halt instruction would
//! increase the instruction pointer by `1`, but it halts the program instead.)
//!
//! "With terminology out of the way, we're ready to proceed. To complete the gravity assist, you
//! need to **determine what pair of inputs produces the output `19690720`**."
//!
//! The inputs should still be provided to the program by replacing the values at addresses `1` and
//! `2`, just like before. In this program, the value placed in address `1` is called the **noun**,
//! and the value placed in address `2` is called the **verb**. Each of the two input values will be
//! between `0` and `99`, inclusive.
//!
//! Once the program has halted, its output is available at address `0`, also just like before. Each
//! time you try a pair of inputs, make sure you first **reset the computer's memory to the values
//! in the program** (your puzzle input) - in other words, don't reuse memory from a previous
//! attempt.
//!
//! Find the input **noun** and **verb** that cause the program to produce the output `19690720`.
//! **What is `100 * noun + verb`?** (For example, if `noun=12` and `verb=2`, the answer would be
//! `1202`.)

use anyhow::{anyhow, Result};

use super::intcode::{self, Program};

pub const INPUT: &str = include_str!("d02.txt");

pub fn solve_part_one(input: &str) -> Result<i64> {
    let mut cmds = intcode::parse_input(input)?;
    cmds[1] = 12;
    cmds[2] = 2;

    let mut p = Program::new(cmds, &[]);
    p.run(&[])?;

    Ok(p.cmds()[0])
}

pub fn solve_part_two(input: &str) -> Result<i64> {
    let cmds = intcode::parse_input(input)?;

    for noun in 0..=99 {
        for verb in 0..=99 {
            let mut cmds = cmds.clone();
            cmds[1] = noun;
            cmds[2] = verb;

            let mut p = Program::new(cmds, &[]);
            p.run(&[])?;

            if p.cmds()[0] == 19_690_720 {
                return Ok(100 * noun + verb);
            }
        }
    }

    Err(anyhow!("Couldn't find noun and verb which produce output 19690720"))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn part_one() {
        let cmds = process(vec![1, 0, 0, 0, 99]).unwrap();
        assert_eq!(vec![2, 0, 0, 0, 99], cmds);

        let cmds = process(vec![2, 3, 0, 3, 99]).unwrap();
        assert_eq!(vec![2, 3, 0, 6, 99], cmds);

        let cmds = process(vec![2, 4, 4, 5, 99, 0]).unwrap();
        assert_eq!(vec![2, 4, 4, 5, 99, 9801], cmds);

        let cmds = process(vec![1, 1, 1, 4, 99, 5, 6, 0, 99]).unwrap();
        assert_eq!(vec![30, 1, 1, 4, 2, 5, 6, 0, 99], cmds);
    }

    fn process(cmds: Vec<i64>) -> Result<Vec<i64>> {
        let mut p = Program::new(cmds, &[]);
        p.run(&[])?;
        Ok(p.cmds())
    }

    #[test]
    fn part_two() {}
}