#![allow(non_snake_case)]

use aoc::grid::*;

use aoc::Puzzle;

struct AoC2022_08;

impl AoC2022_08 {

fn ignoring_borders(&self, grid: &IntGrid) -> Vec<Cell> {

grid.cells()

.filter(|cell| 1 <= cell.row)

.filter(|cell| cell.row < grid.height() - 1)

.filter(|cell| 1 <= cell.col)

.filter(|cell| cell.col < grid.width() - 1)

.collect()

}

fn visible_from_outside(&self, grid: &IntGrid, cell: &Cell) -> bool {

let val = grid.get(cell);

grid.cells_capital_directions(cell)

.iter_mut()

.any(|dir| dir.all(|cell| grid.get(&cell) < val))

}

fn viewing_distance(

&self,

grid: &IntGrid,

direction: &GridIterator,

val: u32,

) -> u32 {

let mut n = 0;

let mut stop = false;

for cell in direction.collect::<Vec<Cell>>() {

if stop {

break;

}

n += 1;

stop = grid.get(&cell) >= val;

}

n

}

fn scenic_score(&self, grid: &IntGrid, cell: &Cell) -> u32 {

grid.cells_capital_directions(cell)

.iter()

.map(|dir| self.viewing_distance(grid, dir, grid.get(cell)))

.product()

}

}

impl aoc::Puzzle for AoC2022_08 {

type Input = IntGrid;

type Output1 = usize;

type Output2 = u32;

aoc::puzzle_year_day!(2022, 8);

fn parse_input(&self, lines: Vec<String>) -> IntGrid {

IntGrid::from(&lines.iter().map(AsRef::as_ref).collect::<Vec<_>>())

}

fn part_1(&self, grid: &IntGrid) -> usize {

let ans = 2 * (grid.height() + grid.width()) - 4;

ans + self

.ignoring_borders(grid)

.iter()

.filter(|cell| self.visible_from_outside(grid, cell))

.count()

}

fn part_2(&self, grid: &IntGrid) -> u32 {

self.ignoring_borders(grid)

.iter()

.map(|cell| self.scenic_score(grid, cell))

.max()

.unwrap()

}

fn samples(&self) {

#[rustfmt::skip]

let test =

"30373\n\

25512\n\

65332\n\

33549\n\

35390";

aoc::puzzle_samples! {

self, part_1, test, 21,

self, part_2, test, 8

};

}

}

fn main() {

AoC2022_08 {}.run(std::env::args());

}

#[cfg(test)]

mod tests {

use super::*;

#[test]

pub fn samples() {

AoC2022_08 {}.samples();

}

}