pub mod buffer;
pub mod dir;
pub mod file;
pub mod recover;
pub(crate) mod web;

pub use dir::DirectoryInfo;
pub use file::FileInfo;
use std::collections::VecDeque;

use crate::recover::RecoverError;
use std::env::current_dir;
use std::ffi::OsStr;
use std::fs;
use std::fs::{metadata, remove_dir_all, remove_file, Metadata, Permissions};
use std::io::{Error, ErrorKind, Result};
use std::path::{Path, PathBuf};

pub type RecoverResult<'a> = std::result::Result<(), RecoverError<'a>>;
pub trait FileAttr: Sized {
    fn as_path(&self) -> &Path;
    /// Returns None if the path is root directory
    fn file_name(&self) -> Option<&OsStr> {
        self.as_path().file_name()
    }
    fn metadata(&self) -> Result<Metadata> {
        metadata(self.as_path())
    }
    fn size(&self) -> u64;
    /// Return None if the path is a root directory
    fn parent(&self) -> Option<DirectoryInfo> {
        self.as_path().parent().and_then(|path| {
            Some(DirectoryInfo {
                path: path.to_path_buf(),
            })
        })
    }
    /// Rename a file or directory
    ///
    /// # Examples
    /// ```no_run
    /// use fdir::{FileAttr, FileInfo};
    /// let mut file = FileInfo::create("foo.txt").unwrap();
    /// file.rename("bar").unwrap();  // or bar.txt
    /// assert_eq!(file.file_name(), Some("bar.txt".as_ref()))
    /// ```
    ///
    fn rename<T: AsRef<OsStr>>(&mut self, name: T) -> Result<()>;
    fn permissions(&self) -> Result<Permissions> {
        self.metadata().and_then(|data| Ok(data.permissions()))
    }
    fn set_permissions(&self, perm: Permissions) -> Result<()> {
        fs::set_permissions(self.as_path(), perm)
    }
    fn read_only(&self) -> Result<bool> {
        self.metadata()
            .and_then(|data| Ok(data.permissions().readonly()))
    }
    fn set_readonly(&self, readonly: bool) -> Result<()> {
        let mut perm = self.metadata()?.permissions();
        perm.set_readonly(readonly);
        self.set_permissions(perm)
    }
    fn delete(self) -> Result<()> {
        if self.read_only()? {
            self.set_readonly(false)?;
        }
        if self.as_path().is_dir() {
            remove_dir_all(self.as_path())
        } else {
            remove_file(self.as_path())
        }
    }
    fn eq(&self, other: &Self) -> bool;
    /// Copy a file or directory to a new directory
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use fdir::{FileInfo, FileAttr};
    ///
    /// let f = FileInfo::create("foo.txt").unwrap();
    /// f.copy_to("test").unwrap();
    /// assert!(FileInfo::open("test/foo.txt").is_ok())
    /// ```
    ///
    /// # Repairable Error
    ///
    /// If the destination path already exists, return an error that can be recovered
    ///
    /// # Example
    /// ```no_run
    /// use fdir::{FileInfo, FileAttr};
    ///
    /// FileInfo::create("test/foo.txt").unwrap();
    /// let f = FileInfo::create("foo.txt").unwrap();
    /// let res = f.copy_to("test");
    /// assert!(res.is_err());
    /// let res = f.copy_to("test").or_else(|e| e.try_recover());
    /// assert!(res.is_ok())
    /// ```
    ///
    fn copy_to<P: AsRef<Path>>(&self, path: P) -> RecoverResult {
        let path = complete_file_name(path, self.as_path().file_name())?;
        self.copy_new(path)
    }
    /// Copy a file or directory to a new destination path
    ///
    /// # Examples
    /// ```no_run
    /// use fdir::{FileInfo, FileAttr};
    /// let f = FileInfo::create("foo.txt").unwrap();
    /// f.copy_new("test/bar.txt").unwrap();
    /// assert!(FileInfo::open("test/bar.txt").is_ok())
    /// ```
    ///
    /// # Repairable Error
    ///
    /// If the destination path already exists, return an error that can be recovered
    ///
    /// # Example
    /// ```no_run
    /// use fdir::{FileInfo, FileAttr};
    /// FileInfo::create("test/foo.txt").unwrap();
    /// let f = FileInfo::create("foo.txt").unwrap();
    ///
    /// let res = f.copy_new("test/foo.txt");
    /// assert!(res.is_err());
    /// let res = f.copy_new("test/foo.txt").or_else(|e| e.try_recover());
    /// assert!(res.is_ok())
    /// ```
    fn copy_new<P: AsRef<Path>>(&self, path: P) -> RecoverResult;

    /// Move a file or directory to a new directory
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use std::env::current_dir;
    /// use fdir::{FileInfo, FileAttr};
    /// let mut f = FileInfo::create("foo.txt").unwrap();
    /// f.move_to("test").unwrap();
    /// let mut current_dir = current_dir().unwrap();
    /// current_dir.push("test/foo.txt");
    /// assert_eq!(f.as_path(), current_dir.as_path());
    /// ```
    ///
    /// # Repairable Error
    ///
    /// If the destination path already exists, return an error that can be recovered
    ///
    /// # Example
    /// ```no_run
    /// use fdir::{FileInfo, FileAttr};
    /// FileInfo::create("test/foo.txt").unwrap();
    /// let mut f = FileInfo::create("foo.txt").unwrap();
    ///
    /// let res = f.move_to("test");
    /// assert!(res.is_err());
    /// let res = f.move_to("test").or_else(|e| e.try_recover());
    /// assert!(res.is_ok())
    /// ```
    ///
    fn move_to<P: AsRef<Path>>(&mut self, path: P) -> RecoverResult {
        let path = complete_file_name(path, self.as_path().file_name())?;
        self.move_new(path)
    }

    /// Move a file or directory to a new destination path
    ///
    /// # Examples
    /// ```no_run
    /// use std::env::current_dir;
    /// use fdir::{FileInfo, FileAttr};
    ///
    /// let mut f = FileInfo::create("foo.txt").unwrap();
    /// f.move_new("test/bar.txt").unwrap();
    /// let mut current_dir = current_dir().unwrap();
    /// current_dir.push("test/bar.txt");
    /// assert_eq!(f.as_path(), current_dir.as_path());
    /// ```
    ///
    /// # Repairable Error
    ///
    /// If the destination path already exists, return an error that can be recovered
    ///
    /// # Example
    /// ```no_run
    /// use fdir::{FileInfo, FileAttr};
    /// FileInfo::create("test/foo.txt").unwrap();
    /// let mut f = FileInfo::create("foo.txt").unwrap();
    ///
    /// let res = f.move_new("test/foo.txt");
    /// assert!(res.is_err());
    /// let res = f.move_new("test/foo.txt").or_else(|e| e.try_recover());
    /// assert!(res.is_ok())
    /// ```
    fn move_new<P: AsRef<Path>>(&mut self, path: P) -> RecoverResult;
}

fn complete_file_name<P: AsRef<Path>>(path: P, file_name: Option<&OsStr>) -> Result<PathBuf> {
    let mut path = fix_path(path)?;
    match file_name {
        Some(name) => {
            path.push(name);
            Ok(path)
        }
        _ => Err(Error::new(
            ErrorKind::PermissionDenied,
            format!("Cannot get the file name in {} ", path.display()),
        )),
    }
}

#[inline]
pub(crate) fn fix_path(path: impl AsRef<Path>) -> Result<PathBuf> {
    let path = path.as_ref().to_path_buf();
    if path.is_relative() {
        let mut fix_path = current_dir()?;
        match path.to_str() {
            Some(path) => match path.replace("\\", "/").as_str() {
                "" | "." | "./" => (),
                ".." | "../" => {
                    fix_path.pop();
                }
                "/" => while fix_path.pop() {},
                "~" => {
                    if let Some(home) = dirs::home_dir() {
                        fix_path = home
                    } else {
                        return Err(Error::new(
                            ErrorKind::Unsupported,
                            "Path '~' not supported!",
                        ));
                    }
                }
                _ => {
                    fix_path.push(path);
                }
            },
            _ => {
                fix_path.push(path);
            }
        }
        Ok(fix_path)
    } else {
        Ok(path)
    }
}

fn _fix_path(_path: &str, _current_dir: PathBuf) -> PathBuf {
    todo!()
}



#[inline]
pub(crate) fn is_exist(path: &Path) -> bool {
    path.try_exists().unwrap_or_default()
}
#[inline]
pub(crate) fn replace(path: &Path, base: &Path, to: &Path) -> PathBuf {
    let path_queue: VecDeque<_> = path.iter().map(|path| path).collect();
    let base_queue: VecDeque<_> = base.iter().map(|path| path).collect();
    let mut to = to.to_path_buf();
    let mut i = 0;
    while i < base_queue.len() && path_queue.get(i) == base_queue.get(i) {
        i += 1;
    }
    for j in i..path_queue.len() {
        to.push(path_queue[j])
    }
    to
}

#[inline]
pub(crate) fn is_same_root(path: &Path, to: &Path) -> bool {
    let mut path = path.to_path_buf();
    while path.pop() {
        // empty
    }
    to.starts_with(path)
}
#[inline]
fn _delete_file(file: &FileInfo) -> Result<()> {
    if file.read_only()? {
        file.set_readonly(false)?
    }
    remove_file(file.as_path())
}