/* Copyright (c) 2018, Curtis McEnroe <programble@gmail.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <sys/types.h>

#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <signal.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/event.h>
#include <sys/ioctl.h>
#include <sysexits.h>
#include <termios.h>
#include <unistd.h>

static struct termios saveTerm;
static void restoreTerm(void) {
    tcsetattr(STDOUT_FILENO, TCSADRAIN, &saveTerm);
}

static struct {
    int read;
    int write;
} winch;

static void sigwinch() {
    struct winsize localWindow;
    int error = ioctl(STDERR_FILENO, TIOCGWINSZ, &localWindow);
    if (error) err(EX_IOERR, "ioctl(%d, TIOCGWINSZ, ...)", STDERR_FILENO);

    ssize_t size = write(winch.write, &localWindow, sizeof(localWindow));
    if (size < 0) err(EX_IOERR, "write(%d)", winch.write);
    if ((size_t)size < sizeof(localWindow)) {
        errx(EX_IOERR, "short write(%d)", winch.write);
    }
}

static struct winsize remoteWindow;
static void readRemoteWindow(int remote) {
    ssize_t size = read(remote, &remoteWindow, sizeof(remoteWindow));
    if (size < 0) err(EX_IOERR, "read(%d)", remote);
    if ((size_t)size < sizeof(remoteWindow)) errx(EX_IOERR, "short read(%d)", remote);
}

int main(int argc, char *argv[]) {
    int error;

    if (argc < 2) return EX_USAGE;
    const char *path = argv[1];

    int input = STDIN_FILENO;
    int local = STDOUT_FILENO;

    error = tcgetattr(local, &saveTerm);
    if (error) err(EX_IOERR, "tcgetattr");
    atexit(restoreTerm);

    struct termios term = saveTerm;
    term.c_lflag &= ~(ICANON | ECHO);
    error = tcsetattr(local, TCSADRAIN, &term);
    if (error) err(EX_IOERR, "tcsetattr");

    error = pipe((int *)&winch);
    if (error) err(EX_OSERR, "pipe");
    signal(SIGWINCH, sigwinch);
    sigwinch();

    int remote = open(path, O_RDONLY);
    if (remote < 0) err(EX_NOINPUT, "%s", path);
    readRemoteWindow(remote);

    int kq = kqueue();
    if (kq < 0) err(EX_OSERR, "kqueue");

    struct kevent events[3] = {
        { .ident = winch.read, .filter = EVFILT_READ, .flags = EV_ADD },
        { .ident = input, .filter = EVFILT_READ, .flags = EV_ADD },
        { .ident = remote, .filter = EVFILT_READ, .flags = EV_ADD },
    };
    int nevents = kevent(kq, events, 3, NULL, 0, NULL);
    if (nevents < 0) err(EX_OSERR, "kevent");

    char buf[4096];
    bool truncated = false;
    for (;;) {
        struct kevent event;
        int nevents = kevent(kq, NULL, 0, &event, 1, NULL);
        if (nevents < 0) {
            if (errno == EINTR) continue;
            err(EX_OSERR, "kevent");
        }
        if (!nevents) continue;

        if (event.ident == (uintptr_t)winch.read) {
            for (;;) {
                struct winsize localWindow;
                ssize_t size = read(winch.read, &localWindow, sizeof(localWindow));
                if (size < 0) err(EX_IOERR, "read(%d)", winch.read);
                if ((size_t)size < sizeof(localWindow)) {
                    errx(EX_IOERR, "short read(%d)", winch.read);
                }

                if (
                    localWindow.ws_col == remoteWindow.ws_col
                    && localWindow.ws_row == remoteWindow.ws_row
                ) break;

                warnx(
                    "Please resize your terminal %hux%hu -> %hux%hu",
                    localWindow.ws_col, localWindow.ws_row,
                    remoteWindow.ws_col, remoteWindow.ws_row
                );
            }
        }

        if (event.ident == (uintptr_t)input) {
            ssize_t size = read(input, buf, sizeof(buf));
            if (size < 0) err(EX_IOERR, "read(%d)", input);
            if (size == 1 && buf[0] == 'q') return EX_OK;
        }

        if (event.ident == (uintptr_t)remote) {
            if (event.data < 0) {
                off_t offset = lseek(remote, 0, SEEK_SET);
                if (offset < 0) err(EX_IOERR, "lseek(%d)", remote);
                truncated = true;
                continue;
            }

            if (truncated) {
                readRemoteWindow(remote);
                sigwinch();
                truncated = false;
                continue;
            }

            ssize_t readSize = read(remote, buf, sizeof(buf));
            if (readSize < 0) err(EX_IOERR, "read(%d)", remote);

            ssize_t writeSize = write(local, buf, readSize);
            if (writeSize < 0) err(EX_IOERR, "write(%d)", local);
            if (writeSize < readSize) errx(EX_IOERR, "short write(%d)", local);
        }
    }
}