use std::collections::HashSet;

use aoc_runner_derive::{aoc as aoc_run, aoc_generator};

use ndarray::prelude::*;

type Forest = Array2<i8>;
type Tree = (i8, i8);

#[aoc_generator(day8)]
fn parse_input_day1(input: &str) -> Forest {
    let nrows = input.lines().map(|_| ()).collect::<Vec<_>>().len();
    let ncols = input.lines().next().unwrap().len();
    let shape = (nrows, ncols);
    let mut arr = Array2::zeros(shape);
    for (row, line) in input.lines().enumerate() {
        for (col, tree) in line.chars().enumerate() {
            arr[[row, col]] = tree.to_digit(10).unwrap() as i8;
        }
    }
    arr
}

#[aoc_run(day8, part1)]
fn part1(input: &Forest) -> usize {
    let mut viz = HashSet::new();
    for (ridx, row) in input.rows().into_iter().enumerate() {
        let mut max = -1;
        for (cidx, &tree) in row.as_slice().unwrap().iter().enumerate() {
            if tree > max {
                let addr = (ridx, cidx);
                viz.insert(addr);
                max = tree;
            }
        }
        max = -1;
        for (cidx, &tree) in row.as_slice().unwrap().iter().enumerate().rev() {
            if tree > max {
                viz.insert((ridx, cidx));
                max = tree;
            }
        }
    }

    for (cidx, col) in input.columns().into_iter().enumerate() {
        let mut max = -1;
        for (ridx, &tree) in col
            .as_standard_layout()
            .as_slice()
            .unwrap()
            .iter()
            .enumerate()
        {
            if tree > max {
                viz.insert((ridx, cidx));
                max = tree;
            }
        }
        max = -1;
        for (ridx, &tree) in col
            .as_standard_layout()
            .as_slice()
            .unwrap()
            .iter()
            .enumerate()
            .rev()
        {
            if tree > max {
                viz.insert((ridx, cidx));
                max = tree;
            }
        }
    }

    viz.len()
}

#[aoc_run(day8, part2)]
fn part2(input: &Forest) -> usize {
    0
}