#include "exec.h"
#include "main.h"

#define CHILD_BUF_SIZE 1024

struct process_info {
    pid_t pid;
    int killed;
    int child_pipe;
    process_exit_cb_t *cb;
    void *user;
    struct process_info *next;

    char *read_buf;
    size_t read_buf_size;
};

static struct process_info *procs = NULL;

static struct process_info *find_process(pid_t pid) {
    struct process_info *p = procs;

    while (p) {
        if (p->pid == pid)
            return p;

        p = p->next;
    }

    return NULL;
}

static void *oop_read_cb(oop_source *source, int fd, oop_event event, void *user);

static void close_child_pipe(struct process_info *p) {
    assert(p);

    if (p->read_buf_len && p->read_buf) {
        *(p->read_buf + p->read_buf_len) = 0;
        daemon_log(LOG_INFO, "child(%lu): %s", (unsigned long) p->pid, p->read_buf);
        p->read_buf_len = 0;
    }
    
    if (p->child_pipe >= 0) {
        assert(event_source && event_source->cancel_fd);
        event_source->cancel_fd(event_source, p->child_pipe, OOP_READ, oop_read_cb, p);
        close(p->child_pipe);
        p->child_pipe = -1;
    }
}
    

static void free_process_info(struct process_info *p) {
    assert (p);
    close_child_pipe(p);

    if (p->read_buf)
        free(p->read_buf);
    free(p);
}

static void remove_process(pid_t pid) {
    struct process_info *p;

    if (!procs)
        return;

    if (procs->pid == pid) {
        p = procs;
        procs = procs->next;
        free(p);
        return;
    }

    p = procs;
    while (p->next) {
        if (p->next->pid == pid) {
            struct process_info *r;
            r = p->next;
            p->next = p->next->next;
            free_process_info(r);
        }
        p = p->next;
    }

    return;
}

static void *oop_sigchld_cb(oop_source *source, int sig, void *user) {
    pid_t pid;
    int status;
    struct process_info *p;
    assert(source && sig == SIGCHLD);

    if ((pid = wait(&status)) <= 0) {
        daemon_log(LOG_ERR, "wait() failed: %s", strerror(errno));
        return OOP_HALT;
    }

    if (!(p = find_process_by_pid(pid))) {
        daemon_log(LOG_WARN, "Got SIGCHLD for unknown process, reaping");
        return OOP_CONTINUE;
    }

    assert(p && p->cb);

    if (!p->killed)
        p->cb(pid, status, p->user);

    remove_process(pid);
    
    return OOP_CONTINUE;
}


static void *oop_read_cb(oop_source *source, int fd, oop_event event, void *user) {
    struct process_info *p;
    ssize_t s;
    char *c, *b, *start;
    size_t i;
    assert(source && event == OOP_READ);

    p = (struct process_info*) user;
    assert(p && p->child_pipe == fd && fd >= 0);
    
    if (!p->read_buf) {
        p->read_buf = malloc(CHILD_BUF_SIZE);
        p->read_buf_len = 0;
    }
    
    assert(p->read_buf);

    start = p->read_buf+p->read_buf_len;
    if ((s = read(p->child_pipe, start, CHILD_BUF_SIZE-p->read_buf_len-1)) < 0) {
        daemon_log(LOG_ERR, "Failed to read from child pipe: %s", strerror(errno));
        return OOP_HALT;
    }

    if (s == 0) { /* EOF */
        close_child_pipe(p);
        return OOP_CONTINUE;
    }

    /* Escape */
    for (c = start, i = 0; i < s; i++, c++)
        if (*c < 32 || *c == 127)
            *c = '.';


    p->read_buf_len += s;
    
    for (c = b = p->read_buf, i = 0; i < p->read_buf_len; i++, c++) {
        if (*c == '\r' || *c == '\n') {
            if (c > b) {
                *c = 0;
                daemon_log(LOG_INFO, "child: %s", b);
            }
            b = c+1;
        }
    }

    if (b != p->read_buf) 
        memcpy(p->read_buf, b, p->read_buf_len = c-b);

    return OOP_CONTINUE;
}


pid_t child_process_create(const char *file, char *const argv[], process_exit_cb_t cb, void*user) {
    pid_t pid;
    int fds[2];

    if (pipe(fds) < 0) {
        daemon_log(LOG_ERR, "pipe() failed: %s", strerror(errno));
        return -1;
    }

    if ((pid = fork()) < 0) {
        daemon_log(LOG_ERR, "fork() failed: %s", strerror(errno));
        close(fds[0]);
        close(fds[1]);
        return -1;
    }

    if (pid) {
        /* parent */

        struct process_info *p = malloc(sizeof(struct process_info));
        assert(p);
        memset(p, 0, sizeof(struct process_info));
        
        p->pid = pid;
        p->cb = cb;
        p->user = user;
        p->next = procs;
        p->killed = 0;

        p->client_pipe = fds[0];
        close(fds[1]);

        assert(event_source && event_source->on_fd);
        event_source->on_fd(event_source, p->client_pipe, oop_read_cb, p);

        procs = p;
        
        return pid;

    } else {
        /* child */

        int fd;

        close(fds[0]);
        for (fd = 0; fd <= 2; fd++) {
            if (fd != fds[1])
                close(fd);
        }

        if ((fds[1] != 1 && dup2(fds[1], 1) < 0) ||
            (fds[1] != 2 && dup2(fds[1], 2) < 0)) {
            daemon_log(LOG_ERR, "dup2() failed: %s", strerror(errno));
            exit(1);
        }

        if (fds[1] != 1 && fds[1] != 2)
            close(fds[1]);

        if (open("/dev/null", O_RDONLY) != 0) {
            daemon_log(LOG_ERR, "open(\"/dev/null\") failed: %s", strerror(errno));
            exit(1);
        }
            
        execv(file, argv);
        daemon_log(LOG_ERR, "exec() failed: %s", strerror(errno));
        exit(1);
    }
}



int child_process_init(void) {
    assert(!procs);
    assert(event_source && event_source->on_signal);
    event_source->on_signal(event_source, SIGCHLD, oop_sigchld_cb, NULL);
    return 0;
}

void child_process_done(void) {
    assert(event_source && event_source->cancel_signal);
    event_source->cancel_signal(event_source, SIGCHLD, oop_sigchld_cb, NULL);

    while (procs) {
        struct process_info *p = procs;
        procs = procs->next;
        free_process_info(p);
    }
}


int child_process_kill(pid_t pid) {
    struct process_info *p = find_process(pid);
    assert (p);

    if (kill(p->pid, SIGTERM) < 0 && errno != ESRCH) {
        daemon_log(LOG_ERR, "Failed to kill() process: %s", strerror(errno));
        return -1;
    }

    p->killed = 1;
    return 0;
}