use serde::{Deserialize}; use serde_yaml::{self, Value};

use serde::{Deserialize};
use serde_yaml::{self};

struct Cli {

struct CliArgs {

#[serde(rename_all = "camelCase")]

    kind, String,

    kind: String,

fn parse_karbonfile(file_path: &PathBuf) -> Karbonfile {
    let file = fs::File::open(file_path)

//
// Return any karbon.{yml, yaml} file if a directory
// is provided. Else return the path as is.
// /!\ Success doesn't mean that the file is valid /!\
//
fn find_resource_file(path: &PathBuf) -> PathBuf {
    let mut path = path.canonicalize()
        .expect("Failed to canonicalize the path provided.");
    // If path is a directory try to find a path/karbon.yml file.
    if path.is_dir() {
        path.push("karbon.yml");
    }
    // If path/karbon.yml is not a file, try .yaml extension.
    if !path.is_file() {
        path.set_extension("yaml");
    }
    // At that point give up and panic.
    if !path.is_file() {
        panic!("Not a valid file path or no karbonfile found.");
    }
    return path;
}
#[derive(Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
struct ResourceType {
    api_version: String,
    kind: String,
}
fn get_resource_type(path: &PathBuf) -> ResourceType {
    let file = fs::File::open(path)

        .expect("Failed to parse to file.");

        .expect("Failed to parse the file.");

    match get_resource_type(path).kind.as_str() {
        "Karbonfile" => return true,
        _ => return false,
    };

fn karbonfile(path: &PathBuf) -> (PathBuf, Karbonfile) {
    let mut karbonfile_path: PathBuf = path
                .canonicalize()
                .expect("Failed to canonicalize the path provided.");

fn parse_karbonfile(path: &PathBuf) -> Karbonfile {
    let file = fs::File::open(path)
        .expect("Failed to open the file.");

    // When given a directory search for any karbon.{yml, yaml} file.
    if karbonfile_path.is_dir() {
        karbonfile_path.push("karbon.yml");

    return serde_yaml::from_reader(file)
        .expect("Failed to parse the file.");
}

        if !karbonfile_path.is_file() {
            karbonfile_path = karbonfile_path.with_extension("yaml");
        };

fn merge_relative_path(first: &PathBuf, second: &PathBuf) -> PathBuf {
    match (first.is_file(), first.parent(), second.is_relative()) {
        // First is a file path and as a parent directory.
        // Second is a relative path.
        // Append Second to First and canonicalize the result.
        (true, Some(path), true) => {
            return path.join(second)
                .canonicalize()
                .expect("Failed to canonitize the merged paths");
        }
        // First is a file and it's doesn't have a parent (Not even "/").
        // This shouldn't happen.
        (true, None, _) => {
            panic!("Failed to merge paths. The first path doesn't have any parent");
        }
        // First is a diretory and second is relative.
        (false, _, true) => {
            return first.join(second)
                .canonicalize()
                .expect("Failed to canonitize the merged paths");
        }
        // Second is not a relative path.
        // In this case just return the Second path.
        (_, _, false) => {
            return second.clone();
        }
    }
}

        if !karbonfile_path.is_file() {
            panic!("No karbon.yml or karbon.yaml file found.")
        };
    };

fn build_tree(path: PathBuf, mut branch: Vec<PathBuf>, result: &mut Vec<Vec<PathBuf>>) {
    let canonical = find_resource_file(&path);

    let content: Karbonfile = parse_karbonfile(&karbonfile_path);
    println!("{:?}", &content);
    return (karbonfile_path, content);

    // add the current path to the branch we are building
    branch.push(canonical.clone());

}

    if is_karbonfile(&canonical) {
        let resources: Vec<PathBuf> = parse_karbonfile(&canonical)
            .resources
            .into_iter()
            .collect();

fn build_karbonfile_list(path: &PathBuf, accumulator: &mut Vec<PathBuf>) {
    let (karbonfile_path, content) = karbonfile(&path);
    accumulator.push(karbonfile_path);

        if resources.is_empty() {
            // leaf since it's a karbonfile but there
            // is no resources in it. 
            result.push(branch);
        } else {
            // not a leaf here since it's a karbonfile
            // and there is resources to go through.
            // So start a new branch an keep walking.
            for r in resources {
                let next_path = merge_relative_path(&path, &r);

    for resource in content.resources.iter() {
        let full_path = &path.join(resource);
        match &full_path.file_name().unwrap().to_string_lossy() {
            "karbon.yml" | "karbon.yaml" =>
                build_karbonfile_list(&full_path, accumulator),

                build_tree(next_path, branch.clone(), result);
            }

    } else {
        // leaf since it's not a karbonfile
        result.push(branch);

    let cli = Cli::parse();

    let cli = CliArgs::parse();

    match &cli.command {

    match cli.command {

            let mut accumulator: Vec<PathBuf> = Vec::new();

            let mut result: Vec<Vec<PathBuf>> = Vec::new();

            build_karbonfile_list(path, &mut accumulator);
            for i in accumulator.iter() {
                println!("{:?}", &i);

            build_tree(path, Vec::new(), &mut result);
            for i in result.iter() {
                println!("{:?}", i);