/// Represents an instruction to our handheld device.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Instruction {
    Noop,
    Addx(i32),
}

/// Module wrapping the parser for the instructions from the input.
mod parser {
    use super::*;
    use anyhow::{anyhow, Result};
    use nom::{
        branch::alt,
        bytes::complete::tag,
        character::complete::i32,
        combinator::{map, value},
        multi::separated_list1,
        sequence::preceded,
        Finish, IResult,
    };

    /// Nom parser for "noop" -> Instruction:Noop
    fn noop(s: &str) -> IResult<&str, Instruction> {
        value(Instruction::Noop, tag("noop"))(s)
    }

    /// Nom parser for "addx 3" -> Instruction::Addx(3)
    fn addx(s: &str) -> IResult<&str, Instruction> {
        map(preceded(tag("addx "), i32), Instruction::Addx)(s)
    }

    /// Nom parser for either instruction variant
    fn instruction(s: &str) -> IResult<&str, Instruction> {
        alt((noop, addx))(s)
    }

    /// Nom parser for all instruction lines -> Vec<Instruction>
    pub fn parse(s: &str) -> Result<Vec<Instruction>> {
        let result = separated_list1(tag("\n"), instruction)(s);
        let (_, instrs) = result.finish().map_err(|e| anyhow!("{e}"))?;
        Ok(instrs)
    }
}

const INPUT: &str = include_str!("../../input/10/input.txt");

/// Parse that input!
fn read() -> Vec<Instruction> {
    parser::parse(INPUT).unwrap()
}

/// Solve Day 10, Part 1
 fn solve(input: &[Instruction]) -> i32 {
    // Instantiate a new device, run all the instructions on it, then return
    // the total signal strength from that device.
    let mut device = Device::new();
    input.iter().for_each(|instruction| device.execute(instruction));
    device.signal_strength
}

/// Represents our handheld computing device, complete with signal strength
/// accumulator!
struct Device {
    register: i32,
    cycle: usize,
    signal_strength: i32,
}

impl Device {
    fn new() -> Self {
        Device { register: 1, cycle: 1, signal_strength: 0 }
    }

    // Execute a NOOP instruction. We'll leverage these instructions to update the
    // signal strength based on the current cycle count.
    fn execute_noop(&mut self) {
        self.cycle += 1;
        let multiple_of_20 = self.cycle % 20 == 0;
        let odd_multiple = (self.cycle / 20) % 2 == 1;

        // We'll update the signal strength on cycles 20, 60, 100, 140, etc.
        // These are all odd multiples of 20, that is, (20 * 1), (20 * 3), (20 * 5), etc.
        // So, we check that the current cycle count is a multiple of 20 and that the
        // current cycle count divided by 20 is an odd number.
        if multiple_of_20 && odd_multiple {
            self.signal_strength += (self.cycle as i32) * self.register;
        }
    }

    /// Execute an ADDX instruction. We leverage the NOOP instructions here to update
    /// the cycle count and the signal strength, if necessary. It's important that
    /// the register be updated between the NOOP instructions, since the puzzle states
    /// signal strength is checked _during_ the cycle and not after.
    fn execute_addx(&mut self, value: i32) {
        self.execute_noop();
        self.register += value;
        self.execute_noop();
    }

    /// Dispatch for instruction execution. Calls the appropriate execute method
    /// depending on the instruction provided.
    fn execute(&mut self, instr: &Instruction) {
        match instr {
            Instruction::Noop => self.execute_noop(),
            Instruction::Addx(v) => self.execute_addx(*v),
        }
    }
}

use std::fmt::{Display, Formatter, Result as FmtResult};

/// Solve Day 10, Part 2
fn solve(input: &[Instruction]) -> String {
    // Boot up a new model of device and run all the instructions on it.
    let mut device = Device::new();
    input.iter().for_each(|instruction| device.execute(instruction));

    // Collect the prettified pixel display into a string and return it
    PrettyPixels(device.pixels).to_string()
}

/// Represents a new-fangled computer with a display. We'll keep track of pixels
/// lit in a boolean array and worry about displaying them later.
struct Device {
    register: i32,
    cycle: usize,
    pixels: [bool; 240],
}

impl Device {
    fn new() -> Self {
        Device { register: 1, cycle: 0, pixels: [false; 240] }
    }

    // Execute a NOOP instruction. We'll leverage these instructions to update the
    // pixels based on the current sprite position.
    fn execute_noop(&mut self) {
        // Calculate the three-wide position of the sprite.
        let sprite_range = (self.register - 1)..=(self.register + 1);

        // The current line position is the cycle wrapped to 40-width lines. So, on
        // cycle 40, we've wrapped around to the first pixel of the second line.
        let line_pos = (self.cycle % 40) as i32;

        // If the current line position is within the sprite, set the corresponding
        // pixel in our array of pixels to `true`.
        if sprite_range.contains(&line_pos) {
            self.pixels[self.cycle] = true;
        }

        self.cycle += 1;
    }

    /// Execute an ADDX instruction. Once again, we leverage the NOOP instructions here
    /// to update the cycle count and the pixels. This time, we need to update the 
    /// register _after_ both NOOPs, since pixel drawing happens at the _beginning_
    /// of each cycle.
    fn execute_addx(&mut self, value: i32) {
        self.execute_noop();
        self.execute_noop();
        self.register += value;
    }

    /// Dispatch for instruction execution. Calls the appropriate execute method
    /// depending on the instruction provided.
    fn execute(&mut self, instr: &Instruction) {
        match instr {
            Instruction::Noop => self.execute_noop(),
            Instruction::Addx(v) => self.execute_addx(*v),
        }
    }
}

/// This is how we worry about displaying pixels. Using the newtype syntax, we can
/// implement a standard library trait on a (wrapped) standard library data structure.
/// In this case, we want to implement `Display` for our array of pixels so we can
/// convert it to a string that can show us the answer to part two.
struct PrettyPixels([bool; 240]);

impl Display for PrettyPixels {
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
        for (idx, pixel) in self.0.iter().enumerate() {
            // Wrap the pixel lines to a width of 40 characters
            if (idx % 40 == 0) && idx > 0 { writeln!(f)?; }

            // If the pixel is lit, print a '#', other wise print a space
            let glyph = if *pixel { "#" } else { " " };
            write!(f, "{glyph}")?;
        }

        write!(f, "") // Finish the print results
    }
}