#[macro_use]
extern crate rust_util;

mod config;
mod build_util;
mod docker_util;

use std::fs;
use std::env;
use std::path::{Path, PathBuf};
use rust_util::util_file;
use docker_util::DockerCmd;

fn main() {
    information!("{} v{}", env!("CARGO_PKG_NAME"), env!("CARGO_PKG_VERSION"));

    let docker_build_config = config::load_docker_build_config_or_default();

    let mut args_iter = env::args().skip(1).peekable();
    let mut get_docker_image = || {
        if let Some(first_arg) = args_iter.peek() {
            if first_arg.starts_with(":image:") {
                let image_name = first_arg[7..].to_string();
                args_iter.next(); // skip ':image:*'
                return image_name;
            }
        }
        docker_build_config.image.clone().expect("Image is not configed in config file!")
    };
    let docker_image = get_docker_image();
    let mut get_crates_mirror = || {
        if let Some(first_arg) = args_iter.peek() {
            if first_arg.starts_with(":mirror:") {
                let mirror = first_arg[8..].to_string();
                args_iter.next(); // skip ':mirror:*'
                return Some(mirror);
            }
        }
        None
    };
    let crates_mirror = get_crates_mirror();

    let args = args_iter.map(|a| a.to_owned()).collect::<Vec<_>>();

    let mut docker_cmd = DockerCmd::new(&docker_image);
    docker_cmd.add_volumn(&get_final_docker_registry(&docker_image), "/usr/local/cargo/registry");
    if let Some(mirror) = &crates_mirror.or(docker_build_config.mirror) {
        if mirror.to_lowercase() != "none" {
            docker_cmd.mirror(mirror);
        }
    }
    docker_cmd.exec(&args).unwrap();
}

fn get_final_docker_registry(docker_image: &str) -> String {
    let docker_registry_path_buf =get_resolved_docker_registry(docker_image).expect("Cannot find $HOME !");
    let docker_registry = docker_registry_path_buf.to_str().expect("Cannot find $HOME !!");
    check_docker_registry_exists(&docker_registry).expect("Check docker registry exists failed!");
    docker_registry.to_string()
}

fn check_docker_registry_exists(docker_registry: &str) -> Option<()> {
    let p = Path::new(docker_registry);
    if !p.exists() {
        if let Err(e) = fs::create_dir_all(&docker_registry) {
            failure!("Create dir failed: {:?}, error: {}", p, e);
            return None;
        }
    }
    Some(())
}

fn get_resolved_docker_registry(image: &str) -> Option<PathBuf> {
    util_file::get_absolute_path(&get_docker_registry(image))
}

fn get_docker_registry(image: &str) -> String {
    let mut registry = "~/.dockerbuild/register/".to_owned();
    for c in image.chars() {
        match c {
            'a'..='z' | 'A'..='Z' | '0'..='9' => registry.push(c),
            _ => registry.push('_'),
        }
    }
    registry
}

#[test]
fn test_get_docker_registry() {
    assert_eq!("~/.dockerbuild/register/rust_1_47", get_docker_registry("rust:1.47"));
}