use std::collections::HashSet;
use std::collections::HashMap;
use std::env;
use std::fs;

use crate::Dir::{North, South, East, West, Stay };


type Coord = (i32, i32);
#[derive(Clone, Copy, Eq, PartialEq, Hash, Debug, PartialOrd, Ord)]
enum Dir { North, South, East, West, Stay }

fn step(start: &Coord, d: Dir, steps: i32) -> Coord {
    match d {
        North => (start.0, start.1 - steps),
        South => (start.0, start.1 + steps),
        East => (start.0 + steps, start.1),
        West => (start.0 - steps, start.1),
        Stay => *start,
    }
}

fn walk_path(start: &Coord, path: &[Dir]) -> Coord {
    let mut here = *start;
    for d in path {
        here = step(&here, *d, 1);
    }
    return here;
}

fn main() {
    println!("Hello, AoC day 21!");

    let args: Vec<String> = env::args().collect();
    if args.len() != 2 {
        println!("wrong number of arguments!");
        std::process::exit(1);
    }

    let file_path = &args[1];

    let file = fs::read_to_string(file_path)
        .expect("should be able to read the file");

    let keypad_door: HashMap<char, Coord> = HashMap::from([
        ('7', (0,0)), ('8', (1,0)), ('9', (2,0)),
        ('4', (0,1)), ('5', (1,1)), ('6', (2,1)),
        ('1', (0,2)), ('2', (1,2)), ('3', (2,2)),
        ('0', (1,3)), ('A', (2,3)),
        ]);
    let mut door_map: HashMap<Coord, char> = HashMap::new();
    for (key, loc) in &keypad_door { door_map.insert(*loc, *key); }
    let mut directions_matrix: HashMap<(Coord, Coord), Vec<(Dir, i32)>> = HashMap::new();
    for (_this, here) in &keypad_door {
        for (_other, there) in &keypad_door {
            let mut v = vec![];
            if there.0 > here.0 {
                v.push((East, there.0 - here.0));
            }
            if there.0 < here.0 {
                v.push((West, here.0 - there.0));
            }
            if there.1 > here.1 {
                v.push((South, there.1 - here.1));
            }
            if there.1 < here.1 {
                v.push((North, here.1 - there.1));
            }
            if there == here {
                v.push((Stay, 0));
            }
            directions_matrix.insert((*here, *there), v);
        }
    }


    let keypad_arrows: HashMap<Dir, Coord> = HashMap::from([
        (North, (1,0)), (Stay, (2,0)),
        (West, (0,1)), (South, (1,1)), (East, (2,1)),
        ]);
    let mut keypad_map: HashMap<Coord, Dir> = HashMap::new();
    for (key, loc) in &keypad_arrows { keypad_map.insert(*loc, *key); }
    let mut keypad_directions_matrix = HashMap::new();
    for (_this, here) in &keypad_arrows {
        for (_other, there) in &keypad_arrows {
            let mut v = vec![];
            if there.0 > here.0 {
                v.push((East, there.0 - here.0));
            }
            if there.0 < here.0 {
                v.push((West, here.0 - there.0));
            }
            if there.1 > here.1 {
                v.push((South, there.1 - here.1));
            }
            if there.1 < here.1 {
                v.push((North, here.1 - there.1));
            }
            if there == here {
                v.push((Stay, 0));
            }
            keypad_directions_matrix.insert((*here, *there), v);
        }
    }

    let mut sum = 0;
    for line in file.lines() {
        let door_code: Vec<char> = line.chars().collect();
        let num: i32 = line[..line.len()-1].parse().expect("failed to parse door code as number");
        let mut complexity: i64 = 100000000000;
        
        for x in &door_code {
            print!("{}", x);
        }
        print!("\n");

        let options_door = build_options(
            &directions_matrix, 
            &keypad_door, 
            &door_code, 
            'A');
        for arrow_code_1 in shortest_sequences(options_door, &door_map, keypad_door[&'A']) {
            print_code(&arrow_code_1);

            let options_arrow_1 = build_options(
                &keypad_directions_matrix,
                &keypad_arrows,
                &arrow_code_1,
                Stay);
            for arrow_code_2 in shortest_sequences(options_arrow_1, &keypad_map, keypad_arrows[&Stay]) {
                print_code(&arrow_code_2);

                let options_arrow_2 = build_options(
                    &keypad_directions_matrix,
                    &keypad_arrows,
                    &arrow_code_2,
                    Stay);
                for arrow_code_3 in shortest_sequences(options_arrow_2, &keypad_map, keypad_arrows[&Stay]) {
                    complexity = complexity.min(arrow_code_3.len() as i64);
                    print_code(&arrow_code_3);
                }
            }
        }
        println!("shortest sequence is {} long", complexity);
        sum += complexity * (num as i64);
    }

    println!("the sum of the complexity scores is {}", sum);

    // println!("printing out the anomalous code");

    // let code = "<<vAA>A>^AAvA<^A>AvA^A<<vA>>^AAvA^A<vA>^AA<A>A<<vA>A>^AAAvA<^A>A";
    // let code_dirs = code.chars().map(|x| match x {
    //     '<' => West, '>' => East, '^' => North, 'v' => South, 'A' => Stay, _ => panic!()
    // }).collect();
    // print_code(&code_dirs);
    // println!("resulting keypresses:");
    // let code_2 = execute_code(&code_dirs, &keypad_map, keypad_arrows[&Stay]);
    // print_code(&code_2);
    // println!("resulting keypresses:");
    // let code_3 = execute_code(&code_2, &keypad_map, keypad_arrows[&Stay]);
    // print_code(&code_3);
    // println!("resulting in:");
    // let code_4 = execute_code(&code_3, &door_map, keypad_door[&'A']);
    // print_code_door(&code_4);


}

fn first_sequence<T>(options: Vec<Vec<(Dir, i32)>>, map: &HashMap<Coord, T>, start: Coord) -> Vec<Dir> {
    let mut out = vec![];
    let mut here = start;

    for choices in options {
        if choices.len() == 1 {
            let (direction, times) = choices[0];
            for _ in 0..times {
                out.push(direction);
            }
            here = step(&here, direction, times)
        } else if choices.len() == 2 {
            let (d1, t1) = choices[0];
            let (d2, t2) = choices[1];
            if map.contains_key(&step(&here, d1, t1)) {
                for _ in 0..t1 {
                    out.push(d1);
                }
                
                for _ in 0..t2 {
                    out.push(d2);
                }
            } else {
                for _ in 0..t2 {
                    out.push(d2);
                }

                for _ in 0..t1 {
                    out.push(d1);
                }
            }
            
            
        }
    }
    return out;
}
fn sequences<T>(options: Vec<Vec<(Dir, i32)>>, map: &HashMap<Coord, T>, start: Coord) -> Vec<Vec<Dir>> {
    let mut out: Vec<(Vec<Dir>, Coord)> = vec![(vec![], start)];

    for choices in options {
        let mut new_out = vec![];

        if choices.len() == 1 {
            let (direction, times) = choices[0];
            for (mut walk, mut here) in out {
                for _ in 0..times {
                    walk.push(direction);
                    here = step(&here, direction, 1);
                }
                new_out.push((walk, here));
            }
        }
        
        else if choices.len() == 2 {
            let (d1, t1) = choices[0];
            let (d2, t2) = choices[1];

            for (ref walk, here) in &mut out {
                let end = step(&step(&here, d1, t1), d2, t2);
                let candidate_here = step(&here, d1, t1);
                if map.contains_key(&candidate_here) {
                    let mut ab_walk = walk.clone();

                    for _ in 0..t1 { ab_walk.push(d1); }
                    for _ in 0..t2 { ab_walk.push(d2); }

                    new_out.push((ab_walk, end));
                }

                let candidate_there = step(&here, d2, t2);
                if map.contains_key(&candidate_there) {
                    let mut ba_walk = walk.clone();

                    for _ in 0..t2 { ba_walk.push(d2); }
                    for _ in 0..t1 { ba_walk.push(d1); }

                    new_out.push((ba_walk, end));
                }

            }
        } else {
            panic!("encountered a bad set of choices");
        }

        out = new_out;
    }

    let mut final_out = vec![];
    for (walk, _) in out {
        final_out.push(walk);
    }
    return final_out;
}

fn shortest_sequences<T>(
    options: Vec<Vec<(Dir, i32)>>, 
    map: &HashMap<Coord, T>, 
    start: Coord
) -> Vec<Vec<Dir>> {
    let mut short_length = None;
    let mut shorts = vec![];

    for seq in sequences(options.to_vec(), map, start) {
        let my_len = seq.len();
        if let Some(len) = short_length {
            if my_len == len {
                shorts.push(seq);
            } else if my_len < len {
                shorts = vec![seq];
                short_length = Some(my_len);
            }
        } else {
            short_length = Some(my_len);
            shorts.push(seq);
        }
    }

    return shorts;
}

fn build_options<T: std::hash::Hash + std::cmp::Eq>(
    routes: &HashMap<(Coord, Coord), Vec<(Dir, i32)>>, 
    map: &HashMap<T, Coord>,
    sequence: &Vec<T>,
    start: T,
) -> Vec<Vec<(Dir, i32)>> {
    let mut here = map[&start];
    let mut options: Vec<Vec<(Dir, i32)>> = Vec::new();
    for button in sequence {
        let there = map[&button];
        options.push(routes[&(here, there)].clone());
        options.push(vec![(Stay, 1)]);
        here = there;
    }

    return options;
}


fn print_code(code: &Vec<Dir>) {
    for x in code {
        print!("{}", match x { 
            North => '^', South => 'v', East => '>', West => '<', Stay => 'A'
        });
    }
    print!("\n");
}

fn print_code_door(code: &Vec<char>) {
    for x in code {
        print!("{}", x);
    }
    print!("\n");
}


fn execute_code<T: Clone + Copy>(
    code: &Vec<Dir>, 
    map: &HashMap<Coord, T>, 
    start: Coord
) -> Vec<T> {

    let mut out = vec![];
    let mut here = start;
    for d in code {
        if *d == Stay {
            out.push(map[&here]);
        } else {
            here = step(&here, *d, 1);
        }

    }
    return out;

}