/// the purpose of this crate is to invoke kernel routines 
pub mod kernel{

    /// depend crates {colorful, process};
    use colorful::{Color, Colorful};
    use std::process::{Command, Child, Stdio};

    /// Process struct acessible other crates within kernel module. This struct have two fields (command , args). 
    #[derive(Debug, PartialEq)]
    pub struct Process{

        pub command : String,
        pub args : String,
    }


    /// Kernellevel enumerate kernel level. i.e read, write etc.
    #[derive(Debug, PartialEq)]
    pub enum Kernellevel{

        Write,
        Read,
        None,
        Root,
    }


    /// new function takes two parameters as string and return struct. The purpose is to interact structs fields directly.
    pub fn new(command : String , args : String) -> Process{

        Process{
            command,
            args,
        }
    }

    /// process have following methods are attached. These methods will either allocate permission or intiate the process.

    impl Process{


        /// kernel permission allocate permission to complete the task. These permission allow to complete process within timeframe.
        pub fn kernel_permission(&self) -> Kernellevel {


            let mut klevel : Kernellevel = Kernellevel::None;
            if self.command.contains("ls "){

                klevel = Kernellevel::Read
            }

            if self.command.contains("cat "){

               klevel = Kernellevel::Read;
            }

            if self.command.contains("cd ") {

                klevel = Kernellevel::None;
            }

            if self.command.contains("mkdir ") {

                klevel = Kernellevel::None;
            }

            if self.command.contains("cp ") {

                klevel = Kernellevel::None;
            }

            if self.command.contains("touch ") {

                klevel = Kernellevel::Write;
            }

            if self.command.contains("rm ") {

                klevel = Kernellevel::Write;
            }

            if self.command.contains("mv "){

                klevel = Kernellevel::None;
            }

            if self.command.contains("sudo "){

                klevel = Kernellevel::Root; 
            }

            if self.command.contains("top ") {

                klevel = Kernellevel::None;
            }

            if self.command.contains("q") || self.command.contains("--q "){

                klevel = Kernellevel::None;
            }

            if self.command.contains("? ") || self.command.contains("help "){

                klevel = Kernellevel::None;
            }

            if self.command.contains("-v") || self.command.contains("--v "){

                klevel = Kernellevel::None;
            }

            if self.command.contains("whatis") {

                klevel = Kernellevel::None;
            }

            if self.command.contains("man "){

                klevel = Kernellevel::None;
            }

            if self.command.contains("exit"){

                klevel = Kernellevel::None;
            }

            klevel
        }

        /// purpose of listing is to view memory space. This method takes two parameters (self reference , level) & return  Result<Child>.
        /// there may be possible level is not checked, then it will throw unexpected state or panic suitation.
        /// there may be even possible that args are not included in commands.    
    
        pub fn listing(&self, level : Kernellevel) -> std::io::Result<Child> {
        

            if level == Kernellevel::None {
                
                println!("{}", " File Dispatch is not found".color(Color::Red).bold());
            
                panic!("file dispatch is not found");
            
            }
            
            if !(self.args.contains("-a")){

                let child = Command::new(self.command.clone()).spawn().expect("process created");

                println!("input = {:?}", child);
                return Ok(child);

            }else{

                let child = Command::new(self.command.clone()).arg(self.args.clone()).spawn().expect("process created");
                return Ok(child);
            }

        }

        /// the purpose of "cat" is to view the records or content in a memory space. e.g cat file.txt.
        /// cat takes two parameters similar to listing and return result.
        /// there may be possible that level is not checked.    
        pub fn cat_operation(&self, level : Kernellevel) -> std::io::Result<Child>{

            if level == Kernellevel::None{

                println!("{}", "File Dispatch is not found".color(Color::Red).bold());
                panic!("file dispatch is not found");

            }

            let child = Command::new(self.command.clone()).arg(self.args.clone()).spawn().expect("cat command!");

            Ok(child)

        }

        /// change directory is quite similar except the query will handle by stdout.  

        pub fn change_direc(&self) -> std::io::Result<Child>{

            let child = Command::new(self.command.clone()).arg(self.args.clone()).stdout(Stdio::piped()).spawn().expect("change your directory");

            Ok(child)
        }
    }
}


#[cfg(test)]
mod tests {
    use crate::kernel;

    #[test]
    fn instance() {

        let object : _ = kernel::new("ls ".to_string(), "-a ".to_string());

        assert_ne!(object, kernel::Process{command : "".to_string(), args : "".to_string()});
    }

    #[test]
    fn kernel_operation() {

        let object : _ = kernel::new("ls ".to_string(), "-a ".to_string());

        let pem : _ = object.kernel_permission();

        assert_ne!(pem, kernel::Kernellevel::None);
    }

    #[test]
    fn kernel_listing_command() {

        let object : _ = kernel::new("ls ".to_string(), "".to_string());

        let pem : _ = object.kernel_permission();

        let list : _ = object.listing(pem);

        let output : _ = list.expect("process created").wait_with_output().expect("child process running");

        assert_eq!(output.stdout, Vec::<u8>::new());
    }

    #[test]
    fn kernel_cat_operation() {

        let object : _ = kernel::new("cat ".to_string(), "file.txt".to_string());

        let pem : _ = object.kernel_permission();

        let cat_op : _ = object.cat_operation(pem);

        let allow :_ = cat_op.expect("child process created!").id();

        assert_ne!(allow, 0);
    }

    #[test]
    fn kernel_change_direc(){

        let object : _ = kernel::new("cd ".to_string(), "lib/".to_string());

        // let pem : _ = object.kernel_permission();

        let cd_op : _ = object.change_direc();

        let allow : _ = cd_op.expect("process created ...").wait_with_output().expect("child process running");

        assert!(allow.status.success());

    }
}