#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <errno.h>
#include <string.h>

#define MAXEVENTS 64

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

int main () {
    int listening;
    struct sockaddr_in server;

    listening = socket(AF_INET , SOCK_STREAM , 0);
    if (listening == -1)
    {
        printf("Could not create socket");
    }

    int s;

    server.sin_family = AF_INET;
    server.sin_addr.s_addr = INADDR_ANY;
    server.sin_port = htons( 8888 );

    if( bind(listening,(struct sockaddr *)&server , sizeof(server)) < 0)
    {
        puts("bind failed");
    }
    listen(listening, SOMAXCONN);

    int efd;
    struct epoll_event event;
    struct epoll_event *events;

    efd = epoll_create1(0);
    if (efd == -1) {
        puts("epoll_create failed");
    }

    event.data.fd = listening;
    event.events = EPOLLIN | EPOLLOUT;
    s = epoll_ctl(efd, EPOLL_CTL_ADD, listening, &event);
    if (s == -1) {
        puts("epoll_ctl failed");
    }

    events = calloc(MAXEVENTS, sizeof event);

    while (1) {
        int socketCount = epoll_wait(efd, events, MAXEVENTS, -1);
        if (socketCount == -1) {
            perror("epoll_pwait");
            exit(1);
        }
        for (int i = 0; i < socketCount; i++) {
            if ((events[i].events & EPOLLERR) ||
                (events[i].events & EPOLLHUP) ||
                (!(events[i].events & EPOLLIN))) {
                fprintf(stderr, "epoll error\n");
                close(events[i].data.fd);
                continue;
            }
            else if (events[i].data.fd == listening) {
                int client = accept(listening, NULL, NULL);
                //If any clients
                if (client == -1) {
                    if ((errno == EAGAIN) ||
                        (errno == EWOULDBLOCK)) {
                        break;
                    }
                    else {
                        puts("accept failed");
                        break;
                    }
                }
                //Add to epoll
                setnonblocking(client);
                event.events = EPOLLIN | EPOLLET;
                event.data.fd = client;
                if (epoll_ctl(efd, EPOLL_CTL_ADD, client, &event) == -1) {
                    perror("epoll_ctl");
                    exit(1);
                }
                char* message = "Welcome!\r\n";
                write(client, message, strlen(message));
            }
            else {
                ssize_t count;
                char buf[512];

                count = read(events[i].data.fd, buf, sizeof buf);
                if (count == -1) {
                    perror("read");
                    exit(1);
                }

                struct epoll_event *events_to;
                int n = epoll_wait(efd, events_to, MAXEVENTS, -1);
                for (int j = 0; j < n; j++) {
                    if (events_to[j].data.fd != listening) {
                        write(events_to[j].data.fd, buf, count);
                    }
                }
            }
        }
    }

    listen(listening, SOMAXCONN);

}