filelib 0.1.3

mod sender;

use std::env;
use std::ffi::OsStr;
use std::fs::{create_dir, File, OpenOptions, read_dir};
use std::io::{Error, ErrorKind, Read, Write};
use std::net::{TcpListener, TcpStream};
use std::path::{PathBuf};


/// **This is a file manager**.
pub struct FileManager;

impl FileManager {
    /// Creates a new File.
    /// # Arguments
    /// * `path` - The name of the file.(This will get the path of the root folder) or the absolute path of the file.
    /// # Example
    /// ```
    /// use filelib::FileManager;
    /// FileManager::create_file("file.txt").unwrap();
    /// FileManager::create_file("C:\\user\\documents\\file.txt").unwrap();
    /// ```
    /// # Errors
    /// If the file cannot be created, an error is returned.

    pub fn create_file(path: &str) -> Result<File, Error> {
        let mut root = PathBuf::from(path);
        if !Utils::is_absolute(root.to_str().unwrap()) {
            root = Utils::user_route();
            root.push(path)
        }
        Ok(File::create(root)?)
    }

    /// Writes a string to a file.
    /// # Arguments
    /// * `path` - The name of the file.(This will get the path of the root folder) or the absolute path of the file.
    /// * `content` - The content to write to the file.
    /// # Example
    /// ```
    /// use filelib::FileManager;
    /// FileManager::write_to_file("file.txt", "Hello World!").unwrap();
    /// FileManager::write_to_file("C:\\user\\documents\\file.txt", "Hello World!").unwrap();
    /// ```
    /// # Errors
    /// If the file cannot be written, an error is returned.

    pub fn write_to_file(path: &str, data: &str) -> Result<(), Error> {
        if !FileManager::file_exists(path) {
            let mut file = FileManager::create_file(path)?;
            file.write_all(data.as_bytes())?;
            file.write_all("\n".as_ref())?;
            Ok(())
        } else {
            let mut root = PathBuf::from(path);
            if !Utils::is_absolute(root.to_str().unwrap()) {
                root = Utils::user_route();
                root.push(path)
            }

            let mut file = OpenOptions::new().append(true).open(root)?;
            file.write_all(data.as_bytes())?;
            file.write_all("\n".as_ref())?;
            Ok(())
        }
    }

    /// Cleans a file.
    /// # Arguments
    /// * `path` - The name of the file.(This will get the path of the root folder) or the absolute path of the file.
    /// # Example
    /// ```
    /// use filelib::FileManager;
    /// FileManager::clean_file("file.txt").unwrap();
    /// FileManager::clean_file("C:\\user\\documents\\file.txt").unwrap();
    /// ```
    /// # Errors
    /// If the file cannot be cleaned, an error is returned.

    pub fn clean_file(path: &str) -> Result<(), Error> {
        let mut root = PathBuf::from(path);
        if !Utils::is_absolute(root.to_str().unwrap()) {
            root = Utils::user_route();
            root.push(path)
        }
        FileManager::delete_file(root.to_str().unwrap())?;
        FileManager::create_file(path)?;

        Ok(())
    }

    /// Reads a file and returns its content.
    /// # Arguments
    /// * `path` - The name of the file.(This will get the path of the root folder) or the absolute path of the file.
    /// # Example
    /// ```
    /// use filelib::FileManager;
    /// let cont1 = FileManager::read_file("file.txt").unwrap();
    /// let cont2 = FileManager::read_file("C:\\user\\documents\\file.txt").unwrap();
    /// ```

    pub fn read_file(path: &str) -> std::io::Result<String> {
        let mut root = PathBuf::from(path);
        if !Utils::is_absolute(root.to_str().unwrap()) {
            root = Utils::user_route();
            root.push(path)
        }
        let mut file = File::open(root)?;
        let mut contents = String::new();

        file.read_to_string(&mut contents)?;
        Ok(contents)
    }

    /// Checks if a file exists.
    /// # Arguments
    /// * `path` - The path of the file.
    /// # Example
    /// ```
    /// use filelib::{FileManager};
    /// FileManager::file_exists("file.txt").unwrap();
    /// FileManager::file_exists("C:\\user\\documents\\file.txt").unwrap();
    /// ```
    /// # Errors
    /// If the file cannot be found, an error is returned.

    pub fn file_exists(path: &str) -> bool {
        let mut root = PathBuf::from(path);
        root = Utils::get_file_name(root, path);
        root.exists()
    }

    /// Deletes a file.
    /// # Arguments
    /// * `path` - The path of the file.
    /// # Example
    /// ```
    /// use filelib::{FileManager};
    /// FileManager::delete_file("file.txt").unwrap();
    /// FileManager::delete_file("C:\\user\\documents\\file.txt").unwrap();
    /// ```
    /// # Errors
    /// If the file cannot be deleted, an error is returned.

    pub fn delete_file(path: &str) -> Result<bool, Error> {
        let root = PathBuf::from(path);
        let root = Utils::get_file_name(root, path);//.to_str().unwrap().to_string()
        std::fs::remove_file(root)?;
        Ok(true)
    }
    /// Renames a file
    /// # Arguments
    /// * `path` - The path of the file.
    /// * `new_name` - The new name of the file.
    /// # Example
    /// ```
    /// use filelib::{FileManager};
    /// FileManager::rename_file("file.txt", "new_file.txt").unwrap();
    /// FileManager::rename_file("C:\\user\\documents\\file.txt", "new_file.txt").unwrap();
    /// ```
    /// # Errors
    /// If the file cannot be renamed, an error is returned.

    pub fn rename_file(path: &str, new_name: &str) -> Result<(), Error> {
        let mut root = PathBuf::from(path);
        if !Utils::is_absolute(root.to_str().unwrap()) {
            root = Utils::user_route();
            root.push(path);
            std::fs::rename(root, new_name)?;
        } else {
            std::fs::rename(root, new_name)?;
        }
        Ok(())
    }

    /// Changes a file extension
    /// # Arguments
    /// * `path` - The path of the file.
    /// * `new_extension` - The new extension of the file.
    /// # Example
    /// ```
    /// use filelib::{FileManager};
    /// FileManager::change_extension("file.txt", "rs").unwrap();
    /// FileManager::change_extension("C:\\user\\documents\\file.txt", "rs").unwrap();
    /// ```
    /// # Errors
    /// If the file cannot be renamed, an error is returned.

    pub fn change_extension(path: &str, new_extension: &str) -> Result<bool, Error> {
        let mut root = PathBuf::from(path);
        let mut has_changed = false;
        if !Utils::is_absolute(root.to_str().unwrap()) {
            root = Utils::user_route();
            root.push(path);
            has_changed = root.set_extension(new_extension)
        } else {
            has_changed = root.set_extension(new_extension)
        }

        if has_changed {
            let content = FileManager::read_file(path)?;
            FileManager::delete_file(path)?;
            FileManager::write_to_file(root.to_str().unwrap(), &content)?;
        }

        Ok(true)
    }

    /// Copies a file
    /// # Arguments
    /// * `path` - The path of the file.
    /// * `another_path` - The path of the new file.
    /// # Example
    /// ```
    /// use filelib::{FileManager};
    /// FileManager::copy_file("file.txt", "C:\\user\\documents\\file.txt").unwrap();
    /// FileManager::copy_file("C:\\user\\documents\\file.txt", "C:\\user\\documents\\file.txt").unwrap();
    /// ```
    /// # Errors
    /// If the file cannot be found, an error is returned.
    ///
    /// If the paths have the same value , an error is returned.


    pub fn copy_file(path: &str, another_path: &str) -> Result<bool, Error> {
        let mut root = PathBuf::from(path);
        let mut another_root = PathBuf::from(another_path);
        match root == another_root {
            true => {
                return Err(Error::new(ErrorKind::Other, "The paths have the same value."));
            }
            false => {
                if !Utils::is_absolute(another_root.to_str().unwrap()) {
                    another_root = Utils::user_route();
                }
                another_root.push(another_path);
                std::fs::copy(root, another_root)?;
                Ok(true)
            }
        }
    }

    /// Creates a directory
    /// # Arguments
    /// * `path` - The path of the directory.
    /// # Example
    /// ```
    /// use filelib::{FileManager};
    /// FileManager::create_dir("C:\\user\\documents\\some_dir").unwrap();
    /// FileManager::create_dir("C:\\user\\documents\\some_dir\\some_dir2").unwrap();
    /// FileManager::create_dir("some_dir3").unwrap();
    /// ```
    /// # Errors
    /// If the directory cannot be created, an error is returned.


    pub fn create_dir(path: &str) -> Result<bool, Error> {
        let mut root = PathBuf::from(path);
        if !Utils::is_absolute(root.to_str().unwrap()) {
            root = Utils::user_route();
            root.push(path);
        }

        create_dir(root)?;

        Ok(true)
    }

    /// Deletes a directory
    /// # Arguments
    /// * `path` - The path of the directory.
    /// # Example
    /// ```
    /// use filelib::{FileManager};
    /// FileManager::delete_dir("C:\\user\\documents\\some_dir").unwrap();
    /// FileManager::delete_dir("C:\\user\\documents\\some_dir\\some_dir2").unwrap();
    /// FileManager::delete_dir("some_dir3").unwrap();
    /// ```
    /// # Errors
    /// If the directory cannot be deleted, an error is returned.


    pub fn delete_dir(path: &str) -> Result<bool, Error> {
        let mut root = PathBuf::from(path);
        if !Utils::is_absolute(root.to_str().unwrap()) {
            root = Utils::user_route();
            root.push(path);
        }

        std::fs::remove_dir(root)?;
        Ok(true)
    }

    /// Renames a directory
    /// # Arguments
    /// * `path` - The path of the directory.
    /// * `new_name` - The new name of the directory.
    /// # Example
    /// ```
    /// use filelib::{FileManager};
    /// FileManager::rename_dir("C:\\user\\documents\\some_dir", "new_dir").unwrap();
    /// FileManager::rename_dir("C:\\user\\documents\\some_dir\\some_dir2", "new_dir2").unwrap();
    /// FileManager::rename_dir("some_dir3", "new_dir3").unwrap();
    /// ```
    /// # Errors
    /// If the directory cannot be renamed, an error is returned.


    pub fn rename_dir(path: &str, new_name: &str) -> Result<bool, Error> {
        let mut root = PathBuf::from(path);
        let mut new_name = PathBuf::from(new_name);
        if !Utils::is_absolute(root.to_str().unwrap()) {
            root = Utils::user_route();
            root.push(path);
        }
        std::fs::rename(root, new_name)?;
        Ok(true)
    }

    /// Copies a directory
    /// # Arguments
    /// * `path` - The path of the directory.
    /// * `another_path` - The new path of the directory.
    /// # Example
    /// ```
    /// use filelib::{FileManager};
    /// FileManager::copy_dir("C:\\user\\documents\\some_dir", "C:\\user\\documents\\some_dir2").unwrap();
    /// FileManager::copy_dir("C:\\user\\documents\\some_dir\\some_dir2", "C:\\user\\documents\\some_dir2\\some_dir3").unwrap();
    /// FileManager::copy_dir("some_dir3", "some_dir4").unwrap();
    /// ```
    /// # Errors
    /// If the directory is not found, an error is returned.
    ///
    /// If the paths have the same value , an error is returned.


    pub fn copy_dir(path: &str, another_path: &str) -> Result<bool, Error> {
        let mut root = PathBuf::from(path);
        let mut another_root = PathBuf::from(another_path);
        let mut new_path: PathBuf = Default::default();

        match root == another_root {
            true => {
                return Err(Error::new(ErrorKind::Other, "The paths have the same value."));
            }
            false => {
                if !Utils::is_absolute(another_root.to_str().unwrap()) {
                    another_root = Utils::user_route();
                }
                another_root.push(another_path);

                new_path = PathBuf::from(another_root.to_str().unwrap());
                create_dir(new_path.clone())?;

                for file in read_dir(root).unwrap() {
                    let file = file.unwrap();
                    let file_name = file.file_name().into_string().unwrap();

                    let file_path = file.path();
                    let another_path = new_path.join(file_name);

                    if file_path.is_dir() {
                        FileManager::copy_dir(file_path.to_str().unwrap(), another_path.to_str().unwrap())?;
                    } else {
                        FileManager::copy_file(file_path.to_str().unwrap(), another_path.to_str().unwrap())?;
                    }
                }

                Ok(true)
            }
        }
    }
}

/// **These are some utilities**.
pub struct Utils;

impl Utils {
    /// Checks if the specified path is an absolute path.
    /// # Arguments
    /// * `path` - The path to check.
    /// # Example
    /// ```
    /// use filelib::Utils;
    /// let is_absolute = Utils::is_absolute("C:\\Users\\user\\Desktop\\file.txt").unwrap();
    /// assert_eq!(is_absolute, true)
    pub fn is_absolute(path: &str) -> bool {
        PathBuf::from(path).is_absolute()
    }

    /// Returns the root directory of the project.
    /// # Example
    /// ```
    /// use filelib::Utils;
    /// let root = Utils::get_root();
    /// ```

    pub fn get_route() -> String {
        Utils::user_route().to_str().unwrap().to_string()
    }

    fn user_route() -> PathBuf {
        let bin = env::current_exe().expect("exe path");

        let mut target_dir = PathBuf::from(bin.parent().expect("bin parent"));
        while target_dir.file_name() != Some(OsStr::new("target")) {
            target_dir.pop();
        }
        target_dir.pop();
        let mut new_path = String::new();

        let mut first: char = ' ';

        for c in target_dir.display().to_string().chars() {
            if c.is_alphabetic() {
                first = c;
                break;
            }
        }
        new_path.push(first);
        new_path.push_str(target_dir.display().to_string().split(first).collect::<Vec<&str>>()[1].to_string().as_str());
        PathBuf::from(new_path)
    }

    /// Checks if the specified path is a file.
    /// # Arguments
    /// * `path` - The path to check.
    /// # Example
    /// ```
    /// use filelib::Utils;
    /// let is_file = Utils::is_file("file.txt").unwrap();
    /// assert_eq!(is_file, true)
    pub fn is_file(path: &str) -> bool {
        PathBuf::from(path).is_file()
    }

    fn get_file_name(mut root: PathBuf, path: &str) -> PathBuf {
        if !Utils::is_absolute(root.to_str().unwrap()) {
            root = Utils::user_route();
            root.push(path)
        } else {
            root.push(path)
        }
        root
    }

    /// Returns the size of a file in bytes.
    /// # Arguments
    /// * `path` - The path of the file.
    /// # Example
    /// ```
    /// use filelib::Utils;
    /// let size = Utils::get_file_size("file.txt").unwrap();
    /// assert_eq!(size, 1405)
    /// ```
    /// # Errors
    /// If the file cannot be found, an error is returned.


    pub fn get_file_size(path: &str) -> Result<u64, Error> {
        let mut root = PathBuf::from(path);
        if !Utils::is_absolute(root.to_str().unwrap()) {
            root = Utils::user_route();
            root.push(path)
        }
        let metadata = std::fs::metadata(root)?;
        Ok(metadata.len())
    }

    /// Returns the size of a directory in bytes.
    /// # Arguments
    /// * `path` - The path of the directory.
    /// # Example
    /// ```
    /// use filelib::Utils;
    /// let size = Utils::get_dir_size("C:\\user\\documents\\some_dir").unwrap();
    /// assert_eq!(size, 1454)
    /// ```
    /// # Errors
    /// If the directory cannot be found, an error is returned.

    pub fn get_dir_size(path: &str) -> Result<u64, Error> {
        let mut root = PathBuf::from(path);
        if !Utils::is_absolute(root.to_str().unwrap()) {
            root = Utils::user_route();
            root.push(path)
        }
        let mut size = 0;
        for entry in read_dir(root)? {
            let entry = entry?;
            let path = entry.path();

            if path.is_dir() {
                size += Utils::get_dir_size(path.to_str().unwrap())?;
            } else {
                size += Utils::get_file_size(path.to_str().unwrap())?;
            }
        }
        Ok(size)
    }
}

/// **This is a simple file sender**.
pub struct FileSender;


impl FileSender {
    /// Sends a file to the specified ip address.
    /// # Arguments
    /// * `path` - The path of the file.
    /// * `address` - The address to send the file to.
    /// # Example
    /// ```
    /// use filelib::FileSender;
    /// FileSender::send_file("file.txt", "192.168.1.1:8080").unwrap();
    /// ```
    /// # Errors
    /// If the file cannot be found, an error is returned.
    /// If the address is invalid, an error is returned.

    pub fn send_file(path: &str, ip: &str) -> Result<bool, Error> {
        let mut root = PathBuf::from(path);
        if !Utils::is_absolute(root.to_str().unwrap()) {
            root = Utils::user_route();
            root.push(path)
        }
        let mut file = File::open(root)?;
        let mut buffer = Vec::new();
        file.read_to_end(&mut buffer)?;

        let mut stream = TcpStream::connect(ip)?;
        stream.write(&buffer)?;

        Ok(true)
    }
    /// Waits for a file on the specified ip address.
    /// # Arguments
    /// * `path` - The path of the directory.
    /// * `address` - The address to send the directory to.
    /// # Example
    /// ```
    /// use filelib::FileSender;
    /// FileSender::receive_file("C:\\user\\documents\\some_dir", "192.168.1.1:8080").unwrap();
    /// ```
    /// # Errors
    /// If the directory cannot be found, an error is returned.
    /// If the address is invalid, an error is returned.


    pub fn receive_file(path: &str, ip: &str) -> Result<bool, Error> {
        let mut root = PathBuf::from(path);
        if !Utils::is_absolute(root.to_str().unwrap()) {
            root = Utils::user_route();
            root.push(path)
        }

        match TcpListener::bind(ip)?.accept()?
        {
            (mut stream, _) => {
                let mut buffer = Vec::new();
                stream.read_to_end(&mut buffer)?;

                let mut file = File::create(root)?;
                file.write(&buffer)?;
                Ok(true)
            }
        }
    }
}