use advent_of_code::include_aoc;
use advent_of_code::strings::{convert_to_array, parsenumber};

include_aoc!(2024, 01);

pub fn splitspace(input: &str) -> (u32, u32) {
    println!("{}", input);
    let mut output = input.split_ascii_whitespace();
    (parsenumber(output.next().unwrap()), parsenumber(output.next().unwrap()))
}

fn distance(leftlist: &Vec<u32>, rightlist: &Vec<u32>) -> u32 {
    let mut distance = 0;
    for i in 0..leftlist.len() {
        let left = leftlist[i];
        let right = rightlist[i];
        distance += match right > left {
            true => right - left,
            false => left - right,
        };
    }
    distance
}

fn similarity(leftlist: &Vec<u32>, rightlist: &Vec<u32>) -> u32 {
    let mut similarity = 0;
    let mut count: u32;
    for i in leftlist {
        if rightlist.contains(i) {
            count = 0;
            for j in rightlist {
                if *i == *j {
                    count += 1;
                }
            }
            similarity += i * count;
        }
    }
    similarity
}

fn main() {
    let mut leftlist = Vec::<u32>::with_capacity(1000);
    let mut rightlist = Vec::<u32>::with_capacity(1000);
    for (left, right) in convert_to_array::<_, _, '\n'>(DATA, splitspace) {
        leftlist.push(left);
        rightlist.push(right);
    }
    leftlist.sort();
    rightlist.sort();
    let length = leftlist.len();
    if length != rightlist.len() {
        println!("Not matching lists");
        return;
    }
    println!("Maximum Distance: {}", distance(&leftlist, &rightlist));
    println!("Similarity: {}", similarity(&leftlist, &rightlist))
}