fn is_opening(c: &char) -> bool {
    c == &'(' || c == &'[' || c == &'{' || c == &'<'
}

fn inverse(c: &char) -> char {
    match c {
        '(' => ')',
        '[' => ']',
        '{' => '}',
        '<' => '>',
        // E for error...
        _ => 'E'
    }
}

fn aoc_10_part02(incomplete: &Vec<(String, Vec<char>)>) -> i64 {
    let mut results = incomplete.iter().map(|(_line, remaining_stack)| {
        remaining_stack.iter().fold(0, |acc, val| {
            acc * 5 + match val {
                '(' => 1,
                '[' => 2,
                '{' => 3,
                '<' => 4,
                _   => 0
            }
        })
    }).collect::<Vec<i64>>();
    results.sort();
    results[results.len() / 2]
}

fn aoc_10_part01(lines: &[String]) -> (i32, Vec<(String, Vec<char>)>) {
    let mut stack: Vec<char>;
    let mut corrupted: Vec<(String, char)> = Vec::new();
    let mut incomplete: Vec<(String, Vec<char>)> = Vec::new();
    // let mut valid: Vec<String> = Vec::new();
    let mut is_corrupted: bool;

    for line in lines {
        stack = Vec::new();
        is_corrupted = false;
        for c in line.chars() {
            if is_opening(&c) {
                stack.push(c);
            } else {
                if let Some(last_opening) = stack.pop() {
                    if inverse(&last_opening) != c {
                        corrupted.push((line.clone(), c));
                        is_corrupted = true;
                        break;
                    }
                }
            }
        }

        if !is_corrupted {
            if !stack.is_empty() {
                stack.reverse();
                incomplete.push((line.clone(), stack.clone()));
            }
            /*
            else {
                valid.push(line.clone());
            }
            */
        }
    }

    (corrupted.iter().map(|(_sentence, c)| {
        match c {
            ')' => 3,
            ']' => 57,
            '}' => 1197,
            '>' => 25137,
            _ => 0,
        }
    }).sum(), incomplete)
}

fn main() {
    let s = include_str!("../input.txt").lines().map(String::from).collect::<Vec<String>>();

    let result = aoc_10_part01(&s);
    println!("Result {}", result.0);

    let result = aoc_10_part02(&result.1);
    println!("Result {}", result);
}