#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <string>
#include <event2/event.h>
#include <event.h>
#include <sys/types.h>
#include <netinet/in.h>

using namespace std;

#define SERVER_PORT 5185

struct client
{
    int fd;
    struct bufferevent *buf_ev;
};

int setnonblock(int fd)
{
    int flags;

    flags = fcntl(fd, F_GETFL);
    flags |= O_NONBLOCK;
    fcntl(fd, F_SETFL, flags);
}

void buf_read_callback(struct bufferevent *incoming, void *arg)
{
    struct evbuffer *evreturn;
    char *req;

    req = evbuffer_readline(incoming->input);
    if (req == NULL)
        return;

    evreturn = evbuffer_new();
    evbuffer_add_printf(evreturn, "You said %s\n", req);
    bufferevent_write_buffer(incoming, evreturn);
    evbuffer_free(evreturn);
    free(req);
}

void buf_write_callback(struct bufferevent *bev, void *arg)
{
}

void buf_error_callback(struct bufferevent *bev, short what, void *arg)
{
    struct client *client = (struct client *)arg;
    bufferevent_free(client->buf_ev);
    close(client->fd);
    free(client);
}

void accept_callback(int fd, short ev, void *arg)
{
    int client_fd;
    struct sockaddr_in client_addr;
    socklen_t client_len = sizeof(client_addr);
    struct client *client2;

    client_fd = accept(fd, (struct sockaddr *)&client_addr, &client_len);

    if (client_fd < 0)
    {
        fprintf(stderr, "failed accepting client\n");
        return;
    }

    setnonblock(client_fd);

    client2 = calloc(1, sizeof (*client));
    if (client2 == NULL)
        fprintf(stderr, "malloc failed\n");
    client2->fd = client_fd;

    client2->buf_ev = bufferevent_new(client_fd, buf_read_callback, buf_write_callback, buf_error_callback, client2);
    bufferevent_enable(client2->buf_ev, EV_READ);
}

int main()
{
    printf("sizeof (structjunk) = %zu\n", sizeof(struct client));

    int socketlisten;
    struct sockaddr_in addresslisten;
    struct event accept_event;
    int reuse = 1;

    event_init();

    socketlisten = socket(AF_INET, SOCK_STREAM, 0);

    if (socketlisten < 0)
    {
        fprintf(stderr, "Failed to create listen socket\n");
        return 1;
    }

    addresslisten.sin_family = AF_INET;
    addresslisten.sin_addr.s_addr = INADDR_ANY;
    addresslisten.sin_port = htons(SERVER_PORT);

    if (bind(socketlisten, (struct sockaddr *)&addresslisten, sizeof(addresslisten)) < 0)
    {
        fprintf(stderr, "failed to bind socket\n");
        return 1;
    }

    if (listen(socketlisten, 5) < 0)
    {
        fprintf(stderr, "failed to listen\n");
        return 1;
    }

    setsockopt(socketlisten, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
    setnonblock(socketlisten);

    event_set(&accept_event, socketlisten, EV_READ|EV_PERSIST, accept_callback, NULL);
    event_add(&accept_event, NULL);
    event_dispatch();

    close(socketlisten);
    return 0;
}