#[path = "../lib.rs"]
mod lib;

enum Dir {
    Left,
    Right,
    Up,
    Down,
}

fn parse_input() -> (Vec<(Dir, i64)>, Vec<(Dir, i64)>) {
    let mut v1 = vec![];
    let mut v2 = vec![];

    for line in lib::iter_input() {
        let (d, tail) = line.split_once(' ').unwrap();
        let dir1 = match d {
            "L" => Dir::Left,
            "R" => Dir::Right,
            "U" => Dir::Up,
            "D" => Dir::Down,
            _ => unreachable!(),
        };
        let (n, c) = tail.split_once(' ').unwrap();
        let count1 = n.parse().unwrap();
        v1.push((dir1, count1));

        let count2 = i64::from_str_radix(&c[2..7], 16).unwrap();
        let dir2 = match c.bytes().nth(7).unwrap() {
            b'0' => Dir::Right,
            b'1' => Dir::Down,
            b'2' => Dir::Left,
            b'3' => Dir::Up,
            _ => unreachable!(),
        };
        v2.push((dir2, count2));
    }

    return (v1, v2);
}

fn count(border: &Vec<(Dir, i64)>) -> i64 {
    // https://en.wikipedia.org/wiki/Shoelace_formula
    //
    // ######|
    // ######|
    // ——####|
    // ..####|
    // ..####|
    // ####+—O
    // ####|..
    // —#####|
    // .#####|
    // .—————O
    //
    // + and O cancel each other out, but there must be one extra O

    let mut x = 0;
    let mut sum = 0;
    let mut edge = 0;
    for (dir, k) in border.iter() {
        match dir {
            Dir::Left => {
                x -= k;
            }
            Dir::Right => {
                x += k;
                edge += k;
            }
            Dir::Up => {
                sum += k * x;
            }
            Dir::Down => {
                sum -= k * x;
                edge += k;
            }
        };
    }
    return sum.abs() + edge + 1;
}

fn main() {
    let (v1, v2) = parse_input();

    println!("part1: {}", count(&v1));
    println!("part2: {}", count(&v2));
}