#include <unistd.h>
ssize_t read(int fd, void *buf, size_t count);   // 从 fd 读数据到内存
ssize_t write(int fd, const void *buf, size_t count);  // 从内存写数据到 fd

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

int fcntl(int fd, int cmd, ... /* arg */);

#include <iostream>
#include <unistd.h>
#include <errno.h>
#include <cstring>
#include <fcntl.h>
using namespace std;

void setNoBlock(int fd)
{
    int fl = fcntl(fd, F_GETFL);                // 获取原来文件描述符的属性
    if(fl < 0)
    {
        perror("fcntl");
        return;
    }

    fcntl(fd, F_GETFL, fl | O_NONBLOCK);        // 在原标志基础上加上非阻塞
    cout << "设置 " << fd << " 为非阻塞模式成功！" << endl;
}

int main()
{
    char buffer[1024];

    setNoBlock(0);

    while(true)
    {
        // printf("please enter: ");
        // fflush(stdout);

        ssize_t n = read(0, buffer, sizeof(buffer) - 1);
        if(n > 0)
        {
            buffer[n - 1] = '\0';
            cout << "echo: " << buffer << endl;
        }
        else if(n == 0)
        {
            cout << "read EOF/read done!" << endl;
        }
        else
        {
            cerr << "read error, n = " << n << "error code: " << errno << "error string: " << strerror(errno) << endl;
        }
    }

    return 0;
}

#include <iostream>
#include <fcntl.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
using namespace std;

int main()
{
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);  // 创建 TCP 套接字
    if (sockfd < 0)
    {
        perror("socket error");
        return -1;
    }

    // 获取当前文件状态标志
    int flags = fcntl(sockfd, F_GETFL, 0);
    if (flags < 0)
    {
        perror("fcntl F_GETFL error");
        return -1;
    }

    // 设置非阻塞模式（加上 O_NONBLOCK）
    if (fcntl(sockfd, F_SETFL, flags | O_NONBLOCK) < 0)
    {
        perror("fcntl F_SETFL error");
        return -1;
    }

    cout << "套接字已设置为非阻塞模式" << endl;

    close(sockfd);
    return 0;
}

#include <sys/select.h>
#include <sys/time.h>

int select(int nfds,
           fd_set *readfds,
           fd_set *writefds,
           fd_set *exceptfds,
           struct timeval *timeout);

typedef struct
{
	unsigned long fds_bits[__FD_SETSIZE / (8 * sizeof(long))];
} fd_set;

FD_CLR(int fd, fd_set* set);		// 把fd从集合中移除（对应 bit = 0）
FD_ISSET(int fd, fd_set* set);		// 判断fd是否在集合中就绪（bit==1 返回 true）
FD_SET(int fd, fd_set* set);		// 把fd加入集合（设置对应 bit = 1）
FD_ZERO(fd_set* set);				// 清空集合（所有 bit 置 0）

fd_set readfds;          // 定义一个fd集合
FD_ZERO(&readfds);       // 清空集合
FD_SET(sockfd, &readfds); // 把sockfd加入关注集合
FD_SET(STDIN_FILENO, &readfds); // 把标准输入加入集合

// 调用select，监听读事件
int ret = select(maxfd + 1, &readfds, NULL, NULL, &timeout);

if (FD_ISSET(sockfd, &readfds))
{
    // sockfd 可读
}
if (FD_ISSET(STDIN_FILENO, &readfds))
{
    // 标准输入可读
}

struct timeval
{
    time_t      tv_sec;   // Seconds —— 秒
    suseconds_t tv_usec;  // Microseconds —— 微秒（1秒=1,000,000微秒）
};

#include <iostream>
#include <sys/select.h>
#include <unistd.h>
using namespace std;

int main()
{
    fd_set readfds;                  // 创建fd集合
    FD_ZERO(&readfds);               // 清空集合
    FD_SET(STDIN_FILENO, &readfds);  // 把标准输入加入监控集合

    struct timeval tv;
    tv.tv_sec = 5;                   // 最多阻塞5秒
    tv.tv_usec = 0;

    cout << "等待输入中..." << endl;
    int ret = select(STDIN_FILENO + 1, &readfds, NULL, NULL, &tv);

    if (ret > 0)
    {
        if (FD_ISSET(STDIN_FILENO, &readfds))
        {
            cout << "检测到输入：" << endl;
            char buf[1024];
            read(STDIN_FILENO, buf, sizeof(buf));
            cout << "你输入了: " << buf;
        }
    }
    else if (ret == 0)
    {
        cout << "超时，没有输入" << endl;
    }
    else
    {
        perror("select 出错");
    }

    return 0;
}

#include <iostream>
#include <sys/select.h>
#include <sys/time.h>
#include "Socket.hpp"
// #include "Log.hpp"
using namespace std;

static const uint16_t defaultport = 8080;                   // 默认端口号8080
static const int fd_num_max = (sizeof(fd_set) * 8);         // 计算fd_set能容纳的最大文件描述符数量，每个bit位代表一个fd
int defaultfd = -1;                                         // 无效文件描述符，用来标识数组中空闲的位置

class SelectServer
{
public:
    SelectServer(uint16_t port = defaultport)
        : _port(port)
    {
        for(int i = 0; i < fd_num_max; i++)
        {
            fd_array[i] = defaultfd;                        // 将数组中所有位置都初始化为-1，表示空闲
            // std::cout << "fd_array[" << i << "]" << " : " << fd_array[i] << std::endl;
        }
    }

    ~SelectServer()
    {
        _listensock.Close();                                // 关闭监听socket
    }

    // 初始化服务器：创建socket、绑定端口、开始监听
    bool Init()
    {
        _listensock.Socket();                               // 创建监听socket
        _listensock.Bind(_port);                            // 绑定端口
        _listensock.Listen();                               // 开始监听

        return true;
    }

    // 打印当前在线的文件描述符列表
    void PrintFd()
    {
        cout << "在线_fd_列表： ";                          // 输出提示信息
        for (int i = 0; i < fd_num_max; i++)               // 遍历fd_array数组
        {
            if (fd_array[i] == defaultfd)                  // 如果是空闲位置，跳过
            {
                continue;
            }
            
            cout << fd_array[i] << " ";                    // 输出有效的文件描述符
        }

        cout << endl;
    }

    void Accepter()
    {
        // 连接事件已经就绪
        std::string client_ip;                              // 客户端的IP
        uint16_t client_port;                               // 客户端的端口

        int sock = _listensock.Accept(&client_ip, &client_port);    // 从监听socket获取新的连接，不会阻塞，因为select已经告诉我们有连接事件就绪
        if (sock < 0)
        {
            return;  // 如果accept失败，直接返回
        }

        log_(Info, "新连接建立成功：客户端IP：%s，客户端端口：%d，socket fd：%d", client_ip.c_str(), client_port, sock);
        cout << "Info, 新连接建立成功：客户端IP：" << client_ip << "，客户端端口：" << client_port << "，socket fd：" << sock << endl;

        // 将新连接的文件描述符存入fd_array数组中
        int pos = 1;                                       // 从数组索引1开始找空闲位置（索引0存放监听socket）
        for (; pos < fd_num_max; pos++)                    // 查找数组中空闲的位置
        {
            if (fd_array[pos] != defaultfd)                // 如果当前位置不为空（-1），继续找下一个
            {
                continue;
            }
            else                                           // 找到空闲位置，跳出循环
            {
                break;
            }
        }

        if (pos == fd_num_max)                             // 如果遍历完整个数组都没找到空闲位置
        {
            log_(Warning, "服务器已满，立即关闭%d！", sock); // 服务器已满，关闭新连接
            cout << "Warning, 服务器已满，立即关闭" << sock << "！" << endl;
            close(sock);
        }
        else                                               // 找到了空闲位置
        {
            fd_array[pos] = sock;                          // 将新连接的fd放入数组
            PrintFd();                                     // 打印当前在线的fd列表
            
            // 后续可能还有其他处理
        }
    }

    // 处理数据接收的函数
    void Recver(int fd, int pos)                            // fd是需要读取数据的文件描述符，pos是该fd在数组中的位置
    {
        // demo，接收客户端数据
        char buffer[1024];                                  // 临时缓冲区，用于存储接收的数据
        ssize_t n = read(fd, buffer, sizeof(buffer) - 1);   // 从指定fd读取数据到缓冲区，预留1字节给字符串结束符
        if (n > 0)                                          // 读取到数据
        {
            buffer[n] = 0;                                  // 手动添加字符串结束符
            cout << "收到一条消息：" << buffer << endl;      // 输出接收到的消息
        }
        else if (n == 0)                                    // 客户端断开连接（读到文件结束符）
        {
            log_(Info, "客户端退出了，关闭连接的文件描述符是%d", fd);  // 记录客户端断开日志
            close(fd);                                      // 关闭该连接的文件描述符
            fd_array[pos] = defaultfd;                      // 将数组中对应位置重置为-1，表示该位置空闲（这里本质是从select中移除该fd）
        }
        else                                                // 读取错误
        {
            log_(Warning, "接收文件错误，描述符是: %d", fd);  // 记录接收错误日志
            close(fd);                                      // 关闭该连接的文件描述符
            fd_array[pos] = defaultfd;                      // 将数组中对应位置重置为-1，表示该位置空闲（这里本质是从select中移除该fd）
        }
    }

    // 事件分发函数：根据select返回的结果，处理就绪的文件描述符
    void Dispatcher(fd_set& rfds)                           // rfds是select调用后被修改的fd_set，其中包含了就绪的fd
    {
        for (int i = 0; i < fd_num_max; i++)
        {
            int fd = fd_array[i];                           // 获取数组中第i个位置的fd
            if (fd == defaultfd)                            // 如果是无效fd（-1），跳过
            {
                continue;
            }
            
            // 检查这个fd是否在select返回的就绪fd集合中
            if(FD_ISSET(fd, &rfds))                         // FD_ISSET宏用于检查fd是否在rfds集合中
            {
                if(fd == _listensock.Fd())                  // 如果就绪的fd是监听socket
                {
                    Accepter();                             // 说明有新的连接请求，调用Accepter处理
                }
                else                                        // 如果就绪的fd不是监听socket，而是普通的数据连接socket
                {
                    Recver(fd, i);                          // 调用Recver处理数据接收
                }
            }
        }
    }

    // 服务器主循环：使用select实现IO多路复用
    void Start()
    {
        int listensock = _listensock.Fd();                  // 获取监听socket的文件描述符
        fd_array[0] = listensock;                           // 将监听socket放在数组第0个位置
        // 程序启动时，只有数组第0个位置有值，是监听socket的fd，但是，程序运行过程中，Accepter 会向数组中其他位置添加新的连接fd！

        for (;;)                                            // 无限循环，服务器持续运行
        {
            fd_set readfds;                                 // 定义一个fd_set变量，用于存储待检测的读就绪文件描述符集合
            FD_ZERO(&readfds);                              // 清空readfds集合，将所有位都设置为0
            // 每次进入循环，都要重新构建readfds集合，因为select会修改它。

            int maxfds = fd_array[0];                       // 记录当前最大的文件描述符值，用于select调用
            for (size_t i = 0; i < fd_num_max;i++)          // 第一次循环，遍历fd_array数组，准备select的参数
            {
                if (fd_array[i] == defaultfd)               // 如果数组中该位置是空闲的（-1），跳过
                {
                    continue;
                    // 这个 continue 非常有用！如果不跳过，fd_array[i] 是 -1，FD_SET(-1, &readfds) 会出错或行为未定义。
                    // 并且，如果当前只有监听socket，数组后面的位置都是-1，这个循环会遍历所有位置，
                    // 但由于 continue，只有有效的fd（比如监听socket）会被处理。
                }

                FD_SET(fd_array[i], &readfds);              // 将有效的fd添加到readfds集合中，让select监控这些fd的读就绪状态

                if(fd_array[i] > maxfds)
                {
                    maxfds = fd_array[i];                   // 更新最大fd值
                    log_(Info,"最大文件描述符更新，最大文件描述符为：%d", maxfds);
                    std::cout << "最大文件描述符更新，最大文件描述符为：" << maxfds << std::endl;
                }
            }

            struct timeval timeout = {5, 0};

            // 调用select系统调用，监控maxfds+1个文件描述符（0到maxfds），readfds是读就绪集合，nullptr表示不监控写和异常
            int n = select(maxfds + 1, &readfds, NULL, NULL, &timeout); // 最后一个参数为nullptr表示不超时，阻塞等待
            // select 现在监控的是 0 到 maxfds 范围内所有在 readfds 位图中被置位的 fd。
            // 如果只有监听socket，它只监控监听socket。如果有多个连接，它会监控监听socket 和 所有已连接的socket。

            // 根据select返回值进行处理
            switch(n)
            {
            // select超时处理
            case 0:
                cout << "time out, timeout: " << timeout.tv_sec << "." << timeout.tv_usec << endl;
                break;
            // select调用出错处理
            case -1:
                cout << "select error, errno:" << errno << endl;
                break;
            // select成功处理
            default:
                cout << "得到了一个新的连接请求！" << endl;
                Dispatcher(readfds); // 调用Dispatcher处理所有就绪的事件
                break;
            }
        }
    }


private:
    Sock _listensock;                // 监听socket对象
    uint16_t _port;                  // 服务器端口号
    int fd_array[fd_num_max];        // 文件描述符数组，用于维护当前所有有效的连接fd（包括监听fd）
    // int wfd_array[fd_num_max];    // 扩展写事件处理
};

#include <poll.h>
int poll(struct pollfd *fds, nfds_t nfds, int timeout);

struct pollfd
{
    int   fd;        // 要监控的文件描述符
    short events;    // 想监控哪些事件（输入参数）
    short revents;   // 实际发生的事件（输出参数，由内核填充）
};

#include <iostream>
#include <poll.h>
#include <sys/time.h>
#include "Socket.hpp"
// #include "Log.hpp"
using namespace std;

static const uint16_t defaultport = 8080;           // 默认端口号8080
static const int fd_num_max = 64;                   // poll数组的最大容量，最多同时监听64个文件描述符
int defaultfd = -1;                                 // 无效文件描述符，用来标识数组中空闲的位置
int no_event = 0;

class PollServer
{
public:
    PollServer(uint16_t port = defaultport)
        : _port(port)
    {
        for (int i = 0; i < fd_num_max; i++)
        {
            _event_fds[i].fd = defaultfd;           // 初始化每个位置的fd为-1（表示未使用）
            _event_fds[i].events = no_event;        // 初始化每个位置的监听事件为0（不监听任何事件）
            _event_fds[i].revents = no_event;       // 初始化每个位置的返回事件为0（无事件发生）

            // std::cout << "fd_array[" << i << "]" << " : " << fd_array[i] << std::endl;
        }
    }

    ~PollServer()
    {
        _listensock.Close();                        // 关闭监听socket
    }

    // 初始化服务器：创建socket、绑定端口、开始监听
    bool Init()
    {
        _listensock.Socket();                       // 创建监听socket
        _listensock.Bind(_port);                    // 绑定端口
        _listensock.Listen();                       // 开始监听

        return true;
    }

    // 打印当前在线的文件描述符列表
    void PrintFd()
    {
        cout << "在线_fd_列表： ";                  // 输出提示信息
        for (int i = 0; i < fd_num_max; i++)       // 遍历_event_fds数组
        {
            if (_event_fds[i].fd == defaultfd)     // 如果是空闲位置（fd为-1），跳过
            {
                continue;
            }

            cout << _event_fds[i].fd << " ";       // 输出有效的文件描述符
        }

        cout << endl;
    }

    void Accepter()
    {
        // 有新的客户端连接请求到来
        std::string client_ip;                     // 客户端的IP
        uint16_t client_port;                      // 客户端的端口

        int sock = _listensock.Accept(&client_ip, &client_port);    // 接收新的客户端连接
        if (sock < 0)
        {
            return;                                // 如果accept失败，直接返回
        }

        log_(Info, "新连接建立成功：客户端IP：%s，客户端端口：%d，socket fd：%d", client_ip.c_str(), client_port, sock);
        cout << "Info, 新连接建立成功：客户端IP：" << client_ip << "，客户端端口：" << client_port << "，socket fd：" << sock << endl;

        // 将新连接的文件描述符添加到poll数组中
        int pos = 1;                               // 从数组索引1开始找空闲位置（索引0存放监听socket）
        for (; pos < fd_num_max; pos++)            // 查找数组中空闲的位置
        {
            if (_event_fds[pos].fd != defaultfd)   // 如果当前位置已被占用（fd不为-1），继续找下一个
            {
                continue;
            }
            else                                   // 找到空闲位置，跳出循环
            {
                break;
            }
        }

        if (pos == fd_num_max)                     // 如果遍历完整个数组都没找到空闲位置
        {
            log_(Warning, "服务器已满，立即关闭%d！", sock);        // 服务器连接数已达上限，关闭新连接
            cout << "Warning, 服务器已满，立即关闭" << sock << "！" << endl;
            close(sock);
        }
        else // 找到了空闲位置
        {
            _event_fds[pos].fd = sock;             // 将新连接的fd放入数组
            _event_fds[pos].events = POLLIN;       // 设置该fd的监听事件为POLLIN（监听数据可读）
            _event_fds[pos].revents = no_event;    // 清空返回事件

            PrintFd();                             // 打印当前在线的fd列表

            // 后续可能还有其他处理
        }
    }

    // 处理数据接收的函数
    void Recver(int fd, int pos)                   // fd是需要读取数据的文件描述符，pos是该fd在数组中的位置
    {
        // 接收客户端发送的数据
        char buffer[1024];                         // 临时缓冲区，用于存储接收的数据
        ssize_t n = read(fd, buffer, sizeof(buffer) - 1);       // 从指定fd读取数据到缓冲区，预留1字节给字符串结束符
        if (n > 0)                                 // 读取到数据
        {
            buffer[n] = '\0';                      // 手动添加字符串结束符
            cout << "收到一条消息：" << buffer << endl;          // 输出接收到的消息
        }
        else if (n == 0)                           // 客户端断开连接（读到文件结束符）
        {
            log_(Info, "客户端退出了，关闭连接的文件描述符是%d", fd);   // 记录客户端断开日志
            close(fd);                             // 关闭该连接的文件描述符
            _event_fds[pos].fd = defaultfd;        // 将数组中对应位置重置为-1，表示该位置空闲（从poll监听列表中移除该fd）
        }
        else                                       // 读取错误
        {
            log_(Warning, "接收文件错误，描述符是: %d", fd);      // 记录接收错误日志
            close(fd);                             // 关闭该连接的文件描述符
            _event_fds[pos].fd = defaultfd;        // 将数组中对应位置重置为-1，表示该位置空闲（从poll监听列表中移除该fd）
        }
    }

    // 事件分发函数：处理所有就绪的事件
    void Dispatcher()                              // 遍历poll数组，检查哪些fd的事件已经就绪
    {
        for (int i = 0; i < fd_num_max; i++)
        {
            int fd = _event_fds[i].fd;             // 获取数组中第i个位置的fd
            if (fd == defaultfd)                   // 如果是无效fd（-1），跳过
            {
                continue;
            }

            if (_event_fds[i].revents & POLLIN)    // 如果这个fd的POLLIN事件已经就绪（有数据可读）
            {
                if (fd == _listensock.Fd())        // 如果就绪的fd是监听socket
                {
                    Accepter();                    // 说明有新的连接请求，调用Accepter处理
                }
                else                               // 如果就绪的fd不是监听socket，而是普通的数据连接socket
                {
                    Recver(fd, i);                 // 调用Recver处理数据接收
                }
            }
        }
    }

    // 服务器主循环：使用poll实现IO多路复用
    void Start()
    {
        _event_fds[0].fd = _listensock.Fd();       // 把监听socket的fd放到数组的第一个位置
        _event_fds[0].events = POLLIN;             // 监听socket只关心POLLIN事件（新连接请求）
        int timeout = 3000;                        // 设置poll超时时间为3000毫秒（3秒），如果3秒内没有事件发生，poll会返回0

        for (;;)                                   // 服务器无限循环，持续监听和处理事件
        {
            int n = poll(_event_fds, fd_num_max, timeout);   // 调用poll等待事件发生

            // 根据poll返回值进行处理
            switch (n)
            {
            // poll超时处理（timeout时间内没有事件发生）
            case 0:
                cout << "time out, timeout: " << timeout << endl;   // poll超时，没有事件发生
                break;
            // poll调用出错处理
            case -1:
                cout << "select error, errno:" << errno << endl;    // poll调用出错
                break;
            // poll成功处理（有事件发生）
            default:
                cout << "得到了一个新的连接请求！" << endl;           // poll成功，有事件发生（注意：这里注释可能不准确，有事件发生不一定都是连接请求）
                Dispatcher();                      // 调用Dispatcher处理所有就绪的事件
                break;
            }
        }
    }

private:
    Sock _listensock;                             // 监听socket对象
    uint16_t _port;                               // 服务器端口号
    struct pollfd _event_fds[fd_num_max];         // poll需要的数组，存储要监听的fd和事件（结构体数组，数组每一个位置都是结构体）
    // struct pollfd *_event_fds;

    // int fd_array[fd_num_max];
    // int wfd_array[fd_num_max];                 // 扩展写事件处理
};