---cargo
---

static CONTENT: &'static str = include_str!("./inputs/06_1.txt");

#[derive(Debug, PartialEq, Clone)]
enum Operation {
    Add,
    Mul,
}

fn main() {
    let raw_grid: Vec<_> = CONTENT.lines().map(|l| {
        l.chars().collect::<Vec<_>>()
    }).collect();
    println!("Raw-Grid\n{:?}", raw_grid);

    let height = raw_grid.len();
    let width = raw_grid[0].len();

    let separators: Vec<_> = (0..width).filter(|pidx| {
        raw_grid.iter().map(|row| row[*pidx]).all(|c| c == ' ')
    }).collect();
    println!("Separators {:?}", separators);

    let ranges: Vec<_> = (core::iter::once(0).chain(separators.iter().copied().map(|v| v+1))).zip(separators.iter().copied().chain(core::iter::once(width))).map(|(s, e)| s..e).collect();
    println!("Ranges {:?}", ranges);

    let mut result = 0;

    for r in ranges.iter().cloned() {
        println!("Range {:?}", r);

        let values: Vec<_> = r.clone().rev().map(|p| {
            raw_grid.iter().enumerate().take(height-1).map(|(i, r)| (i, r[p])).fold(0usize, |acc, (i, v)| {
                if v == ' ' {
                    return acc;
                }

                acc * 10usize + v.to_digit(10).unwrap() as usize
            })
        }).collect();
        println!("Values: {:?}", values);

        let operation = raw_grid[height-1][r].iter().find(|c| **c != ' ').unwrap();
        println!("Operation {:?}", operation);

        let calc_res = match operation {
            '+' => values.into_iter().sum::<usize>(),
            '*' => values.into_iter().product::<usize>(),
            other => unreachable!("Unexpected Operation {:?}", other),
        };
        println!("Calculation {:?}", calc_res);

        result += calc_res;
    }

    println!("result {:?}", result);
}