#include "../base_tool.h"
#include <sys/epoll.h>
#include <signal.h>
#include <string.h>

int epfd = 0;
#define BUFFER_LENGTH 1024
#define CONN_SIZE 1048576

typedef int (*RCALLBACK)(int fd);

struct conn {  // 什么事件，执行什么回调函数
    int fd;
    char rbuffer[BUFFER_LENGTH];
    char rlength;
    char wbuffer[BUFFER_LENGTH];
    char wlength;

    RCALLBACK send_callback;
    union {
        RCALLBACK recv_callback;
        RCALLBACK accept_callback;  // 只有 EPOLLIN 和 EPOLLOUT 两个事件，所以accept和recv是或的关系
    } r_action;
};

struct conn conn_list[CONN_SIZE] = {0};

long GetUnixTime() {
    auto now = std::chrono::system_clock::now();
    // 转换为时间戳
    auto timestamp = std::chrono::system_clock::to_time_t(now);
    return timestamp;
}

void set_event(int fd, int event, int flag) {  // 设置事件
    if (flag) {  // add
        struct epoll_event ev;
        ev.events = event;
        ev.data.fd = fd;
        epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);
    } else {  // modify
        struct epoll_event ev;
        ev.events = event;
        ev.data.fd = fd;
        epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &ev);
    }
}

int init_server(unsigned short port) {  // 初始化一个server
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);  // 创建一个socket
    struct sockaddr_in servaddr;

    servaddr.sin_family = AF_INET;                 // 指定IP地址版本为IPV4
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  // 绑定本地0.0.0.0
    servaddr.sin_port = htons(port);               // 0~1023系统默认，需要给一个大于1024的地址，小于65535

    if (-1 == bind(sockfd, (struct sockaddr *)&servaddr, sizeof(struct sockaddr))) {
        std::cout << "bind failed" << std::endl;
        return -1;
    }
    
    listen(sockfd, 10);
    printf("listen finished\n");
    return sockfd;
}

int recv_callback(int fd) {
    int count = recv(fd, conn_list[fd].rbuffer, BUFFER_LENGTH, 0);
    conn_list[fd].rlength = count;
    
    if (count == 0) {
        printf("client disconnect%d\n", fd);
        epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);  // TODO: unfinished
        close(fd);
        return -1;
    }
    
    printf("RECV :%s\n", conn_list[fd].rbuffer);

    // echo: 默认将客户端发送的内容，回给客户端
    memcpy(conn_list[fd].wbuffer, conn_list[fd].rbuffer, conn_list[fd].rlength);
    conn_list[fd].wlength = conn_list[fd].rlength;
    set_event(fd, EPOLLOUT, 0);
    
    return count;
}

int send_callback(int fd) {
    int count = send(fd, conn_list[fd].wbuffer, BUFFER_LENGTH, 0);
    printf("SEND :%s\n", conn_list[fd].wbuffer);
    set_event(fd, EPOLLIN, 0);
    return count;
}

int event_register(int fd, int event) {  // 事件注册函数
    if (fd < 0) {
        return -1;
    }
    
    conn_list[fd].fd = fd;
    conn_list[fd].r_action.recv_callback = recv_callback;
    conn_list[fd].send_callback = send_callback;
    
    // 为新的链接设置回调
    memset(conn_list[fd].rbuffer, 0, BUFFER_LENGTH);
    conn_list[fd].rlength = 0;

    memset(conn_list[fd].wbuffer, 0, BUFFER_LENGTH);
    conn_list[fd].wlength = 0;

    set_event(fd, event, 1);
    return 0;
}

int accept_callback(int fd) {
    struct sockaddr client_addr;
    socklen_t client_addr_len = sizeof(client_addr);
    int clientfd = accept(fd, &client_addr, &client_addr_len);

    printf("accept clienfd=%d\n", clientfd);
    
    if (clientfd < 0) {
        printf("accept failed %s\n", strerror(errno));
        return -1;
    }
    
    event_register(clientfd, EPOLLIN);  // 接受到新的客户端fd，注册EPOLLIN事件
    return 0;
}

int main(int argc, char **argv) {
    if (argc <= 1) {
        printf("Usage: %s port\n", argv[0]);
        exit(0);
    }
    
    unsigned short port = atoi(argv[1]);
    int sockfd = init_server(port);

    epfd = epoll_create(1);
    conn_list[sockfd].fd = sockfd;
    conn_list[sockfd].r_action.recv_callback = accept_callback;
    set_event(sockfd, EPOLLIN, 1);
    
    while (1) {  // mainloop
        struct epoll_event events[1024] = {0};
        int nready = epoll_wait(epfd, events, 1024, -1);
        
        for (int i = 0; i < nready; i++) {
            // 当有epoll连入时，根据具体时间，调用对应的函数
            int connfd = events[i].data.fd;
            
            // 一次循环中，IO的读写可能并存，一起处理
            if (events[i].events & EPOLLIN) {
                conn_list[connfd].r_action.recv_callback(connfd);  
                // 可能是accept_callback，他们共用一个函数空间，所以都能调到
            }

            if (events[i].events & EPOLLOUT) {
                conn_list[connfd].send_callback(connfd);
            }
        }
    }
}

// main    
epfd = epoll_create(1);

for (int i = 0; i < MAX_PORT; i++) {  // 初始化20个server，每个都注册
    int sockfd = init_server(port + i);
    conn_list[sockfd].fd = sockfd;
    conn_list[sockfd].r_action.recv_callback = accept_callback;
    set_event(sockfd, EPOLLIN, 1);
}

int main() {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in servaddr;

    servaddr.sin_family = AF_INET;                  // 指定IP地址版本为IPV4
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);   // 绑定本地0.0.0.0
    servaddr.sin_port = htons(3264);                // 0~1023系统默认，需要给一个大于1024的地址，小于65535

    if (-1 == bind(sockfd, (struct sockaddr*)&servaddr, sizeof(struct sockaddr))) {
        std::cout << "bind failed" << std::endl;
        return -1;
    }
    
    listen(sockfd, 10);
    printf("listen finished\n");
    
    struct sockaddr_in clientaddr;
    socklen_t len = sizeof(clientaddr);
    int clientfd = accept(sockfd, (struct sockaddr *)&servaddr, &len);  // 会阻塞，直至第一次来连接
    
    while (1) {  
        printf("accept finished\n");
        char buffer[1024] = {0};
        int count = recv(clientfd, buffer, 1024, 0);  // 会阻塞，直至收到消息
        
        if (count == 0) {
            std::cout << "client closed!" << std::endl;
            close(clientfd);
            return 0;
        }
        
        printf("RECV:%s\n", buffer);
    }

    printf("exit\n");
    return 0;
}

#define THREAD_CREATE_FUNC 0

#if THREAD_CREATE_FUNC
void *client_thread(void *clientfd) {
    int client_fd = *(int *)clientfd;
    while (1) {
        printf("accept finished\n");
        char buffer[1024] = {0};
        int count = recv(client_fd, buffer, 1024, 0);
        
        if (count == 0) {
            close(clientfd);
            std::cout << "client closed!" << std::endl;
            return 0;
        }
        
        printf("RECV:%s\n", buffer);
    }
}
#else
void client_thread(int clientfd) {
    while (1) {
        printf("accept finished\n");
        char buffer[1024] = {0};
        int count = recv(clientfd, buffer, 1024, 0);
        
        if (count == 0) {
            close(clientfd);
            std::cout << "client closed!" << std::endl;
            return;
        }
        
        printf("RECV:%s\n", buffer);
    }
}
#endif

int main() {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);  // 创建一个socket
    struct sockaddr_in servaddr;

    servaddr.sin_family = AF_INET;                 // 指定IP地址版本为IPV4
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  // 绑定本地0.0.0.0
    servaddr.sin_port = htons(3264);               // 0~1023系统默认，需要给一个大于1024的地址，小于65535

    if (-1 == bind(sockfd, (struct sockaddr *)&servaddr, sizeof(struct sockaddr))) {
        std::cout << "bind failed" << std::endl;
        return -1;
    }
    
    listen(sockfd, 10);
    printf("listen finished\n");

    // 创建线程方法1
#if THREAD_CREATE_FUNC
    struct sockaddr_in clientaddr;
    socklen_t len = sizeof(clientaddr);
    
    while (1) {
        int clientfd = accept(sockfd, (struct sockaddr *)&clientaddr, &len);
        
        if (clientfd >= 0) {
            pthread_t thread_id;
            pthread_create(&thread_id, NULL, client_thread, (void *)&clientfd);
        }
    }
#else
    // 创建线程方法2
    struct sockaddr_in clientaddr;
    socklen_t len = sizeof(clientaddr);
    
    while (1) {
        int clientfd = accept(sockfd, (struct sockaddr *)&clientaddr, &len);
        
        if (clientfd >= 0) {
            std::thread t1(client_thread, clientfd);
            t1.detach();
        }
    }
#endif

    printf("exit\n");
    return 0;
}

fd_set rfds, rset, wset, errset;  // fd的集合  
FD_ZERO(&rfds);
FD_SET(sockfd, &rfds);  // 设置
int max_fd = sockfd;    // 用于对fd_set做遍历的最大个数

while (1) {
    rset = rfds;
    // 需要传入 是否可读 / 是否可写？
    int nready = select(max_fd + 1, &rset, &wset, &errset, NULL);
    // 返回值为就绪的总数量
    // 该函数有五个参数：
    // 1. 最大的fd
    // 2. 可读集合
    // 3. 可写集合(一般为NULL)
    // 4. 错误集合(一般为NULL)
    // 5. 超时时间(一般为NULL)
    
    // 例如select返回 rset 俩个 wset 3个，nready = 5
    // 每次调用都会将fd的集合拷贝到内存中去，循环判断IO有没有就绪，判断三个集合
    
    char buffer[1024] = {0};
    
    if (FD_ISSET(sockfd, &rset)) {  // sockfd有没有被设置？
        sockaddr_in clientaddr;
        socklen_t len = sizeof(clientaddr);
        int clientfd = accept(sockfd, (struct sockaddr *)&clientaddr, &len);

        std::cout << "clientfd: " << clientfd 
                  << " ip:" << inet_ntoa(clientaddr.sin_addr) 
                  << " port:" << ntohs(clientaddr.sin_port) << std::endl;

        FD_SET(clientfd, &rfds);
        max_fd = clientfd > max_fd ? clientfd : max_fd;  // 可能会回收所以取他们的最大值
    }
    
    // recv 
    for (int i = sockfd + 1; i <= max_fd; i++) {
        if (FD_ISSET(i, &rset)) {
            int ret = recv(i, buffer, 1024, 0);
            
            if (ret == 0) {
                printf("client disconnect:%d \n", i);
                close(i);  // close后应该要在fd_set中清空的
                FD_CLR(i, &rset);
                continue;
            }
            
            std::cout << string(buffer) << std::endl;
        }
    }
}

for (i = 0; i < max_fd; i++);  // 类似于这样

/* Data structure describing a polling request. */
struct pollfd {
    int fd;              // 对应的fd值
    short int events;    // 关心的events
    short int revents;   // 实际上发生了可读的
};

// poll:
struct pollfd fds[1024] = {0};  // 创建poll_set
fds[sockfd].fd = sockfd;
fds[sockfd].events = POLLIN;

int max_fd = sockfd;  // 也可以用1024，但底层每次就会循环1024个了

while (1) {
    int nready = poll(fds, max_fd + 1, -1);  // -1是一直阻塞，将fds拷贝到内核，内核通过循环判断poll是否已经就绪
    
    if (fds[sockfd].revents & POLLIN) {  // 只要有一位为1：POLLIN:位 0000 0001
        struct sockaddr_in clientaddr;
        socklen_t len = sizeof(clientaddr);
        int clientfd = accept(sockfd, (struct sockaddr *)&clientaddr, &len);
        
        std::cout << "clientfd: " << clientfd 
                  << " ip:" << inet_ntoa(clientaddr.sin_addr) 
                  << " port:" << ntohs(clientaddr.sin_port) << std::endl;
                  
        max_fd = max_fd > clientfd ? max_fd : clientfd;
        fds[clientfd].fd = clientfd;
        fds[clientfd].events = POLLIN;
    }
    
    for (int i = 0; i < max_fd + 1; i++) {
        if (fds[i].revents & POLLIN) {
            // RECV:
            char buffer[1024] = {0};
            int count = recv(i, buffer, 1024, 0);
            
            if (count == 0) {
                printf("client disconnect:%d\n", i);
                fds[i].fd = -1;
                fds[i].events = 0;
                close(i);
            }
            
            printf("%s\n", buffer);
        }
    }
}

int epoll_create(int size);
int epoll_ctl(int epfd, int op, int fd, struct epoll_event * _Nullable event);
int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);

typedef union epoll_data {
    void *ptr;   
    int fd;      // 对应的fd，貌似只用到了这个
    uint32_t u32;
    uint64_t u64;
} epoll_data_t;

struct epoll_event {
    uint32_t events;     /* Epoll events */  // 用于规定模式，EPOLLIN？
    epoll_data_t data;   /* User data variable */
} __EPOLL_PACKED;

// int epoll_create(int size);
// size：最开始是一次性最多就绪的数量，但后来从数组改成了列表，size没有了作用。只要不等于0，就效果相同，目的是兼容过去
int epfd = epoll_create(1);

struct epoll_event ev;
ev.events = EPOLLIN;
ev.data.fd = sockfd;

sockaddr client_addr;
socklen_t len = sizeof(client_addr);

epoll_ctl(epfd, EPOLL_CTL_ADD, sockfd, &ev);

while (1) {
    struct epoll_event events[1024] = {0};
    int nready = epoll_wait(epfd, events, 1024, -1);

    for (int i = 0; i < nready; i++) {   
        int confd = events[i].data.fd;
        
        if (confd == sockfd) {  // 有新的链接来了
            int clientfd = accept(sockfd, (sockaddr*)&client_addr, &len);
            ev.events = EPOLLIN;
            ev.data.fd = clientfd;
            epoll_ctl(epfd, EPOLL_CTL_ADD, clientfd, &ev);

            printf("accept finished:%d\n", clientfd);
        }    
        else if (events[i].events & EPOLLIN) {  // 有新的消息来了
            char buffer[1024] = {0};
            int count = recv(confd, buffer, 1024, 0);
            
            if (count == 0) {
                printf("client disconnect!\n");
                epoll_ctl(epfd, EPOLL_CTL_DEL, ev.data.fd, NULL);
                close(confd);
                continue;
            }
            
            printf("clientfd: %d msg=%s", confd, buffer);
            send(confd, buffer, count, 0);
            printf("send\n");
        }
    }
}

int main() {
    int a; // 由于此处未给a进行初始化
    printf("a=%d", a);  // 对a进行了访问，在VS中编译将会报错，而在linux中则可以正常运行，但是数值每次运行程序时，并不固定
    printf("b=%d", b);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>  // 在C语言使用malloc需要引用stdlib.h,如果使用iostream则无需另外添加stdlib.h

struct Another {
    int a;
};

int b;

int main() {
    struct Another* struc = (struct Another*)malloc(sizeof(struct Another));
    int a = 5;
    printf("a=%d", struc->a);
    printf("b=%d", b);
    printf("d=%d");  // 警告 C6064 缺少"printf"的整型参数(对应于转换说明符"1")。会打印出来不被定义的值 -1282888768(该值多次运行并不一定)，且多次打印 format '%d' expects a matching 'int' argument 
    printf("d=%d");  // 警告 C6064 缺少"printf"的整型参数(对应于转换说明符"1")。会打印出来不被定义的值 -1282888768，和上方一样
    return 0;
}

#include <iostream>

int main() {
    // int units_sold = 0;
    // int units_sold = {0};
    // int units_sold{0};
    int units_sold(0);
    std::cout << units_sold << std::endl;
}

int main() {
    long double ld = 3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679;
    int a{ld}, b = {ld};  // 这里在VS里面会直接不过编译，报错，但是在linux只会warning // C++11 style initialization
    int c(ld), d = ld;     // C++98 style initialization
}

// **LINUX**
// warning: narrowing conversion of 'ld' from 'long double' to 'int' [-Wnarrowing]  可以通过编译
//   10 |     int a{ld},b = {ld};

// **WINDOWS**
// 错误 C2397 从"long double"转换到"int"需要收缩转换 testC C:\Users\24854\source\repos\testC\testC\testC.cpp 7

// main.cpp
#include <stdio.h>
#include <stdlib.h>  // 在C语言使用malloc需要引用stdlib.h,如果使用iostream则无需另外添加stdlib.h
// #include "new.cpp"  // ERROR! 注意，这里不可以include "new.cpp" 变量只能被定义一次，但是可以多次被声明

extern int p;       // 这里只是声明
extern int func();  // 这里只是声明

int main() {
    printf("%d\n", p);
    int d = func();
    printf("%d\n", d);
    return 0;
}

// new.cpp
#ifndef NEW_H
#define NEW_H

int p = 15;   // 可以是变量
int func() {  // 也可以是函数
    return p;
}

#endif

// 相关知识介绍
extern int i;  // 声明了i而非定义i
int j;         // 声明并定义j
extern double pi = 3.1416;  // 定义pi(没有声明)

int ival = 1024;
int &refVal = ival;
int &refVal2;  // ERROR, 引用必须被初始化

refVal = 2;      // 把2赋给refVal指向的对象，此处即是赋给了ival
int ii = refVal; // 与ii = ival 执行结果相同

int i = 1024, i2 = 2048;     // i和i2都是int
int &r = i, r2 = i2;         // r是一个引用，与i绑定在一起，r2是int
int i3 = 1024, &ri = i3;     // i3是int，ri是一个引用，与i3绑定在一起
int &r3 = i3, &r4 = i2;      // r3 r4都是引用

int ival = 42;
int *p = &ival;// p存放变量ival的地址

int *p = nullptr;   // 等价于 int *p1 = 0;
int *p2 = 0;        // 直接将p2初始化为字面常量0
// 需要先 include cstdlib
int *p3 = NULL;     // 等价于 int *p3 = 0;

const int k;  // 错误，k是一个未经初始化的常量

int i = 42;
const int ci = i;  // 正确：i的值被拷贝给了ci
int j = ci;        // 正确：ci的值被拷贝给了j

const int bufSize = 512; // 输入缓冲区大小

double i = 5.14;
const int& ref = i;  // 正确，实际上运行过程为 const int temp = i; const int & ref = temp;
int& p = i;          // 错误，引用有严格的类型检查，绑定的对象一定和自己的类型一致

int i = 1024; 
const int& const_int_i = i;       // 对const的引用可能引用一个并非const的对象
const double& const_double_i = i;
int& refi = i;

i = 5;
std::cout << const_int_i << std::endl;       // 5，常量引用会正常的修改到
std::cout << const_double_i << std::endl;    // 1024，修改了类型的常量流程为实际上运行过程为 const int temp = i; const int & ref = temp;
                                             // 是额外开辟了一个变量，所以不会被修改到。
std::cout << refi << std::endl;              // 5, refi 被修改到了

const int& r2 = 24;  // 正确，const int temp = 24; const int& r2 = temp;(实际上)

const double pi = 3.14;      // pi是个常量，它的值不可以改变
double *ptr = π           // 错误：ptr是一个普通指针
const double *cptr = π    // 正确，cptr可以指向一个双精度常量
*cptr = 42;                  // 错误：不能给*cptr赋值

int errNumb = 0;
int * const curErr = &errNumb;  // curErr将会一直指向errNumb

const int max_files = 20;      // max_files 是常量表达式
const int limit = max_files + 1; // limit是常量表达式
int staff_size = 27;           // staff_size 不是常量表达式
const int sz = get_size();     // sz 不是常量表达式

constexpr int mf = 20;           // 20 是常量表达式
constexpr int limit = mf + 1;    // mf + 1是常量表达式
constexpr int sz = size();       // 只有当size是一个constexpr函数时才是一个正确的声明语句

const int* p = nullptr;           // 指向常量的指针，底层const
constexpr int *q = nullptr;       // 指向整数的常量指针，顶层const

constexpr int *np = nullptr;      // 指向整数的常量指针，顶层const
int j = 0;
constexpr int i = 42;             // i的类型是整数常量

// i和j必须定义在函数体之外，全局变量（包括main函数）
constexpr const int* p = &i;      // p是常量指针，指向常量i
constexpr int* p1 = &j;           // p1是常量指针，指向变量j

typedef double wages;       // wages是double的同义词
using wages = double;       // wages是double的同义词
wages hourly, weekly;       // 等价于 double hourly, weekly;

typedef int* pint;
int a = 5;
const pint b = &a;  // 实际上是 int * const b = &a  指向int的常量指针
                    // 并不是直接的替换 const int* b : 指向int常量的指针

auto i = 0, *p = &i;     // 正确；i是整数，p是整形指针 他们的基本数据类型都是int，*是修饰符
auto sz = 0, pi = 3.14;  // 错误：sz 和 pi的类型不一致(int, double)

int i = 0, &r = i;
auto a = r;  // a是一个整数 (r是i的别名，而i是一个整数)

const int ci = i, &cr = ci;
auto b = ci;        // b的类型为int，顶层const的特性被忽略掉了
auto c = cr;        // c是一个整数，（cr是ci的别名，ci本身是一个顶层const，顶层const的特性被忽略掉了）
auto d = &i;        // i本身是一个变量，d是一个整型的指针（整数的地址就是指向整数的指针）
auto e = &ci;       // ci本身是一个顶层const，&i是一个底层const
                    // （对常量对象取地址是一种底层const）
                    // 底层const会保留，所以e的类型是const int* (指向整数常量的指针)

const auto f = ci;  // ci的推演类型为int，f是 const int

auto &g = ci;         // g 是一个整形常量的引用
auto &h = 42;         // 错误，不能为常量绑定引用
const auto &j = 42;   // 正确，可以为常量引用绑定字面值