/// --- Part Two ---
///
/// Content with the amount of tree cover available, the Elves just need to know the best spot to
/// build their tree house: they would like to be able to see a lot of trees.
///
/// To measure the viewing distance from a given tree, look up, down, left, and right from that
/// tree; stop if you reach an edge or at the first tree that is the same height or taller than the
/// tree under consideration.  (If a tree is right on the edge, at least one of its viewing
/// distances will be zero.)
///
/// The Elves don't care about distant trees taller than those found by the rules above; the
/// proposed tree house has large eaves to keep it dry, so they wouldn't be able to see higher than
/// the tree house anyway.
///
/// In the example above, consider the middle 5 in the second row:
///
/// ```
/// 30373
/// 25512
/// 65332
/// 33549
/// 35390
/// ```
///
///     Looking up, its view is not blocked; it can see 1 tree (of height 3).
///     Looking left, its view is blocked immediately; it can see only 1 tree (of height 5, right
///     next to it).
///     Looking right, its view is not blocked; it can see 2 trees.
///     Looking down, its view is blocked eventually; it can see 2 trees (one of height 3, then the
///     tree of height 5 that blocks its view).
///
/// A tree's scenic score is found by multiplying together its viewing distance in each of the four
/// directions. For this tree, this is 4 (found by multiplying 1 * 1 * 2 * 2).
///
/// However, you can do even better: consider the tree of height 5 in the middle of the fourth row:
///
/// ```
/// 30373
/// 25512
/// 65332
/// 33549
/// 35390
/// ```
///
///     Looking up, its view is blocked at 2 trees (by another tree with a height of 5).
///     Looking left, its view is not blocked; it can see 2 trees.
///     Looking down, its view is also not blocked; it can see 1 tree.
///     Looking right, its view is blocked at 2 trees (by a massive tree of height 9).
///
/// This tree's scenic score is 8 (2 * 2 * 1 * 2); this is the ideal spot for the tree house.
///
/// Consider each tree on your map. What is the highest scenic score possible for any tree?
use clap::Parser;
use itertools::Itertools;

use std::fs::File;
use std::io::prelude::*;
use std::io::BufReader;
use std::path::PathBuf;

const FILEPATH: &'static str = "examples/input.txt";

#[derive(Parser, Debug)]
#[clap(author, version, about, long_about = None)]
struct Cli {
    #[clap(short, long, default_value = FILEPATH)]
    file: PathBuf,
}

fn main() {
    let args = Cli::parse();

    let file = File::open(&args.file).unwrap();
    let reader = BufReader::new(file);
    let grid = reader
        .lines()
        .map(|l| {
            l.unwrap()
                .chars()
                .map(|c| c.to_digit(10).unwrap() as u8)
                .collect_vec()
        })
        .collect_vec();

    let xdim = grid.len();
    let ydim = grid[0].len();

    let res = (1..(xdim - 1))
        .cartesian_product(1..(ydim - 1))
        .map(|(idx, idy)| {
            let tree = grid[idx][idy];
            let top = (0..idx)
                .rev()
                .map(|t| tree as i32 - grid[t][idy] as i32)
                .position(|diff| diff <= 0)
                .unwrap_or(idx - 1)
                + 1;
            let bottom = ((idx + 1)..xdim)
                .map(|t| tree as i32 - grid[t][idy] as i32)
                .position(|diff| diff <= 0)
                .unwrap_or((xdim - idx) - 2)
                + 1;
            let left = (0..idy)
                .rev()
                .map(|t| tree as i32 - grid[idx][t] as i32)
                .position(|diff| diff <= 0)
                .unwrap_or(idy - 1)
                + 1;
            let right = ((idy + 1)..ydim)
                .map(|t| tree as i32 - grid[idx][t] as i32)
                .position(|diff| diff <= 0)
                .unwrap_or((ydim - idy) - 2)
                + 1;
            top * bottom * left * right
        })
        .max()
        .unwrap();

    println!("{res:?}");
}