##include <sys/socket.h>
##include <string.h>
##include <errno.h>
##include <stdio.h>
##include <unistd.h>
##include <netinet/in.h>

##include <liburing.h>

##define ENTRIES_LENGTH 1024

enum{
    EVENT_ACCEPT = 0,
    EVENT_READ,
    EVENT_WRITE
};

typedef struct _conninfo{
    int connfd;
    int event;
} conninfo;

void set_accept_event(struct io_uring *ring, int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags)
{
    printf("enter set_accept_event\n");
    struct io_uring_sqe* sqe = io_uring_get_sqe(ring);
    io_uring_prep_accept(sqe, sockfd, addr, &addrlen, NULL);

    // user_data这个段专门用来传递参数
    conninfo info_accept = {
        .connfd = sockfd,
        .event = EVENT_ACCEPT,
    };
    memcpy(&sqe->user_data, &info_accept, sizeof(info_accept));
}

void set_recv_event(struct io_uring *ring, int clientfd, char* buf, int len, int flags){
    printf("enter set_recv_event\n");
    struct io_uring_sqe* new_seq = io_uring_get_sqe(ring);
    io_uring_prep_recv(new_seq, clientfd, buf, len ,0);
    conninfo info_recv = {
        .connfd = clientfd,
        .event = EVENT_READ,
    };
    memcpy(&new_seq->user_data, &info_recv, sizeof(info_recv));
}

void set_send_event(struct io_uring *ring, int clientfd, char* buf, int len, int flags)
{
    printf("enter set_send_event\n");
    struct io_uring_sqe* sqe = io_uring_get_sqe(ring);
    io_uring_prep_send(sqe, clientfd, buf, len, NULL);

    // user_data这个段专门用来传递参数
    conninfo info_send = {
        .connfd = clientfd,
        .event = EVENT_WRITE,
    };
    memcpy(&sqe->user_data, &info_send, sizeof(info_send));
}

int main()
{
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(struct sockaddr_in));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(9999);

    if(-1 == bind(sockfd, (struct sockaddr*)&servaddr, sizeof(struct sockaddr))){
        printf("bind failed: %s", strerror(errno));
        return -1;
    }
    listen(sockfd, 10);

    struct io_uring_params params;
    memset(&params, 0, sizeof(struct io_uring_params));

    struct io_uring ring;
    /*
        这个函数带了空间大小，会调用系统调用
        ret = syscall(_NR_io_uring_setup, ENTRIES_LENGTH, p);
        所以这块空间在内核空间中的
        ret = io_uring_queue_mmap(fd, p, ring);
        同时在用户空间有一层映射，所以对用户空间的内容进行操作，该操作能映射到内核空间
    */
    io_uring_queue_init_params(ENTRIES_LENGTH, &ring, &params);

    // 提交任务的位置
    struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);

    // 对比：所以io_uring_prep_等函数都是posix api的一致调用
    // int accept(int sockfd, struct sockaddr *addr, socklen_t* addrlen);
    // int accept4(int sockfd, struct sockaddr *addr, socklen_t* addrlen, int flags);
    // void io_uring_prep_accept(struct io_uring_sqe *sqe, int fd,
    //                          struct sockaddr *addr, socklen_t* addrlen, int flags);
    struct sockaddr_in clientaddr;
    socklen_t clilen = sizeof(struct sockaddr);
    set_accept_event(&ring, sockfd, (struct sockaddr*)&clientaddr, &clilen, NULL);

    char buf[1024];

    while(1){
        io_uring_submit(&ring); // sqe提交到内核执行
        /*
            提交queue（sq）到结束queue（cq）是没有拷贝动作的，只改变指针
            为了提高性能
        */
        // 判断cqe队的头节点不为空
        struct io_uring_cqe *cqe;
        io_uring_wait_cqe(&ring, &cqe);


        struct io_uring_cqe *cqes[10]; // 假设一次取10个结果
        int cqecount = io_uring_peek_batch_cqe(&ring, cqes, 10);

        printf("cqecount --> %d\n", cqecount);

        for(int i = 0 ; i < cqecount ; i++)
        {
            cqe = cqes[i];
            conninfo ci;
            memcpy(&ci, &cqe->user_data, sizeof(ci));

            if(ci.event == EVENT_ACCEPT){
                int clientfd = cqe->res;
                if(clientfd < 0){
                    continue;
                }
                printf("clientfd = %d\n", clientfd);
                // 每次accept一个事件处理完，需要重新加一个事件，才能触发第二次
                // 因为sq的事件进入cq之后，sq中就没有这个事件了
                set_accept_event(&ring, ci.connfd, (struct sockaddr*)&clientaddr, &clilen, NULL);
                set_recv_event(&ring, clientfd, buf, 1024, NULL);
            }
            else if(ci.event == EVENT_READ){
                int len = cqe->res; // io_uring_prep_recv的res返回的是读的长度
                if(len < 0){
                    continue;
                }
                else if(len == 0){
                    close(ci.connfd);
                }
                else{
                    // reactor与proactor模式的本质区别：
                    // 与reactor模式的区别在这里，reactor模式当通知事件的时候，我们还没开始读
                    // 而这里，事件来的时候，读已经完成了，数据已经在buf里了，这就是proactor模式
                    printf("recv ---> %s, %d\n", buf, cqe->res);
                }
                set_recv_event(&ring, ci.connfd, buf, 1024, NULL);
                // echo
                set_send_event(&ring, ci.connfd, buf, cqe->res, NULL);
            }
            else if(ci.event == EVENT_WRITE){
                printf("write complete\n");
            }
        }
        // 需要应用程序清空cq，不然会一直触发
        io_uring_cq_advance(&ring, cqecount);

    }

    getchar();
}