extern crate serde;
extern crate terminal_size;

#[macro_use]
extern crate serde_derive;

/// Contains things related to displaying things in a terminal. Minimally that is. See the aesthetic module for making things look decent.
pub mod disp {
    use std::fmt;

    /// Prints anything that has a std::fmt::Display trait.
    pub fn print<T>(text: T) where T: fmt::Display {
        println!("{}", text);
        return;
    }

    /// Prints a newline.
    pub fn newline() {
        println!("");
        return;
    }

    /// Prints anything with the std::fmt::Debug trait. Useful for printing different collections.
    pub fn print_debug<T>(data: T) where T: fmt::Debug {
        println!("{:?}", data);
        return;
    }
}

/// The range module. [DEPRECATED]
pub mod range {
    /// Returns a Vec with a range of elements. [DEPRECATED]
    pub fn range(x: u32, y: u32) -> Vec<u32> {
        // Make a new counter. Probably bad practice and should be fixed.
        let mut iterator = x;

        // Create a Vec and assign it each number in the provided range and return.
        let mut list = Vec::new();
        list.push(iterator);
        while iterator != y {
            iterator += 1;
            list.push(iterator);
        }
        return list;
    }
}

/// Contains things related to getting args.
pub mod arg {
    use std::env;

    /// Returns a Vec of all arguments sent to the program.
    pub fn get_args() -> Vec<String> {
        let args = env::args().collect();
        return args;
    }
}

/// Contains some random things that might be useful when working with strings.
pub mod stringutil {
    use std::string::String;

    /// Extract the char at a specific location in a string.
    pub fn get_char_pos(string: &String, char_loc: usize) -> char {
        let char_vec: &Vec<char> = &string.chars().collect();
        return char_vec[char_loc];
    }

    /// Get a empty newline string. Purely for making code look prettier.
    pub fn newline() -> String {
        let newline = String::from("\n");
        return newline;
    }
}

/// The appinfo module. Contains stuff related to the APPINFO standard this library uses. Providing a valid appinfo may be required for some functions in the future.
/// Meant to be set as a constant at the beginning of the main source file.
pub mod appinfo {
    /// A simple struct for storing appinfo data.
    #[derive(Serialize, Deserialize, Debug, Clone, Copy)]
    pub struct AppInfo {
        pub name: &'static str,
        pub author: &'static str,
        pub repository: &'static str,
        pub crate_link: &'static str,
    }

    /// Implements for the struct AppInfo.
    impl AppInfo {
        /// Generate a new, empty appinfo.
        pub fn new() -> AppInfo {
            let appinfo: AppInfo = AppInfo {name: "", author: "", repository: "", crate_link: ""};
            return appinfo;
        }
    }
}

/// Point: Define a point on a 2D canvas.
pub mod point {
    #[derive(Serialize, Deserialize, Debug, Clone, Copy)]
    pub struct Point {
        pub x: i32,
        pub y: i32,
    }

    impl Point {
        pub fn new() -> Point {
            let point: Point = Point {x: 0, y: 0};
            return point;
        }
    }
}

/// Coordinate: Define a point on a 3D canvas.
pub mod coordinate {
    #[derive(Serialize, Deserialize, Debug, Clone, Copy)]
    pub struct Coordinate {
        pub x: i32,
        pub y: i32,
        pub z: i32,
    }

    impl Coordinate {
        pub fn new() -> Coordinate {
            let coordinate: Coordinate = Coordinate {x: 0, y: 0, z: 0};
            return coordinate;
        }
    }
}

/// Stuff related to making shapes. Both 2D and 3D.
pub mod shape {
    pub mod quadrilateral {
        use point::Point;

        #[derive(Serialize, Deserialize, Debug, Clone, Copy)]
        pub struct Quadrilateral {
            pub corner: [Point; 4],
        }

        impl Quadrilateral {
            pub fn new() -> Quadrilateral {
                let quadrilateral: Quadrilateral = Quadrilateral {corner: [Point {x: 0, y: 0}; 4]};
                return quadrilateral;
            }
        }
    }

    pub mod hexahedron {
        use coordinate::Coordinate;

        #[derive(Serialize, Deserialize, Debug, Clone, Copy)]
        pub struct Hexahedron {
            pub corner: [Coordinate; 8],
        }

        impl Hexahedron {
            pub fn new() -> Hexahedron {
                let hexahedron: Hexahedron = Hexahedron {corner: [Coordinate {x: 0, y: 0, z: 0}; 8]};
                return hexahedron;
            }
        }
    }
}

/// Stuff for error handling and exiting smoothly.
pub mod error {
    use std::process;
    use ::disp::print;
    use ::stringutil;

    /// Defines an error.
    #[derive(Serialize, Deserialize, Debug, Clone)]
    pub struct Error {
        pub errormessage: String,
        pub exitcode: u8,
        pub exit: bool,
    }

    /// Construct an error which exits.
    pub fn const_error(errormessage: &'static str, exitcode: u8) -> Error {
        let error = Error {errormessage: String::from(errormessage), exitcode: exitcode, exit: true};
        return error;
    }

    /// Construct an error that doesn't exit. Really just a error template.
    pub fn const_error_noexit(errormessage: &'static str) -> Error {
        let error = Error {errormessage: String::from(errormessage), exitcode: 1, exit: false};
        return error;
    }

    /// Takes an error and prints everything in a nice standarized format.
    pub fn error(error: Error) {
        print([String::from("Error: "), error.errormessage, stringutil::newline()].concat());

        // Exit if the exit var is set to true.
        if error.exit {
            process::exit(error.exitcode as i32);
        }
        return;
    }
}

/// Everything related to argument parsing and help texts.
pub mod argumentparser {
    /// Defines a argument.
    #[derive(Serialize, Deserialize, Debug, Clone)]
    pub struct Argument {
        pub identifier: char,
        pub description: String,
    }

    /// Everything related to help texts.
    pub mod help {
        use std::string::String;
        use ::argumentparser::Argument;
        use ::aesthetic::border;
        use ::disp::print;
        use ::stringutil;

        /// Takes a Vec of all valid Arguments and an usage paramater and turns it into a help text and prints it.
        pub fn help(usage: &'static str, arg_array: Vec<Argument>) {

            // Make a new Vec to store each line of the help text.
            let mut help: Vec<String> = Vec::new();

            // Add the border, template and the usage text.
            help.push([border::horizontal(String::from("-")), stringutil::newline()].concat());
            help.push([String::from("Usage:\n    "), String::from(usage), stringutil::newline()].concat());
            help.push(String::from("Flags:"));

            // Add every argument.
            for argument in arg_array {
                help.push([String::from("    -"), argument.identifier.to_string(), String::from(" # "), argument.description].concat());
            }

            // Add a newline at the end.
            help.push(stringutil::newline());

            // Then finally print everything.
            for line in &help {
                print(&line);
            }
            return;
        }
    }

    /// A simple argument parser. In it's current state. You probably want to use clap instead.
    pub mod parse {
        use std::collections::HashMap;
        use ::argumentparser::Argument;

        pub fn parseargs(argstring: String, valid_arg_array: Vec<Argument>) -> HashMap<String, bool> {
            // Make a new HashMap to store if an argument is given.
            let mut arg_bool_list = HashMap::new();

            // Set every argument to false as a base,
            for validarg in &valid_arg_array {
                arg_bool_list.insert(validarg.identifier.to_string(), false);
            }

            // Check every character in the provided argument string if it's valid. And if so, set it's entry to true.
            for arg in argstring.chars() {
                for validarg in &valid_arg_array {
                    if arg == validarg.identifier {
                        arg_bool_list.remove(&validarg.identifier.to_string());
                        arg_bool_list.insert(validarg.identifier.to_string(), true);
                    }

                }
            }
            return arg_bool_list;
        }
    }
}

/// This module is used for making your terminal applications look better.
pub mod aesthetic {
    pub mod border {
        use std::iter;
        use terminal_size::terminal_size;

        /// Create an horizontal border with the length of the terminal.
        pub fn horizontal(border_char: String) -> String {
            // Get the width of the terminal.
            let term_size = terminal_size().unwrap();
            let term_width: usize = (term_size.0).0 as usize;

            // Create a infinite generator of the character provided and take as many as the terminal fits.
            let border = iter::repeat(border_char).take(term_width).collect::<String>();
            return border;
        }
    }
}

/// A module containing the PointString type, a string variant comprised of a Vec<u8> which provides easy access and manipulation of individual
/// bytes with upcoming support for in memory compression of strings.
pub mod pstring {
    use std::vec::Vec;
    use std::string::String;
    use std::str;

    /// The PointString, a string variant comprised of a Vec<u8> which provides easy access and manipulation of individual
    /// bytes with upcoming support for in memory compression of strings.
    #[derive(Serialize, Deserialize, Debug, Clone)]
    pub struct PString {
        codepoints: Vec<u8>,
    }

    impl PString {
        /// Create a new, empty PString.
        pub fn new() -> PString {
            let returnvalue: PString = PString { codepoints: vec![] };
            return returnvalue;
        }

        /// Create a new PString with a Vec of bytes.
        pub fn set(codepoints: Vec<u8>) -> PString {
            let returnvalue: PString = PString { codepoints: codepoints };
            return returnvalue;
        }

        /// Set the bytes of an existing PString.
        pub fn set_existing(mut self: &mut Self, codepoints: Vec<u8>) {
            self.codepoints = codepoints;
        }

        /// Create a PString from a String.
        pub fn from_str(string: &'static str) -> PString {
            let mut returnvalue: PString = PString::new();
            for character in string.chars() {
                let codepoint: u8 = character as u8;
                returnvalue.codepoints.push(codepoint);
            }
            return returnvalue;
        }

        /// Convert to a regular String.
        pub fn to_string(self: &Self) -> String {
            let returnvalue: String = str::from_utf8(&self.codepoints[..]).unwrap().to_string();
            return returnvalue;
        }

        /// Get the individual bytes that make up a PString.
        pub fn get(self: &Self) -> Vec<u8> {
            let returnvalue = self.codepoints.clone();
            return returnvalue;
        }
    }
}

#[cfg(test)]
mod tests {
    use ::range;
    use ::error;
    use ::aesthetic::border;
    use ::argumentparser;
    use ::argumentparser::Argument;
    use ::pstring::PString;

    #[test]
    fn range() {
        let testvec = range::range(0, 4);
        println!("{:?}", testvec);
    }

    #[test]
    fn error() {
        let error = error::const_error_noexit("This is a sample error, beep beep.");
        error::error(error);
    }

    #[test]
    fn bordertest() {
        let border = border::horizontal(String::from("-"));
        println!("{}", border);
    }

    #[test]
    fn arghelptest() {
        let usage = "[PROGRAM NAME] -[CATEGORIES AND SWITCHES]";
        let arg1: Argument = Argument { identifier: 'v', description: String::from("Prints the program version") };
        let arg2: Argument = Argument { identifier: 't', description: String::from("Prints \"Rust is the best language\"") };
        let mut arg_array: Vec<Argument> = Vec::new();
        arg_array.push(arg1);
        arg_array.push(arg2);
        argumentparser::help::help(usage, arg_array);
    }

    #[test]
    fn argparser() {
        let args = String::from("-vt");
        let arg1: Argument = Argument { identifier: 'v', description: String::from("Prints the program version") };
        let arg2: Argument = Argument { identifier: 't', description: String::from("Prints \"Rust is the best language\"") };
        let mut arg_array: Vec<Argument> = Vec::new();
        arg_array.push(arg1);
        arg_array.push(arg2);
        let ev = argumentparser::parse::parseargs(args, arg_array);
        println!("{:?}", ev);
    }

    #[test]
    fn pstring() {
        let teststr = "hmm";
        let mut pstr = PString::from_str(teststr);
        for codepoint in pstr.get() {
            println!("{}", codepoint.to_string());
        }
        println!("{}", pstr.to_string());
        pstr.set_existing(vec![110]);
        println!("{}", pstr.to_string());
    }
}