#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include <ctype.h>
#include <time.h>
#include <errno.h>
#include <sysexits.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <dirent.h>
#include <fcntl.h>

#include "dump.h"

#define MAX_ARGS 50
#define MAX_SUBPROCS 50

#define max(a,b) ((a)>(b)?(a):(b))

bool running = true;
char *handler = NULL;
char *msgdir = NULL;
struct timeval output_interval = {0};

void
maybe_setenv(char *key, char *val)
{
    if (val) {
        setenv(key, val, 1);
    }
}

void
irc_filter(const char *str)
{
    char buf[4096];
    char *line = buf;
    char *parts[20] = {0};
    int   nparts;
    char  snick[20];
    char *cmd;
    char *text = NULL;
    char *prefix = NULL;
    char *sender = NULL;
    char *forum = NULL;
    int   i;

    strncpy(buf, str, sizeof buf);
    /* Tokenize IRC line */
    nparts = 0;
    if (':' == *line) {
        prefix = line + 1;
    } else {
        parts[nparts++] = line;
    }
    while (*line) {
        if (' ' == *line) {
            *line++ = '\0';
            if (':' == *line) {
                text = line+1;
                break;
            } else {
                parts[nparts++] = line;
            }
        } else {
            line += 1;
        }
    }

    /* Strip trailing carriage return */
    while (*line) line += 1;
    if ('\r' == *(line-1)) *(line-1) = '\0';

    /* Set command, converting to upper case */
    cmd = parts[0];
    for (i = 0; cmd[i]; i += 1) {
        cmd[i] = toupper(cmd[i]);
    }

    /* Extract prefix nickname */
    for (i = 0; prefix && (prefix[i] != '!'); i += 1) {
        if (i == sizeof(snick) - 1) {
            i = 0;
            break;
        }
        snick[i] = prefix[i];
    }
    snick[i] = '\0';
    if (i) {
        sender = snick;
    }

    /* Determine forum */
    if ((0 == strcmp(cmd, "PRIVMSG")) ||
            (0 == strcmp(cmd, "NOTICE"))) {
        /* :neale!user@127.0.0.1 PRIVMSG #hydra :foo */
        switch (parts[1][0]) {
            case '#':
            case '&':
            case '+': 
            case '!':
                forum = parts[1];
                break;
            default:
                forum = snick;
                break;
        }
    } else if ((0 == strcmp(cmd, "PART")) ||
            (0 == strcmp(cmd, "MODE")) ||
            (0 == strcmp(cmd, "TOPIC")) ||
            (0 == strcmp(cmd, "KICK"))) {
        forum = parts[1];
    } else if (0 == strcmp(cmd, "JOIN")) {
        if (0 == nparts) {
            forum = text;
            text = NULL;
        } else {
            forum = parts[1];
        }
    } else if (0 == strcmp(cmd, "INVITE")) {
        forum = text?text:parts[2];
        text = NULL;
    } else if (0 == strcmp(cmd, "NICK")) {
        sender = parts[1];
        forum = sender;
    } else if (0 == strcmp(cmd, "PING")) {
        printf("PONG :%s\r\n", text);
        fflush(stdout);
    }

    {
        int   _argc;
        char *_argv[MAX_ARGS + 1];

        maybe_setenv("handler", handler);
        maybe_setenv("prefix", prefix);
        maybe_setenv("command", cmd);
        maybe_setenv("sender", sender);
        maybe_setenv("forum", forum);
        maybe_setenv("text", text);

        _argc = 0;
        _argv[_argc++] = handler;
        for (i = 1; (i < nparts) && (_argc < MAX_ARGS); i += 1) {
            _argv[_argc++] = parts[i];
        }
        _argv[_argc] = NULL;

        execvp(handler, _argv);
        perror(handler);
    }
}

void
unblock(int fd)
{
    int flags = fcntl(fd, F_GETFL, 0);

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

FILE *subprocs[MAX_SUBPROCS] = { 0 };

void
sigchld(int signum)
{
    while (0 < waitpid(-1, NULL, WNOHANG));
}


void
dispatch(char *text)
{
    int subout[2];
    int i;

    for (i = 0; i < MAX_SUBPROCS; i += 1) {
        if (NULL == subprocs[i]) {
            break;
        }
    }

    if (MAX_SUBPROCS == i) {
        fprintf(stderr, "warning: dropping message (too many children)\n");
        return;
    }

    if (-1 == pipe(subout)) {
        perror("pipe");
        return;
    }

    subprocs[i] = fdopen(subout[0], "r");
    if (! subprocs[i]) {
        close(subout[0]);
        close(subout[1]);
        perror("fdopen");
        return;
    }

    if (0 == fork()) {
        /*
         * Child 
         */
        int null;

        if ((-1 == (null = open("/dev/null", O_RDONLY))) ||
                (-1 == dup2(null, 0)) ||
                (-1 == dup2(subout[1], 1))) {
            perror("fd setup");
            exit(EX_OSERR);
        }

        /*
         * We'll be a good citizen and only close file descriptors we opened. 
         */
        close(null);
        close(subout[1]);
        for (i = 0; i < MAX_SUBPROCS; i += 1) {
            if (subprocs[i]) {
                fclose(subprocs[i]);
            }
        }

        irc_filter(text);
        exit(0);
    }

    unblock(subout[0]);
    close(subout[1]);
}

void
delay_output()
{
    struct timeval now;
    struct timeval diff;
    static struct timeval output_last = { 0 };

    gettimeofday(&now, NULL);
    timersub(&now, &output_last, &diff);
    if (timercmp(&diff, &output_interval, <)) {
        struct timeval delay;
        struct timespec ts;
        int ret;

        timersub(&output_interval, &diff, &delay);

        ts.tv_sec = (time_t) delay.tv_sec;
        ts.tv_nsec = (long) (delay.tv_usec * 1000);
        do {
            ret = nanosleep(&ts, &ts);
        } while ((-1 == ret) && (EINTR == errno));
        gettimeofday(&output_last, NULL);
    } else {
        output_last = now;
    }
}


/** Writes all of buf to stdout, possibly blocking. */
void
output(char *buf)
{
    if (timerisset(&output_interval)) {
        delay_output();
    }

    puts(buf);
}

void
handle_file(FILE *f, void (*func) (char *))
{
    char line[2048];
    size_t linelen;

    // Read a line.  If we didn't have enough space, drop it.
    while (fgets(line, sizeof line, f)) {
        linelen = strlen(line);
        if (line[linelen-1] != '\n') {
            fprintf(stderr, "warning: dropping %u bytes (no trailing newline)\n", (unsigned int)linelen);
        } else {
            line[linelen-1] = '\0';
            func(line);
        }
    }
}

void
handle_input()
{
    handle_file(stdin, dispatch);
    if (feof(stdin)) {
        running = false;
    }
}

void
handle_subproc(FILE *s)
{
    handle_file(s, output);
}

void
loop()
{
    int i;
    int ret;
    int nfds = 0;
    fd_set rfds;
    static time_t last_pulse = 0;
    time_t now;

    // Look for messages in msgdir
    if (msgdir) {
        DIR *d = opendir(msgdir);

        while (d) {
            struct dirent *ent = readdir(d);

            if (! ent) {
                break;
            }
            if (ent->d_type == DT_REG) {
                char fn[PATH_MAX];
                FILE *f;

                snprintf(fn, sizeof fn, "%s/%s", msgdir, ent->d_name);
                f = fopen(fn, "r");
                if (f) {
                    // This one is blocking
                    handle_subproc(f);
                    fclose(f);
                    remove(fn);
                }
            }
        }

        if (d) {
            closedir(d);
        }
    }

    // Check subprocs for input
    FD_ZERO(&rfds);
    FD_SET(0, &rfds);
    for (i = 0; i < MAX_SUBPROCS; i += 1) {
        if (subprocs[i]) {
            int fd = fileno(subprocs[i]);

            FD_SET(fd, &rfds);
            nfds = max(nfds, fd);
        }
    }

    do {
        struct timeval timeout = {1, 0};

        ret = select(nfds + 1, &rfds, NULL, NULL, &timeout);
    } while ((-1 == ret) && (EINTR == errno));
    if (-1 == ret) {
        perror("select");
        exit(EX_IOERR);
    }


    if (FD_ISSET(0, &rfds)) {
        handle_input();
    }

    for (i = 0; i < MAX_SUBPROCS; i += 1) {
        FILE *f = subprocs[i];

        if (f && FD_ISSET(fileno(f), &rfds)) {
            handle_subproc(f);
            if (feof(f)) {
                fclose(f);
                subprocs[i] = NULL;
            }
        }
    }

    // Heartbeat
    now = time(NULL);
    if (now - last_pulse > 5) {
        last_pulse = now;
        dispatch("PULSE");
    }
}


void
usage(char *self)
{
    fprintf(stderr, "Usage: %s [OPTIONS] HANDLER\n", self);
    fprintf(stderr, "\n");
    fprintf(stderr, "-h           Display help.\n");
    fprintf(stderr, "-d DIR       Also dispatch messages from DIR, one per file.\n");
    fprintf(stderr, "-i INTERVAL  Wait at least INTERVAL microseconds between\n");
    fprintf(stderr, "             sending each line.\n");
}

int
main(int argc, char *argv[])
{
    /*
     * Parse command line 
     */
    while (!handler) {
        switch (getopt(argc, argv, "hd:i:")) {
            case -1:
                if (optind >= argc) {
                    fprintf(stderr, "error: must specify event handler.\n");
                    usage(argv[0]);
                    return EX_USAGE;
                }
                handler = argv[optind];
                break;
            case 'd':
                msgdir = optarg;
                break;
            case 'i':
                {
                    char *end;
                    long long int interval;

                    interval = strtoll(optarg, &end, 10);
                    if (*end) {
                        fprintf(stderr, "error: not an integer number: %s\n", optarg);
                        return EX_USAGE;
                    }
                    output_interval.tv_sec = interval / 1000000;
                    output_interval.tv_usec = interval % 1000000;
                }
                break;
            case 'h':
                usage(argv[0]);
                return 0;
            default:
                fprintf(stderr, "error: unknown option.\n");
                usage(argv[0]);
                return EX_USAGE;
        }
    }

    /*
     * tcpclient uses fds 6 and 7.  If these aren't open, we keep the
     * original fds 0 and 1. 
     */
    if (-1 != dup2(6, 0)) {
        close(6);
    }
    if (-1 != dup2(7, 1)) {
        close(7);
    }

    unblock(0);
    setvbuf(stdout, NULL, _IOLBF, 0);

    signal(SIGCHLD, sigchld);

    // Let handler know we're starting up
    dispatch("_INIT_");

    while (running) {
        loop();
    }

    // Let handler know we're shutting down
    dispatch("_END_");

    return 0;
}