/*
 * .============.
 * // M A K E / \
 * // C++ DEV / \
 * // E A S Y / \/ \
 * ++ ----------. \/\ .
 * \\ \ \ /\ /
 * \\ \ \ /
 * \\ \ \ /
 * -============'
 *
 * Copyright (c) 2018 Hevake and contributors, all rights reserved.
 *
 * This file is part of cpp-tbox (https://github.com/cpp-main/cpp-tbox)
 * Use of this source code is governed by MIT license that can be found
 * in the LICENSE file in the root of the source tree. All contributing
 * project authors may be found in the CONTRIBUTORS.md file in the root
 * of the source tree.
 */
#include "fs.h"

#include <sys/stat.h>
#include <exception>
#include <fstream>
#include <errno.h>
#include <cstring>
#include <dirent.h>

#include <unistd.h>
#include <fcntl.h>

#include <tbox/base/log.h>
#include <tbox/base/scope_exit.hpp>

namespace tbox {
namespace util {
namespace fs {

using std::ifstream;
using std::ofstream;
using std::exception;

FileType GetFileType(const std::string &file_path, bool refer_to_real_file)
{
 auto func = refer_to_real_file ? (::stat) : (::lstat);

 struct stat st;
 if (func(file_path.c_str(), &st) == 0) {
 if (S_ISDIR(st.st_mode)) return FileType::kDirectory;
 if (S_ISREG(st.st_mode)) return FileType::kRegular;
 if (S_ISCHR(st.st_mode)) return FileType::kCharacterDevice;
 if (S_ISBLK(st.st_mode)) return FileType::kBlockDevice;
 if (S_ISLNK(st.st_mode)) return FileType::kSymbolLink;
 if (S_ISSOCK(st.st_mode)) return FileType::kSocket;
 if (S_ISFIFO(st.st_mode)) return FileType::kNamedPipe;
 }

 return FileType::kNone;
}

bool IsFileExist(const std::string &filename)
{
 int ret = ::access(filename.c_str(), F_OK);
 return ret == 0;
}

bool ReadStringFromTextFile(const std::string &filename, std::string &content)
{
 try {
 ifstream f(filename);
 if (f) {
 content = std::string((std::istreambuf_iterator<char>(f)),
 std::istreambuf_iterator<char>());
 return true;
 } else {
 LogNotice("open failed, %s", filename.c_str());
 }
 } catch (const exception &e) {
 LogNotice("catch exception: %s", e.what());
 }
 return false;
}

bool ReadEachLineFromTextFile(const std::string &filename, const std::function<void(const std::string&)> &line_handle_func)
{
 try {
 ifstream f(filename);
 if (f) {
 std::string text;
 while (std::getline(f, text)) {
 while (!text.empty() && (text.back() == '\r' || text.back() == '\n'))
 text.pop_back();
 line_handle_func(text);
 }
 return true;
 } else {
 LogNotice("open failed, %s", filename.c_str());
 }
 } catch (const exception &e) {
 LogNotice("catch exception: %s", e.what());
 }
 return false;
}

bool ReadAllLinesFromTextFile(const std::string &filename, std::vector<std::string> &text_vec)
{
 try {
 ifstream f(filename);
 if (f) {
 std::string text;
 while (std::getline(f, text)) {
 while (!text.empty() && (text.back() == '\r' || text.back() == '\n'))
 text.pop_back();
 text_vec.emplace_back(std::move(text));
 }
 return true;
 } else {
 LogNotice("open failed, %s", filename.c_str());
 }
 } catch (const exception &e) {
 LogNotice("catch exception: %s", e.what());
 }
 return false;
}

bool ReadFirstLineFromTextFile(const std::string &filename, std::string &text)
{
 try {
 ifstream f(filename);
 if (f) {
 std::getline(f, text);
 while (!text.empty() && (text.back() == '\r' || text.back() == '\n'))
 text.pop_back();
 return true;
 } else {
 LogNotice("open failed, %s", filename.c_str());
 }
 } catch (const exception &e) {
 LogNotice("catch exception: %s", e.what());
 }
 return false;
}

bool WriteStringToTextFile(const std::string &filename, const std::string &content, bool sync_now)
{
 return WriteFile(filename.c_str(), content.data(), content.size(), sync_now);
}

bool AppendStringToTextFile(const std::string &filename, const std::string &content, bool sync_now)
{
 return AppendFile(filename.c_str(), content.data(), content.size(), sync_now);
}

bool ReadBinaryFromFile(const std::string &filename, std::string &content)
{
 return ReadStringFromTextFile(filename, content);
}

bool WriteBinaryToFile(const std::string &filename, const std::string &content, bool sync_now)
{
 return WriteFile(filename.c_str(), content.data(), content.size(), sync_now);
}

bool WriteFile(const char *filename, const void *data_ptr, size_t data_size, bool sync_now)
{
 //! 这里采用原始系统接口,是为了解决Linux下往文件写数据不会立即同步到外存的问题。
 //! 这个问题会在导致写入数据之后,系统宕机或设备断电,重启后文件中数据丢失的故障。
 //! 为保证数据一定写入到外存,需要在写入数据之后,调用一次fsync(fd)。
 //! 然而,标准C++的ofstream无法提供文件对象的fd。所以不得不使用原始的文件操作。

 int flag = O_CREAT | O_WRONLY | O_TRUNC;
 if (sync_now)
 flag |= O_SYNC; //! 加了这个参数后,相当于每次write()操作都执行了一次fsync(fd)

 int fd = ::open(filename, flag, S_IRUSR | S_IWUSR);
 if (fd >= 0) {
 SetScopeExitAction([fd] { close(fd); }); //! 确保退出时一定会close(fd)

 auto wsize = ::write(fd, data_ptr, data_size);
 if (wsize == static_cast<ssize_t>(data_size))
 return true;

 if (wsize == -1)
 LogNotice("write errno:%d, %s", errno, strerror(errno));
 else
 LogNotice("wsize:%d, size:%d", wsize, data_size);

 } else
 LogNotice("open %s failed, %d, %s", filename, errno, strerror(errno));

 return false;
}

bool AppendFile(const char *filename, const void *data_ptr, size_t data_size, bool sync_now)
{
 int flag = O_CREAT | O_WRONLY | O_APPEND;
 if (sync_now)
 flag |= O_SYNC;

 int fd = ::open(filename, flag, S_IRUSR | S_IWUSR);
 if (fd >= 0) {
 SetScopeExitAction([fd] { close(fd); }); //! 确保退出时一定会close(fd)

 auto wsize = ::write(fd, data_ptr, data_size);
 if (wsize == static_cast<ssize_t>(data_size))
 return true;

 if (wsize == -1)
 LogNotice("write errno:%d, %s", errno, strerror(errno));
 else
 LogNotice("wsize:%d, size:%d", wsize, data_size);

 } else
 LogNotice("open %s failed, %d, %s", filename, errno, strerror(errno));

 return false;
}

bool RemoveFile(const std::string &filename, bool allow_log_print)
{
 int ret = ::unlink(filename.c_str());
 if (ret == 0)
 return true;

 if (errno != ENOENT && allow_log_print)
 LogNotice("errno:%d (%s)", errno, strerror(errno));

 return false;
}

bool MakeSymbolLink(const std::string &old_path, const std::string &new_path, bool allow_log_print)
{
 int ret = ::symlink(old_path.c_str(), new_path.c_str());
 if (ret == 0)
 return true;

 if (allow_log_print)
 LogNotice("errno:%d (%s)", errno, strerror(errno));
 return false;
}

bool MakeLink(const std::string &old_path, const std::string &new_path, bool allow_log_print)
{
 int ret = ::link(old_path.c_str(), new_path.c_str());
 if (ret == 0)
 return true;

 if (allow_log_print)
 LogNotice("errno:%d (%s)", errno, strerror(errno));
 return false;
}

bool IsDirectoryExist(const std::string &dir)
{
 return GetFileType(dir) == FileType::kDirectory;
}

bool MakeDirectory(const std::string &origin_dir_path, bool allow_log_print)
{
 if (origin_dir_path.empty()) {
 if (allow_log_print)
 LogNotice("origin_dir_path is empty");
 return false;
 }

 if (IsDirectoryExist(origin_dir_path))
 return true;

 std::string trimmed_dir_path;
 trimmed_dir_path.reserve(origin_dir_path.size());
 for (auto c : origin_dir_path) {
 //! 消除重复的 '/',比如: "a//b"
 if (trimmed_dir_path.empty() || !(c == '/' && trimmed_dir_path.back() == '/'))
 trimmed_dir_path.push_back(c);
 }

 //! 确保trimmed_dir_path以'/'字符结尾
 if (trimmed_dir_path.back() != '/')
 trimmed_dir_path.push_back('/');

 for (size_t i = 1; i < trimmed_dir_path.size(); ++i) {
 if (trimmed_dir_path.at(i) == '/') {
 trimmed_dir_path.at(i) = '0円';
 struct stat sb;
 if (::stat(trimmed_dir_path.c_str(), &sb) != 0) {
 if (errno == ENOENT) { //! 如果trimmed_dir_path指定的inode不存在,则创建目录
 if (::mkdir(trimmed_dir_path.c_str(), 0775) != 0) {
 if (allow_log_print)
 LogNotice("mkdir(%s) fail, errno:%d, %s", trimmed_dir_path.c_str(), errno, strerror(errno));
 return false;
 }
 } else { //! 如果是其它的错误
 if (allow_log_print)
 LogNotice("stat(%s) fail, errno:%d, %s", trimmed_dir_path.c_str(), errno, strerror(errno));
 return false;
 }
 } else { //! 如果 trimmed_dir_path 指定的inode存在
 if (!S_ISDIR(sb.st_mode)) { //! 该inode并不是一个目录
 if (allow_log_print)
 LogNotice("inode %s is not directory", trimmed_dir_path.c_str());
 return false;
 }
 //! 存在,且是目录,则不做任何事件
 }
 trimmed_dir_path.at(i) = '/';
 }
 }

 return true;
}

bool RemoveDirectory(const std::string &dir, bool is_remove_file_only)
{
 DIR *dp = ::opendir(dir.c_str());
 if (dp == nullptr) {
 // 无法打开目录,直接结束
 if (errno == ENOENT) {
 LogNotice("directory %s does not exist", dir.c_str());
 } else {
 LogNotice("open directory %s fail, errno:%d, %s", dir.c_str(), errno, strerror(errno));
 }
 return false;
 }

 SetScopeExitAction([dp] { closedir(dp); });

 bool is_all_removed = true;
 struct dirent *entry = nullptr;

 while ((entry = readdir(dp)) != nullptr) {
 std::string entry_name = entry->d_name;
 if (entry_name == "." || entry_name == "..") {
 // 目录系统的 . 和 .. 内容,直接略过
 continue;
 }

 // 依次查看每一个文件或者目录的属性
 std::string full_path = dir + '/' + entry_name;
 struct stat statbuf;
 if (::stat(full_path.c_str(), &statbuf) == 0) {
 if (S_ISDIR(statbuf.st_mode)) {
 // 属性为目录,递归删除目录的内容
 if (!RemoveDirectory(full_path, is_remove_file_only)) {
 is_all_removed = false;
 }
 } else {
 // 属性为文件,直接删除文件
 if (::remove(full_path.c_str())) {
 LogNotice("removing file %s fail, errno:%d, %s", full_path.c_str(), errno, strerror(errno));
 is_all_removed = false;
 }
 }
 } else {
 // 无法获取属性,直接结束
 LogNotice("getting state of %s fail, errno:%d, %s", full_path.c_str(), errno, strerror(errno));
 is_all_removed = false;
 }
 }

 if (!is_remove_file_only) {
 // 最后删除目录
 if (::rmdir(dir.c_str())) {
 LogNotice("removing directory %s fail, errno:%d, %s", dir.c_str(), errno, strerror(errno));
 is_all_removed = false;
 }
 }

 return is_all_removed;
}

bool ListDirectory(const std::string &dir, std::vector<std::string> &names)
{
 DIR *dp = ::opendir(dir.c_str());
 if (dp == nullptr) {
 // 无法打开目录,直接结束
 if (errno == ENOENT) {
 LogNotice("directory %s does not exist", dir.c_str());
 } else {
 LogNotice("open directory %s fail, errno:%d, %s", dir.c_str(), errno, strerror(errno));
 }
 return false;
 }

 SetScopeExitAction([dp] { closedir(dp); });

 struct dirent *entry = nullptr;
 while ((entry = readdir(dp)) != nullptr) {
 std::string entry_name = entry->d_name;
 if (entry_name != "." && entry_name != "..") {
 names.emplace_back(entry_name);
 }
 }

 return true;
}

std::string Basename(const std::string &full_path)
{
 auto const pos = full_path.find_last_of('/');
 return full_path.substr(pos + 1);
}

const char* Basename(const char *full_path)
{
 const char *p_last = full_path;
 if (p_last != nullptr) {
 for (const char *p = full_path; *p; ++p) {
 if (*p == '/')
 p_last = p + 1;
 }
 }
 return p_last;
}

/**
 * 目标:
 * "a" -> "."
 * "a/" -> "a"
 * "a/b" -> "a"
 * "a/b/" -> "a/b"
 * " a/b " -> "a"
 * "" -> "."
 * "abc" -> "."
 * "/" -> "/"
 * "/a" -> "/"
 * "/a/" -> "/a"
 */
std::string Dirname(const std::string &full_path)
{
 auto start_pos = full_path.find_first_not_of("\t "); //! 去除左边的空白符
 auto end_pos = full_path.find_last_of('/');

 //! 如果全是空白符或没有找到/,则推测为当前目录
 if (start_pos == std::string::npos || end_pos == std::string::npos)
 return ".";

 //! 对以/开头的要特征处理,否则 "/a" 就会被处理成 ""
 if (start_pos == end_pos)
 return "/";

 return full_path.substr(start_pos, end_pos - start_pos);
}

/**
 * 目标:
 * "a" -> "a"
 * "a.txt" -> "a"
 * "/some/a.txt" -> "a"
 * "/some/a.b/c" -> "c"
 * "" -> ""
 */
std::string FilenameStem(const std::string &filepath)
{
 std::string::size_type start_pos = 0;

 auto last_backslash_pos = filepath.find_last_of('/');
 if (last_backslash_pos != std::string::npos)
 start_pos = last_backslash_pos + 1;

 auto last_dot_pos = filepath.find_last_of('.');
 if (last_dot_pos != std::string::npos && last_dot_pos > start_pos)
 return filepath.substr(start_pos, last_dot_pos - start_pos);
 else
 return filepath.substr(start_pos);
}

/**
 * 目标:
 * "a.b" -> "b"
 * "a" -> ""
 * "a." -> ""
 * "/w/a.b" -> "b"
 * "" -> ""
 */
std::string FilenameSuffix(const std::string &filepath)
{
 auto last_dot_pos = filepath.find_last_of('.');
 if (last_dot_pos == std::string::npos)
 return "";

 //! 防止 "a.b/c" -> "a/c" 的情况
 auto last_backslash_pos = filepath.find_last_of('/');
 if (last_backslash_pos != std::string::npos && last_backslash_pos > last_dot_pos)
 return "";

 return filepath.substr(last_dot_pos + 1);
}

bool Rename(const std::string &old_name, const std::string &new_name)
{
 int ret = ::rename(old_name.c_str(), new_name.c_str());
 if (ret == 0)
 return true;

 LogNotice("rename '%s' to '%s' fail, errno:%d (%s)",
 old_name.c_str(), new_name.c_str(), errno, strerror(errno));
 return false;
}

}
}
}