// This file is used to test epoll in multiple processes environment
//

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <arpa/inet.h>

static const char* host;
static int port;

struct context {
    int fd;
};

struct context ctx;

int create_listening() {
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in sockaddr;
    int optval = 1;
    socklen_t socklen;
    if (fd < 0) {
        perror("socket failed: ");
        goto fail;
    }
    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));

    socklen = sizeof(sockaddr);
    memset(&sockaddr, 0, socklen);
    sockaddr.sin_family = AF_INET;
    sockaddr.sin_port = htons(port);
    sockaddr.sin_addr.s_addr = INADDR_ANY;

    if (bind(fd, (struct sockaddr*)&sockaddr, socklen)) {
        perror("bind failed: ");
        goto fail;
    }

    if (listen(fd, 1024)) {
        perror("listen failed: ");
        goto fail;
    }

    ctx.fd = fd;

    return 0;
fail:
    if (fd >= 0) {
        close(fd);
    }
    return 1;
}

int ep_fd = -1;
int create_epoll() {
    ep_fd = epoll_create(10);
    if (ep_fd < 0) {
        perror("epoll create failed: ");
        goto fail;
    }
    return ep_fd;

fail:
    if (ep_fd >= 0) {
        close(ep_fd);
        ep_fd = -1;
    }
    return -1;
}

void handler(int fd) {
    close(fd);
}

void worker_process() {
    struct epoll_event ev;

    // listen
    if (create_listening()) {
        fprintf(stderr, "create listening failed.\n");
        return;
    }
    ev.events = EPOLLIN;
    ev.data.fd = ctx.fd;
    if (epoll_ctl(ep_fd, EPOLL_CTL_ADD, ctx.fd, &ev)) {
        perror("epoll control add event failed: ");
        return;
    }
    fprintf(stderr, "Child: goto sleep.\n");
    while (1) {
        sleep(100);
    }
}

void master_worker() {
    int i = 0;
    pid_t self_pid = getpid();
    fprintf(stderr, "Master: create epoll fd.\n");
    create_epoll();
    fprintf(stderr, "Master: create children process.\n");
    pid_t pid = fork();
    switch (pid) {
    case 0:
        worker_process();
        return;
    case -1:
        perror("create child failed:");
        break;
    default:
        break;
    }
    fprintf(stderr, "master wait epoll.\n");
    while (1) {
        struct epoll_event events[5];
        int num_event = epoll_wait(ep_fd, events, 5, 5000);
        if (num_event > 0) {
            int i = 0;
            for (; i < num_event; ++i) {
                if (events[i].events & EPOLLIN) {
                    printf("recevie event in fd is %d\n", events[i].data.fd);
                    int client_fd = accept(events[i].data.fd, NULL, NULL);
                    if (client_fd < 0) {
                        fprintf(stderr, "%d accept failed.\n", self_pid);
                    } else {
                        fprintf(stderr, "%d recevie epoll in event.\n", self_pid);
                        handler(client_fd);
                    }
                } else if (events[i].events & EPOLLERR) {
                    fprintf(stderr, "%d recevie epoll err event.\n", self_pid);
                } else {
                    fprintf(stderr, "%d recevie epoll unknown event.\n", self_pid);
                }
            }
        } else if (num_event < 0) {
            perror("epoll wait failed");
        } else {
            printf("no events.num_event=%d\n", num_event);
        }
    }
}

int create_master() {
    master_worker();
}

void print_help() {
    fprintf(stderr, "usage\n");
    fprintf(stderr, "\t./a.out host port\n");
    fprintf(stderr, "example\n");
    fprintf(stderr, "\t./a.out 127.0.0.1 54321\n");
}

int main(int argc, char* argv[]) {
    if (argc != 3) {
        print_help();
        return 1;
    }

    // Get argument information.
    host = argv[1];
    port = atoi(argv[2]);
    printf("host is %s and port is %d\n", host, port);

    // create master
    create_master();

    return 0;
}