#include <iostream>       // 输入输出
#include <fstream>        // 文件操作
#include <string>         // 字符串操作
#include <filesystem>     // 文件操作
#include <boost/asio.hpp> // socket通信

tcp::resolver resolver = tcp::resolver(context);           // 解析器
tcp::endpoint ep = *resolver.resolve("127.0.0.1", "5555"); // 解析域名
tcp::resolver resolver(io);                                // 解析器
tcp::resolver::query q("www.baidu.com", "https");          // 查询
tcp::resolver::iterator eq2 = resolver.resolve(q);         // 迭代器
tcp::endpoint ep = *resolver.resolve("127.0.0.1", "5555"); // 解析域名
tcp::resolver resolver(io);                                // 解析器
tcp::resolver::query q("www.baidu.com", "https");          // 查询
tcp::resolver::iterator eq2 = resolver.resolve(q);         // 迭代器
sock.send(...); // 发送数据
sock.write_some(boost::asio::buffer("hello world", sizeof("hello world")));
sock.async_send(...); // 异步
io_context.run();
是一个成员函数，它的作用是启动异步操作的处理循环
sock.shutdown(tcp::socket::shutdown_both); // 关闭连接

// send.cpp
#define PORT 5555
#define BUF_SIZE 1024
#define Error -1
using namespace std;
using boost::asio::ip::tcp;

int send_file(tcp::socket &sock, std::string filename)
{
    std::ifstream file(filename, std::ios::binary);
    if (!file)
        return Error;
    char buffer[BUF_SIZE]; // 分配内存
    while (file)
    {
        file.read(buffer, BUF_SIZE); // 读取文件
        if (file.gcount() < BUF_SIZE)
        {
            sock.send(boost::asio::buffer(buffer, file.gcount()));
            return 0;
        }
        sock.send(boost::asio::buffer(buffer, BUF_SIZE));
    }
    return 0;
}

int Parameter_parsing(int argc, char **argv, string &FilenameOrMsg, int &Is_File, boost::asio::ip::address &ip)
{
    if (argc != 3)
        return Error;
    else
    {
        boost::asio::ip::address _ip;
        boost::system::error_code ec;
        _ip = boost::asio::ip::address::from_string(argv[1], ec);
        if (ec)
            return Error;
        ip = _ip;
        FilenameOrMsg = string(argv[2]);
        if (filesystem::exists(FilenameOrMsg) && filesystem::is_regular_file(FilenameOrMsg))
            Is_File = 1;
        return 1;
    }
}

int main(int argc, char **argv)
{
    try
    {

        boost::asio::io_context io_context;
        tcp::socket sock(io_context);
        boost::asio::ip::address TargetIp;
        string FilenameOrMsg;
        string &FileName = FilenameOrMsg;
        string &Msg = FilenameOrMsg;
        int Is_File = 0;
        if (Parameter_parsing(argc, argv, FilenameOrMsg, Is_File, TargetIp) == Error)
        {
            // 输出提示
            cout << "Usage: ./send <ip> <filename or message>" << endl;
            return -1;
        }
        sock.connect(tcp::endpoint(TargetIp, PORT));
        if (Is_File)
        {
            string _FileSize = std::to_string(std::filesystem::file_size(FileName));
            string _FileName = filesystem::path(FilenameOrMsg).filename().string();
            string _info = _FileName + '|' + _FileSize;
            size_t _info_Size = _info.size();
            char _info_Size_buffer[sizeof(size_t)];
            memcpy(_info_Size_buffer, &_info_Size, sizeof(size_t));
            char Mode[10] = "FILE MODE";
            sock.send(boost::asio::buffer(Mode, 10));
            sock.send(boost::asio::buffer(_info_Size_buffer, sizeof(size_t)));
            sock.send(boost::asio::buffer(_info, _info_Size));
        }
        else
        {
            char Mode[10] = "MSGS MODE";
            sock.send(boost::asio::buffer(Mode, 10));
            size_t _Msg_Size = Msg.size();
            char _Msg_Size_buffer[sizeof(size_t)];
            memcpy(_Msg_Size_buffer, &_Msg_Size, sizeof(size_t));
            int len = sock.send(boost::asio::buffer(_Msg_Size_buffer, sizeof(size_t)));
        }
        char confirm_send = 0;
        sock.read_some(boost::asio::buffer(&confirm_send, sizeof(char)));
        if (Is_File)
            if (confirm_send || sock.is_open())
                send_file(sock, FileName);
            else
                cout << "对方已拒绝接受文件!" << endl;
        else
            sock.send(boost::asio::buffer(Msg, Msg.size()));
        sock.close();
    }
    catch (const boost::system::system_error &e)
    {
        cout << "无法链接至目标主机!" << '\n';
    }
    return 0;
}

bool Confirm(string FileName, size_t FileSize)
{
    cout << "文件名: " << FileName << endl;
    cout << "文件大小: " << FileSize << endl;
    cout << "是否接收文件(Y/N): ";
    char ch;
    cin >> ch;
    if (ch == 'Y' || ch == 'y')
        return 1;
    else
        return 0;
}

int recv_file(tcp::socket &sock, std::string &file_name)
{
    std::ofstream ofs(file_name, std::ios::binary);
    char buf[BUF_SIZE];
    while (true)
    {
        int len = sock.read_some(boost::asio::buffer(buf, BUF_SIZE));
        ofs.write(buf, len);
        if (len < BUF_SIZE)
            break;
    }
    return OK;
};

int main(void)
{
    cout << "开始接收数据!" << endl;
    boost::asio::io_context context;
    tcp::socket sock(context);
    tcp::endpoint ep(boost::asio::ip::address::from_string("0.0.0.0"), PORT);
    tcp::acceptor acceptor(context, ep);
    acceptor.accept(sock);
    char Mode[10] = "FILE MODE";
    string FileName;
    size_t FileSize;
    size_t InfoSize;
    sock.read_some(boost::asio::buffer(Mode, 10));
    // 将整数转换为字节流并存储到字符数组中
    char _InfoSize_buf[sizeof(size_t)];
    sock.read_some(boost::asio::buffer(_InfoSize_buf, sizeof(size_t)));
    std::memcpy(&InfoSize, _InfoSize_buf, sizeof(size_t));
    if (!strcmp("FILE MODE", Mode))
    {
        char _File_NameSzie[InfoSize + 1];
        int Index = 0;
        int len = sock.read_some(boost::asio::buffer(_File_NameSzie, InfoSize));
        _File_NameSzie[len] = '\0';
        for (auto &c : _File_NameSzie)
        {
            Index++;
            if (c == '|')
            {
                string _StrT_FileSize = string(_File_NameSzie).substr(Index, InfoSize);
                FileSize = stoi(_StrT_FileSize);
                break;
            }
            FileName = FileName + c;
        }
        if (Confirm(FileName, FileSize))
        {
            char Is_Confirm = 1;
            sock.send(boost::asio::buffer(&Is_Confirm, sizeof(char)));
            recv_file(sock, FileName);
            cout << "文件接收成功!" << endl;
        }
        else
            return 0;
    }
    else
    {
        cout << "来自 " << sock.remote_endpoint().address() << " 的消息: " << endl;
        char confirm_send = 0;
        sock.send(boost::asio::buffer(&confirm_send, sizeof(char)));
        char _Msg_buf[InfoSize + 1];
        int len = sock.read_some(boost::asio::buffer(_Msg_buf, InfoSize));
        _Msg_buf[len] = '\0';
        cout << _Msg_buf << endl;
    }
    sock.close();
    return 0;
}

#include <iostream>   // 输入输出流
#include <filesystem> // 文件系统库
#include <string>     // 字符串类
#include <fstream>    // 文件输出流

namespace fs = std::filesystem;

int main(int argc, char const *argv[])
{
    // 参数
    std::string parameters[argc];
    // 日志文件
    std::string LogFilePath = fs::temp_directory_path().append("log.txt").generic_string();
    std::ofstream Logs(LogFilePath);
    int OpenLog = 0;
    // 重命名参数
    std::string BaseName = "";
    std::string TargetExt = "";
    // 输出参数
    fs::path OutDir = fs::current_path();
    // 统计
    int FileCount = -1;

    // 输出帮助信息
    auto OutHelpInfo = []()
    {
        std::cout << "批量重命名文件" << std::endl;
        std::cout << "参数说明:" << std::endl;
        std::cout << "  -h, --Help      显示帮助信息" << std::endl;
        std::cout << "  -b, --Base      设置重命名的基准文件名" << std::endl;
        std::cout << "  -l, --Log       开启日志保存重命名记录" << std::endl;
        std::cout << "  -c, --FileCount 设置重命名文件的个数" << std::endl;
        std::cout << "  -o, --OutDir    设置重命名文件的输出目录" << std::endl;
        std::cout << "  -e, --Ext       指定需要重命名文件的后缀名(含分隔符\".\")" << std::endl;
    };

    auto UpperStr = [](std::string str)
    {
        std::string result;
        for (auto &c : str)
            result += toupper(c);
        return result;
    };
    if (argc < 3)
    {
        OutHelpInfo();
        return -1;
    }
    // 参数解析
    for (int i = 0; i < argc; i++)
    {
        parameters[i] = argv[i];
        if (parameters[i] == "-h" || parameters[i] == "--help")
        {
            OutHelpInfo();
            return 0;
        }
        else if (parameters[i] == "-b" || parameters[i] == "--Base")
        {
            if (i + 1 < argc)
                BaseName = argv[i + 1];
            else
            {
                std::cout << "错误: 参数 -b 缺少参数" << std::endl;
                OutHelpInfo();
                return -1;
            }
        }
        else if (parameters[i] == "-l" || parameters[i] == "--Log")
            OpenLog = 1;
        else if (parameters[i] == "-c" || parameters[i] == "--FileCount")
        {
            if (i + 1 < argc)
                FileCount = std::stoi(argv[i + 1]);
            else
            {
                std::cout << "错误: 参数 -c 缺少参数" << std::endl;
                OutHelpInfo();
                return -1;
            }
        }
        else if (parameters[i] == "-o" || parameters[i] == "--OutDir")
        {
            if (i + 1 < argc)
                OutDir = fs::absolute(argv[i + 1]);
            else
            {
                std::cout << "错误: 参数 -o 缺少参数" << std::endl;
                OutHelpInfo();
                return -1;
            }
        }
        else if (parameters[i] == "-e" || parameters[i] == "--Ext")
        {
            if (i + 1 < argc)
                TargetExt = UpperStr(std::string(argv[i + 1]));
            else
            {
                std::cout << "错误: 参数 -e 缺少参数" << std::endl;
                OutHelpInfo();
                return -1;
            }
        }
    }

    if (!OpenLog)
        Logs.close();

    // 输出参数
    std::cout << "基准文件名: " << BaseName << std::endl;
    if (OpenLog)
        std::cout << "已开启开启日志" << std::endl;
    if (FileCount != -1)
        std::cout << "重命名文件个数: " << FileCount << std::endl;
    if (TargetExt != "")
        std::cout << "目标文件后缀: " << TargetExt << std::endl;
    std::cout << "输出目录: " << OutDir.generic_string() << std::endl;
    std::cout << "是否开始批量重命名文件?(Y/N): ";

    // 确认
    char c;
    std::cin >> c;
    if (c != 'Y' && c != 'y')
        return 0;

    fs::path currentPath = fs::current_path();
    int count = 1, ID = 0;
    // 遍历
    for (auto &file : fs::directory_iterator(currentPath))
    {
        // 达到指定个数退出
        if (FileCount != -1 && count > FileCount)
            break;
        // 跳过文件夹
        if (file.is_directory())
            continue;
        // 确认指定后缀
        std::string Extension = UpperStr(file.path().extension().generic_string());
        if (!TargetExt.empty() && Extension != TargetExt)
            continue;
        // 获取目标文件名
        fs::path ToName = OutDir / (BaseName + std::to_string(ID++) + Extension);
        // 跳过已重命名文件
        if (fs::exists(ToName))
        {
            if (OpenLog)
            {
                std::cout << "文件 \"" << ToName << "\" 已存在, 跳过。" << std::endl;
                ID = ID + 1;
            }
            continue;
        }
        // 跳过软链接
        if (fs::is_symlink(file))
        {
            if (OpenLog)
                std::cout << "文件 \"" << file.path() << "\" 是软链接, 跳过。" << std::endl;
            continue;
        }
        // 输出日志
        if (OpenLog)
        {
            Logs << file.path() << " => " << ToName << std::endl;
            std::cout << "Renaming: " << file.path() << " => " << ToName << std::endl;
        }
        // 重命名
        fs::rename(file.path(), ToName);
        count++;
    }
    // 保存日志
    if (OpenLog)
    {
        Logs.close();
        fs::rename(LogFilePath, currentPath / "log.txt");
        std::cout << "重命名完成,日志保存在: " << (currentPath / "log.txt").generic_string() << std::endl;
    }
    return 0;
}