use crate::{parse::AutoPath, res, Error, Result};
use std::{
  borrow::Cow,
  fs,
  io::{self, Write as _},
  path::{Path, PathBuf},
};

#[cfg(feature = "encode")]
use crate::system::encode::auto_decode;

///
#[cfg(feature = "encode")]
pub fn auto_read<'a, P>(path: P) -> Result<String>
where
  P: AsRef<Path>,
{
  let data = fs::read(&path)?;
  Ok(auto_decode(&data).unwrap_or(String::from_utf8_lossy(&data).to_string()))
}

/// 主要针对兼容中文
#[cfg(feature = "encode")]
pub fn auto_read_gpk<P>(path: P) -> Result<String>
where
  P: AsRef<Path>,
{
  auto_read(path)
}

/// 树形目录，返回完整路径的字符串数组
pub fn tree_folder2<P>(dir_path: P) -> Result<Vec<PathBuf>>
where
  P: AsRef<Path>,
{
  let mut result = Vec::new();
  if dir_path.as_ref().is_dir() {
    // 递归处理目录
    let entries = fs::read_dir(dir_path)?;
    for entry in entries {
      if let Ok(entry) = entry {
        // 获取完整路径
        let file_path = entry.path();
        // 判断是文件还是目录
        if file_path.is_dir() {
          // 如果是目录，递归调用，并将结果合并到当前结果中
          let sub_directory_files = tree_folder2(&file_path)?;
          result.extend(sub_directory_files);
        } else {
          // 如果是文件，将完整路径添加到结果中
          result.push(file_path);
        }
      }
    }
  } else {
    result.push(dir_path.as_ref().to_path_buf())
  }
  Ok(result)
}
/// 树形目录，返回完整路径的字符串数组
pub fn tree_folder<P>(dir_path: P) -> Result<Vec<String>>
where
  P: AsRef<Path>,
{
  let mut result = Vec::new();
  if dir_path.as_ref().is_dir() {
    // 递归处理目录
    let entries = fs::read_dir(dir_path)?;
    for entry in entries {
      if let Ok(entry) = entry {
        // 获取完整路径
        let file_path = entry.path();
        // 判断是文件还是目录
        if file_path.is_dir() {
          // 如果是目录，递归调用，并将结果合并到当前结果中
          let sub_directory_files = tree_folder(&file_path)?;
          result.extend(sub_directory_files);
        } else {
          // 如果是文件，将完整路径添加到结果中
          if let Some(file_name) = file_path.to_str() {
            result.push(file_name.to_string());
          }
        }
      }
    }
  } else {
    result.push(dir_path.as_ref().display().to_string())
  }
  Ok(result)
}

/// 重命名
pub fn rename_file<P, P2>(src: P, dst: P2) -> Result<()>
where
  P: AsRef<Path>,
  P2: AsRef<Path>,
{
  let src = src.as_ref();
  let dst = dst.as_ref();
  if src.exists() && src.is_file() {
    if dst.exists() && !dst.is_file() {
      Err(format!("目标已存在，并非文件格式 {}", dst.display()).into())
    } else {
      fs::rename(src, dst)?;
      if dst.exists() && dst.is_file() {
        Ok(())
      } else {
        Err(format!("源{} 目标移动失败 {}", src.display(), dst.display()).into())
      }
    }
  } else {
    Err(format!("原始缓存文件不存在 {}", src.display()).into())
  }
}
/// 自动化转换路径
pub fn convert_path(path_str: &str) -> String {
  if cfg!(target_os = "windows") {
    path_str.replace('/', "\\")
  } else {
    String::from(path_str)
  }
}

/// 复制目录
pub fn auto_copy<P: AsRef<Path>, Q: AsRef<Path>>(from: P, to: Q) -> Result<()> {
  let from_path = from.as_ref();
  let to_path = to.as_ref();

  if from_path.is_file() {
    // 如果是文件，直接复制
    fs::copy(from_path, to_path)?;
  } else if from_path.is_dir() {
    to_path.auto_create_dir()?;
    // 遍历目录中的所有条目
    for entry in fs::read_dir(from_path)? {
      let entry = entry?;
      let from_entry_path = entry.path();
      let to_entry_path = to_path.join(
        from_entry_path
          .file_name()
          .ok_or(Error::Str("无法解析文件名".into()))?,
      );
      // 递归复制每个条目
      auto_copy(from_entry_path, to_entry_path)?;
    }
  } else {
    // 如果既不是文件也不是目录，返回错误
    return Err(res::Error::Io(io::Error::new(
      io::ErrorKind::Other,
      "Path is neither a file nor a directory",
    )));
  }
  Ok(())
}

/// 写入
fn write<'a>(
  path: &PathBuf,
  bytes: Cow<'a, [u8]>,
  is_sync: bool,
  is_append: bool,
) -> crate::Result<()> {
  if !is_append && path.exists() {
    path.auto_remove_file()?;
  }
  let mut f = fs::OpenOptions::new()
    .read(true)
    .write(true)
    .create(true)
    .append(is_append)
    .open(path)?;
  f.write_all(&bytes)?;
  if is_sync {
    f.sync_data()?;
  }
  Ok(())
}
/// 写入GBK格式
#[cfg(feature = "encode")]
pub fn write_gbk<'a>(
  path: &PathBuf,
  content: &'a str,
  is_sync: bool,
  is_append: bool,
) -> crate::Result<()> {
  let (bytes, _encode, had_errors) = encoding_rs::GBK.encode(content);
  if had_errors {
    return Err("写入GBK失败".into());
  } else {
    write(path, bytes, is_sync, is_append)
  }
}
/// 写入UTF-8格式
#[cfg(feature = "encode")]
pub fn write_utf8<'a>(
  path: &PathBuf,
  content: &'a str,
  is_sync: bool,
  is_append: bool,
) -> crate::Result<()> {
  let (bytes, _encode, had_errors) = encoding_rs::UTF_8.encode(content);
  if had_errors {
    return Err("写入UTF-8失败".into());
  } else {
    write(path, bytes, is_sync, is_append)
  }
}
/// 异步写入
#[cfg(feature = "tokio")]
pub mod async_runtime {
  use std::{borrow::Cow, path::PathBuf};
  use tokio::{fs, io::AsyncWriteExt as _};

  /// 异步写入
  async fn async_write<'a>(
    path: &PathBuf,
    bytes: Cow<'a, [u8]>,
    is_sync: bool,
    is_append: bool,
  ) -> crate::Result<()> {
    if !is_append && path.exists() {
      fs::remove_file(path).await?
    }
    let mut f = fs::OpenOptions::new()
      .read(true)
      .write(true)
      .create(true)
      .append(is_append)
      .open(path)
      .await?;
    f.write_all(&bytes).await?;
    if is_sync {
      f.sync_data().await?;
    }
    Ok(())
  }
  /// 异步写入GBK格式
  #[cfg(feature = "encode")]
  pub async fn async_write_gbk<'a>(
    path: &PathBuf,
    content: &'a str,
    is_sync: bool,
    is_append: bool,
  ) -> crate::Result<()> {
    let (bytes, _encode, had_errors) = encoding_rs::GBK.encode(content);
    if had_errors {
      return Err("异步写入GBK失败".into());
    } else {
      async_write(path, bytes, is_sync, is_append).await
    }
  }
  /// 异步写入UTF-8格式
  #[cfg(feature = "encode")]
  pub async fn async_write_utf8<'a>(
    path: &PathBuf,
    content: &'a str,
    is_sync: bool,
    is_append: bool,
  ) -> crate::Result<()> {
    let (bytes, _encode, had_errors) = encoding_rs::UTF_8.encode(content);
    if had_errors {
      return Err("异步写入UTF-8失败".into());
    } else {
      async_write(path, bytes, is_sync, is_append).await
    }
  }
}