mod errors;

mod errors;

        assert_eq!(y.unwrap(), std::path::PathBuf::from("C:\\Users\\aviik\\AppData\\Roaming\\vfxpr\\config.ron"))

        assert_eq!(
            y,
            std::path::PathBuf::from("C:\\Users\\aviik\\AppData\\Roaming\\vfxpr\\config.ron")
        )

use std::{fs::{create_dir, write, File}, path::{PathBuf, Path}, collections::HashMap};

use std::{
    collections::HashMap,
    fs::{create_dir, write, File},
    path::{Path, PathBuf},
};

use serde::{Serialize, Deserialize};
use ron::de::{from_str, from_reader};

use ron::de::{from_reader, from_str};

use serde::{Deserialize, Serialize};

pub fn get_default_path() -> Option<PathBuf> {

pub fn get_default_path() -> PathBuf {

        Some(file_path)

        return file_path;

    None

    std::process::exit(1);

    let pretty = PrettyConfig::new()
    .depth_limit(2);

    let pretty = PrettyConfig::new().depth_limit(2);

#![allow(dead_code)]
use super::constants;
use std::{fmt::Display, path::PathBuf};
#[derive(Debug, Clone)]
enum VFxPRConfigType {
    Local,
    Sourced,
    Unknown,
}
#[derive(Debug, Clone)]
pub struct VFxPRConfigFile {
    pub config_path: Option<PathBuf>,
    config_type: VFxPRConfigType,
}
impl Default for VFxPRConfigFile {
    fn default() -> Self {
        if let Some(cf) = get_default_config() {
            //println!("Seeking file at: {:?}", );
            cf
        } else {
            Self {
                config_path: None,
                config_type: VFxPRConfigType::Unknown,
            }
        }
    }
}
impl Display for VFxPRConfigFile {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        if let Some(file_path) = &self.config_path {
            write!(f, "{:?}", file_path)
        } else {
            write!(f, "No file found")
        }
    }
}
impl VFxPRConfigFile {
    pub fn new(s: &str) -> Self {
        if PathBuf::from(s).is_file() {
            Self {
                config_path: Some(PathBuf::from(s)),
                config_type: VFxPRConfigType::Sourced,
            }
        } else {
            Self {
                config_path: None,
                ..Default::default()
            }
        }
    }
    // pub fn seek_default(&self)->Self {
    // }
}
fn get_default_path() -> PathBuf {
    if let Some(c_path) = dirs::config_dir() {
        let mut file_path = std::path::PathBuf::new();
        file_path.push(c_path);
        file_path.push(constants::VFXPRNAME);
        file_path.push(constants::VFXPRCONFIGFILENAME);
        file_path
    } else {
        PathBuf::new()
    }
}
fn get_default_config() -> Option<VFxPRConfigFile> {
    let file_path = get_default_path();
    if file_path.is_file() {
        let cf = VFxPRConfigFile {
            config_path: Some(file_path),
            config_type: VFxPRConfigType::Local,
        };
        // println!("found config file at {:?}", &file_path);
        return Some(cf);
    }
    None
}
pub fn check_config(cp: &VFxPRConfigFile, dd: bool) {
    if dd {
        println!("Config file set at ");
    }
    //         None => {
    //             // let l = match
    //             println!("No config file!");
    //             // std::process::exit(1)
    //         }
    //     }
}
pub fn create_config_file() -> bool {
    // let file_path = get_default_path();
    false
}

pub const VFXPRNAME: &str = "vfxpr";
pub const VFXPRCONFIGFILENAME: &str = "config.ron";
pub const VFXPRVERSION: &str = "0.0.1";
pub const VFXPRDEFAULTCONFIG: &str = r"";

pub mod config;
pub mod constants;

pub mod cli;

pub mod utils;

#[command(name = cli::constants::VFXPRNAME)]
#[command(author = "aviik c <aviik.c@outlook.com>")]
#[command(version = cli::constants::VFXPRVERSION)]
#[command(about = "VFx Dept Project Management Tool", long_about = None)]

//#[command(name = cli::constants::VFXPRNAME)]
// #[command(author = "aviik c <aviik.c@outlook.com>")]
// #[command(version = cli::constants::VFXPRVERSION)]
// #[command(about = "VFx Dept Project Management Tool", long_about = None)]
#[command(name = utils::constants::VFXPRNAME, author, version, about, long_about)]

    Cmd {
    /// shell snippet code
        code: Option<String>,
    },

    let mut config_path: cli::config::VFxPRConfigFile = cli::config::VFxPRConfigFile::default();

    let mut config_path: utils::config::VFxPRConfigFile = utils::config::VFxPRConfigFile::default();

        config_path = cli::config::VFxPRConfigFile::new(y);

        config_path = utils::config::VFxPRConfigFile::new(y);

            config_path = cli::config::VFxPRConfigFile::new(y);

            config_path = utils::config::VFxPRConfigFile::new(y);

        config_path = cli::config::VFxPRConfigFile::default();

        config_path = utils::config::VFxPRConfigFile::default();

    cli::config::check_config(&config_path, recieved_config);

    utils::config::check_config(&config_path, recieved_config);

        Some(Commands::Cmd { code }) => {
            println!(" got some text {:?}", code);
        }

thiserror = "1.0.38"
vfxpr_core = { path = "vfxpr_core/", version = "0.1.0" }