use std::collections::HashMap;

fn time_parse(time: &str) -> f64 {
    let (h, m) = time.split_once(':').unwrap();
    h.parse::<f64>().unwrap() * 60. + m.parse::<f64>().unwrap()
}
fn from_min_to_string(min: f64) -> String {
    let h = (min / 60.).floor() % 24.;
    let m = (min % 60.).floor();
    format!("{:02}:{:02}", h, m)
}

const BUS_SCHEDULES: &str = r#"Skyport	Crystalium	15 min	2 hours
Crystalium	Skyport	10 min	2 hours
Skyport	Oasis	20 min	3 hours
Oasis	Skyport	15 min	3 hours
Oasis	Crystalium	15 min	1.5 hours
Crystalium	Oasis	10 min	1.5 hours
Skyport	Nexus	15 min	4 hours
Nexus	Skyport	10 min	4 hours
"#;

fn arrival_time(route: Vec<&str>, departure_time: &str) -> String {
    let origin: Vec<&str> = vec!("Skyport");
    if route.is_empty() {
        return "The Train Driver has the day off".to_string();
    } else {
        let from = 0;
        let to = 1;
        let standby_time = 2;
        let travel_time = 4;

        let mut bus: HashMap<(String, String), (String, String)> = HashMap::new();
        for line in BUS_SCHEDULES.lines() {
            let data = line.split_whitespace().collect::<Vec<_>>();
            let bus_stop = (data[from].to_string(), data[to].to_string());
            let data_stop = (
                data[standby_time].to_string(),
                data[travel_time].to_string(),
            );
            bus.insert(bus_stop, data_stop);
        }
        let mut total_travel_time = 0.0;

        let full_route: Vec<&&str> = origin.iter().chain(route.iter()).collect::<Vec<_>>();

        for item in full_route.windows(2) {
            if item[0] == item[1] {
                total_travel_time += 1. * 60.;
            } else {
                let bus_stop = (item[0].to_string(), item[1].to_string());
                match bus.get(&bus_stop) {
                    Some((waiting_time, travel_time)) => {
                        total_travel_time += travel_time.parse::<f64>().unwrap() * 60.
                            + waiting_time.parse::<f64>().unwrap();
                    }
                    None => {
                        let back_to_origin = (item[0].to_string(), origin[0].to_string());
                        let from_origin_to_route = (origin[0].to_string(), item[1].to_string());
                        match bus.get(&back_to_origin) {
                            Some((waiting_time, travel_time)) => {
                              
                                total_travel_time += travel_time.parse::<f64>().unwrap() * 60.
                                    + waiting_time.parse::<f64>().unwrap();
                            }
                            None => {
                                panic!("Could not find route between {} and Skyport", item[0]);
                            }
                        }
                        match bus.get(&from_origin_to_route) {
                            Some((waiting_time, travel_time)) => {
                                total_travel_time += travel_time.parse::<f64>().unwrap() * 60.
                                    + waiting_time.parse::<f64>().unwrap();
                            }
                            None => {
                                panic!("Could not find route between Skyport and {}", item[1]);
                            }
                        }
                    }
                }
            }
        }
        from_min_to_string(total_travel_time + time_parse(departure_time))
    }
}

fn print(n: u64) -> u64 {
    let mut digits = n
        .to_string()
        .chars()
        .map(|c| c.to_digit(10).unwrap() as u64)
        .collect::<Vec<u64>>();
    digits.sort();
    digits
        .into_iter()
        .rev()
        .fold(0, |acc, digit| acc * 10 + digit)
}

fn sum(arr: &[i32]) -> i32 {
    match arr.is_empty() {
        true => 0,
        false => arr[..].iter().sum::<i32>(),
    }
}

fn hello_world(world: bool) -> String {
    if world {
        return "Hello, World".to_string();
    } 
    return "Goodbye, World".to_string();
}