---cargo
---

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

#[derive(Debug)]
struct Bank {
    values: [Option<(usize, usize)>; 10],
}

fn main() {
    let raw_banks: Vec<Vec<u8>> = CONTENT.lines().map(|l| l.trim()).filter(|l| !l.is_empty()).map(|l| {
        l.chars().map(|c| {
            match c {
                '0' => 0,
                '1' => 1,
                '2' => 2,
                '3' => 3,
                '4' => 4,
                '5' => 5,
                '6' => 6,
                '7' => 7,
                '8' => 8,
                '9' => 9,
                c => unreachable!("Other {:?}", c),
            }
        }).collect::<Vec<u8>>()
    }).collect();
    println!("{:?}", raw_banks);

    let banks: Vec<Bank> = raw_banks.iter().map(|rbank| {
        Bank {
            values: core::array::from_fn(|i| {
                let i = i as u8;

                let first = rbank.iter().enumerate().find_map(|(idx, v)| {
                    (*v==i).then_some(idx)
                })?;
                let second = rbank.iter().enumerate().rev().find_map(|(idx, v)| {
                    (*v==i).then_some(idx)
                })?;

                Some((first, second))
            })
        }
    }).collect();
    println!("{:?}", banks);

    let mut result = 0;
    for bank in banks.iter() {
        println!("{:?}", bank);

        let iter_func = || bank.values.iter().enumerate().filter_map(|(idx, v)| {
            let v = v.clone()?;
            Some((idx, v))
        });
       
        
        let value = iter_func().flat_map(|f| core::iter::repeat(f.clone()).zip(iter_func())).filter_map(|(first, second)| {
            if !(first.1.0 < second.1.1) {
                return None;
            }

            let value = (first.0 * 10 + second.0) as usize;
            // println!("{:?} - {:?} => {}", first, second, value);

            Some(value)
        }).max().unwrap();
        println!("{:?}", value);

        result += value;
    }

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