#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/epoll.h>

#define MAX_EVENTS 64

int setfd_nonblock(int fd){
    int flag = fcntl(fd, F_GETFL, 0);
    return fcntl(fd, F_SETFL, flag | O_NONBLOCK);
}

int main()
{
    int socketfd, clientfd, epollfd;
    struct sockaddr_in address, client_address;
    int addrlen, nevent;
    char buffer[1024] = {0};
    struct epoll_event event;

    // 可以使用strace -p pid 来监视该进程的系统调用，观察阻塞的位置
    printf("current pid=%d\n", getpid());

    epollfd = epoll_create(1);

    socketfd = socket(AF_INET,SOCK_STREAM,0);
    if(socketfd == 0){
        perror("socket created failed\n");
        exit(-1);
    }

    // reactor 网络模型中需要设置为非阻塞io
    setfd_nonblock(socketfd);

    int optval = 1;
    if(setsockopt(socketfd, SOL_SOCKET, SO_REUSEPORT, (const void*)&optval, sizeof(optval))){
        perror("setsocketopt failed\n");
        exit(-1);
    }

    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(8989);
    if(bind(socketfd, (const struct sockaddr*)&address,sizeof(address)) < 0){
        perror("socket created failed\n");
        exit(-1);
    }

    // backlog = 511， 意味着当没有被accept可以堆积多少个fd
    if(listen(socketfd, 511) < 0){
        perror("listen error");
        exit(-1);
    }
    printf("start listening\n");


    // accept 对应 socketfd的读事件
    event.events = EPOLLIN;
    event.data.fd = socketfd;
    // 注册事件
    epoll_ctl(epollfd, EPOLL_CTL_ADD, socketfd, &event);
    while(1){
        struct epoll_event evs[MAX_EVENTS];
        nevent = epoll_wait(epollfd, evs, MAX_EVENTS, -1);
        for(int i = 0 ; i < nevent ; i++){
            struct epoll_event active = evs[i];
            if(active.data.fd == socketfd){
                clientfd = accept(socketfd, (struct sockaddr *)&client_address, (socklen_t *)&addrlen);
                if(clientfd < 0){
                    perror("accept error\n");
                    exit(-1);
                }
                printf("accept a client = %d\n", clientfd);
                // 这里这个event上面已经写入内核了，所以这时候可以复用这个event变量
                event.events = EPOLLIN;
                event.data.fd = clientfd;
                epoll_ctl(epollfd, EPOLL_CTL_ADD, clientfd, &event);
            }
            if(active.data.fd == clientfd){
                switch (active.events) {
                    case EPOLLIN:{
                        int n = read(clientfd, buffer, 1024);
                        if(n == 0){
                            printf("client=%d close the connect \n", clientfd);
                            close(clientfd);
                            continue;
                        }
                        printf("read from client: %s\n",buffer);
                        write(clientfd, buffer, n);
                        // close(clientfd);
                        break;
                    }
                    case EPOLLOUT:{
                        // 当写事件触发时，很可能是有数据一次没有写完，可以继续写入
                        break;
                    }
                    case EPOLLHUP:{
                        // 断开连接
                        epoll_ctl(epollfd, EPOLL_CTL_DEL, clientfd, &event);
                        close(clientfd);
                        printf("client %d disconnected", clientfd);
                    }
                }
            }
        }
    }
    close(socketfd);
    close(epollfd);
    return 0;
}