use <std::path::Path>;
use <std::path::PathBuf>;
use <std::fs>;
use <std::process>;

#[derive(Debug)]
pub class Module {
    pub String name;
    pub PathBuf path;
    pub Vec<Self> children;

    pub constructor(String name, PathBuf mist_path, PathBuf rust_path) {
        self.children = new Vec();
        self.name = name;
        self.path = mist_path;

        if (self.path.is_dir()) {
            PathBuf dir = self.path.clone();

            // Behavior 2: It's a directory node. Check for gateway package.mist first.
            PathBuf pkg_gate = self.path.join("package.mist");
            if (pkg_gate.exists()) {
                self.path = pkg_gate;
            }
            
            self.scan_directory(&dir, &rust_path);
        }
    }

    void scan_directory(self mut*, Path* search_dir, Path* rust_path) {
        var entries = match (fs::read_dir(search_dir)) {
            Ok[entries] => entries;
            Err[e] => {
                eprintln!("error: failed to read directory {}\n  {}", search_dir.display(), e);
                process::exit(1);
            }
        };

        for (entry : entries) {
            var entry = match (entry) {
                Ok[entry] => entry;
                Err[e] => {
                    eprintln!("error: failed to read directory entry\n  {}", e);
                    process::exit(1);
                }
            };

            PathBuf child_path = entry.path();

            if (child_path == self.path) {
                continue;
            }

            String child_name = child_path.file_stem()
                .and_then(|var s| s.to_str())
                .expect("Failed to get module name")
                .to_string();

            PathBuf child_output = rust_path.join(&child_name).with_extension("rs");

            if (!child_path.is_dir() && should_skip(&child_path, &child_output)) {
                continue;
            }

            self.children.push(new Module(child_name, child_path, child_output));
        }
    }

    pub PathBuf output_dir(self*, PathBuf* parent_dir) {
        if (self.path.is_dir() || Some("package.mist") == self.path.file_name().unwrap().to_str()) {
            parent_dir.join(&self.name)
        } else {
            parent_dir.clone()
        }
    }

    pub PathBuf output_path(self*, PathBuf* parent_dir) {
        if (self.path.is_dir() || Some("package.mist") == self.path.file_name().unwrap().to_str()) {
            parent_dir.join(&self.name).join("mod.rs")
        } else {
            parent_dir.join(&self.name).with_extension("rs")
        }
    }
}

pub Module master_package(PathBuf mist_path, PathBuf rust_path) {
    String name = mist_path.file_stem()
        .and_then(|var s| s.to_str())
        .expect("Failed to get module name")
        .to_string();

    var mut root_mod = new Module(name, mist_path.clone(), rust_path.clone());

    if (!mist_path.is_dir()) {
        PathBuf parent_dir = mist_path.parent()
            .expect("Failed to get parent directory of root file")
            .to_path_buf();
            
        root_mod.scan_directory(&parent_dir, &rust_path);
    }

    root_mod
}

bool should_skip(Path* source, Path* output) {
    var src_time = fs::metadata(source)
        .ok()
        .and_then(|var v| v.modified().ok());

    var out_time = fs::metadata(output)
        .ok()
        .and_then(|var v| v.modified().ok());

    out_time
        .map(|var out_time| out_time >= src_time.unwrap())
        .unwrap_or_default()
}