use anyhow::Context;
use clap::Parser;
use cli::Args;
use generator::MappingsGenerator;

mod cli;
mod generator;
mod mapping;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let args = Args::parse();

    stderrlog::new()
        .module(module_path!())
        .quiet(args.quiet)
        .show_module_names(false)
        .color(stderrlog::ColorChoice::Auto)
        .verbosity(args.verbosity as usize)
        .timestamp(stderrlog::Timestamp::Off)
        .init()?;

    // gen_lf_mappings(args.home_name, 0, args.relevant_directories);
    let map = MappingsGenerator::new(args.relevant_directories, args.depth, args.home_name)
        .await
        .context("Failed to initialize mappings generator")?;

    Ok(())
}

// fn gen_lf_mappings(home_name: PathBuf, char_num: usize, rel_dirs: Vec<PathBuf>) {
//     let mut mappings_vec = vec![];
//     let mut index_counter = 0;
//     rel_dirs.iter().for_each(|rel_dir| {
//         mappings_vec.push(vec![Mapping::new(
//             &gen_hot_key(rel_dir, rel_dir, char_num),
//             rel_dir,
//             rel_dir,
//             None,
//         )]);
//         get_dir(rel_dir.to_owned()).iter().for_each(|path| {
//             mappings_vec[index_counter].push(Mapping::new(
//                 &gen_hot_key(
//                     path,
//                     path.parent().expect("All paths here should have parents"),
//                     char_num,
//                 ),
//                 path,
//                 &path
//                     .parent()
//                     .expect("All paths here should have parents")
//                     .to_owned(),
//                 None,
//             ));
//         });
//         index_counter += 1;
//     });
//     print_mappings(&mappings_vec, home_name);
//     mappings_vec
//         .into_iter()
//         .for_each(|rel_dir_mapping: Vec<Mapping>| {
//             let mut hash_map = sort_mapping_by_hot_key(rel_dir_mapping.clone());
//             //dbg!(hash_map);
//             hash_map.insert("gsi".to_owned(), vec![rel_dir_mapping[0].clone()]);
//         });
// }
//
// fn sort_mapping_by_hot_key(mut mappings: Vec<Mapping>) -> HashMap<String, Vec<Mapping>> {
//     mappings.sort_by_key(|mapping| mapping.hot_key.clone());
//
//     let mut filtered_mappings: HashMap<String, Vec<Mapping>> = HashMap::new();
//     mappings.iter().for_each(|mapping| {
//         filtered_mappings.insert(mapping.hot_key.clone(), vec![]);
//     });
//     //dbg!(&mappings);
//
//     let mut index_counter = 1;
//     mappings.iter().for_each(|mapping| {
//         if mappings.len() > index_counter {
//             let next_mapping = &mappings[index_counter];
//             let vec = filtered_mappings
//                 .get_mut(&mapping.hot_key)
//                 .expect("This existst as it has been initialized");
//
//             if &next_mapping.hot_key == &mapping.hot_key {
//                 vec.push(mapping.clone());
//                 vec.push(next_mapping.clone());
//             } else {
//                 vec.push(mapping.clone());
//             }
//
//             let new_vec = vec.to_owned();
//             filtered_mappings.insert(mapping.hot_key.to_owned(), new_vec);
//         }
//
//         index_counter += 1;
//     });
//     filtered_mappings
// }
//
// fn print_mappings(mappings: &Vec<Vec<Mapping>>, home_name: PathBuf) {
//     for mapping in mappings {
//         mapping.iter().for_each(|map| {
//             println!(
//                 "{} = \"cd {}\";",
//                 map.hot_key,
//                 map.path
//                     .display()
//                     .to_string()
//                     .replace(home_name.to_str().expect("This should be UTF-8"), "~")
//             );
//         });
//
//         println!("# -------------");
//     }
// }