/*
 * Copyright 2004-2010, Haiku. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Copyright 2002, Travis Geiselbrecht. All rights reserved.
 * Distributed under the terms of the NewOS License.
 */


#include <ctype.h>
#include <dirent.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>

#include <FindDirectory.h>
#include <image.h>
#include <InterfaceDefs.h>
#include <OS.h>

#include <keyboard_mouse_driver.h>
#include <Keymap.h>


struct console;

struct keyboard {
        struct keyboard*        next;
        int                                     device;
        int                                     target;
        thread_id                       thread;
};

struct console {
        int                                     console_fd;
        thread_id                       console_writer;

        struct keyboard*        keyboards;

        int                                     tty_master_fd;
        int                                     tty_slave_fd;
        int                                     tty_num;
};


struct console gConsole;


void
error(const char* message, ...)
{
        char buffer[2048];

        va_list args;
        va_start(args, message);

        vsnprintf(buffer, sizeof(buffer), message, args);

        va_end(args);

        // put it out on stderr as well as to serial/syslog
        fputs(buffer, stderr);
        debug_printf("%s", buffer);
}


void
update_leds(int fd, uint32 modifiers)
{
        char lockIO[3] = {0, 0, 0};

        if ((modifiers & B_NUM_LOCK) != 0)
                lockIO[0] = 1;
        if ((modifiers & B_CAPS_LOCK) != 0)
                lockIO[1] = 1;
        if ((modifiers & B_SCROLL_LOCK) != 0)
                lockIO[2] = 1;

        ioctl(fd, KB_SET_LEDS, &lockIO, sizeof(lockIO));
}


static int32
keyboard_reader(void* arg)
{
        struct keyboard* keyboard = (struct keyboard*)arg;
        uint8 activeDeadKey = 0;
        uint32 modifiers = 0;

        BKeymap keymap;
        // Load current keymap from disk (we can't talk to the input server)
        // TODO: find a better way (we shouldn't have to care about the on-disk
        // location)
        char path[PATH_MAX];
        status_t status = find_directory(B_USER_SETTINGS_DIRECTORY, -1, false,
                path, sizeof(path));
        if (status == B_OK) {
                strlcat(path, "/Key_map", sizeof(path));
                status = keymap.SetTo(path);
        }
        if (status != B_OK)
                keymap.SetToDefault();

        for (;;) {
                raw_key_info rawKeyInfo;
                if (ioctl(keyboard->device, KB_READ, &rawKeyInfo,
                                sizeof(rawKeyInfo)) != 0)
                        break;

                uint32 keycode = rawKeyInfo.keycode;
                bool isKeyDown = rawKeyInfo.is_keydown;

                if (keycode == 0)
                        continue;

                uint32 changedModifiers = keymap.Modifier(keycode);
                bool isLock = (changedModifiers
                        & (B_CAPS_LOCK | B_NUM_LOCK | B_SCROLL_LOCK)) != 0;
                if (changedModifiers != 0 && (!isLock || isKeyDown)) {
                        uint32 oldModifiers = modifiers;

                        if ((isKeyDown && !isLock)
                                || (isKeyDown && !(modifiers & changedModifiers)))
                                modifiers |= changedModifiers;
                        else {
                                modifiers &= ~changedModifiers;

                                // ensure that we don't clear a combined B_*_KEY when still
                                // one of the individual B_{LEFT|RIGHT}_*_KEY is pressed
                                if (modifiers & (B_LEFT_SHIFT_KEY | B_RIGHT_SHIFT_KEY))
                                        modifiers |= B_SHIFT_KEY;
                                if (modifiers & (B_LEFT_COMMAND_KEY | B_RIGHT_COMMAND_KEY))
                                        modifiers |= B_COMMAND_KEY;
                                if (modifiers & (B_LEFT_CONTROL_KEY | B_RIGHT_CONTROL_KEY))
                                        modifiers |= B_CONTROL_KEY;
                                if (modifiers & (B_LEFT_OPTION_KEY | B_RIGHT_OPTION_KEY))
                                        modifiers |= B_OPTION_KEY;
                        }

                        if (modifiers != oldModifiers) {
                                if (isLock)
                                        update_leds(keyboard->device, modifiers);
                        }
                }

                uint8 newDeadKey = 0;
                if (activeDeadKey == 0 || !isKeyDown)
                        newDeadKey = keymap.ActiveDeadKey(keycode, modifiers);

                char* string = NULL;
                int32 numBytes = 0;
                if (newDeadKey == 0 && isKeyDown) {
                        keymap.GetChars(keycode, modifiers, activeDeadKey, &string,
                                &numBytes);
                        if (numBytes > 0)
                                write(keyboard->target, string, numBytes);

                        delete[] string;
                }

                if (newDeadKey == 0) {
                        if (isKeyDown && !modifiers && activeDeadKey != 0) {
                                // a dead key was completed
                                activeDeadKey = 0;
                        }
                } else if (isKeyDown) {
                        // start of a dead key
                        activeDeadKey = newDeadKey;
                }
        }

        return 0;
}


static int32
console_writer(void* arg)
{
        struct console* con = (struct console*)arg;

        for (;;) {
                char buffer[1024];
                ssize_t length = read(con->tty_master_fd, buffer, sizeof(buffer));
                if (length < 0)
                        break;

                write(con->console_fd, buffer, length);
        }

        return 0;
}


static void
stop_keyboards(struct console* con)
{
        // close devices

        for (struct keyboard* keyboard = con->keyboards; keyboard != NULL;
                        keyboard = keyboard->next) {
                close(keyboard->device);
        }

        // wait for the threads

        for (struct keyboard* keyboard = con->keyboards; keyboard != NULL;) {
                struct keyboard* next = keyboard->next;
                wait_for_thread(keyboard->thread, NULL);

                delete keyboard;
                keyboard = next;
        }

        con->keyboards = NULL;
}


/*!     Opens the all keyboard drivers it finds starting from the given
        location \a start that support the debugger extension.
*/
static struct keyboard*
open_keyboards(int target, const char* start, struct keyboard* previous)
{
        // Wait for the directory to appear, if we're loaded early in boot
        // it may take a while for it to appear while the drivers load.
        DIR* dir;
        int32 tries = 0;
        while (true) {
                dir = opendir(start);
                if (dir != NULL)
                        break;
                if(++tries == 10)
                        return NULL;
                sleep(1);
        }

        struct keyboard* keyboard = previous;

        while (true) {
                dirent* entry = readdir(dir);
                if (entry == NULL)
                        break;
                if (!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, ".."))
                        continue;

                char path[PATH_MAX];
                strlcpy(path, start, sizeof(path));
                strlcat(path, "/", sizeof(path));
                strlcat(path, entry->d_name, sizeof(path));

                struct stat stat;
                if (::stat(path, &stat) != 0)
                        continue;

                if (S_ISDIR(stat.st_mode)) {
                        keyboard = open_keyboards(target, path, keyboard);
                        continue;
                }

                // Try to open it as a device
                int fd = open(path, O_RDONLY);
                if (fd >= 0) {
                        // Turn on debugger mode
                        if (ioctl(fd, KB_SET_DEBUG_READER, NULL, 0) == 0) {
                                keyboard = new ::keyboard();
                                keyboard->device = fd;
                                keyboard->target = target;
                                keyboard->thread = spawn_thread(&keyboard_reader, path,
                                        B_URGENT_DISPLAY_PRIORITY, keyboard);
                                if (keyboard->thread < 0) {
                                        close(fd);
                                        closedir(dir);
                                        delete keyboard;
                                        return NULL;
                                }

                                if (previous != NULL)
                                        previous->next = keyboard;

                                resume_thread(keyboard->thread);
                        } else
                                close(fd);
                }
        }

        closedir(dir);
        return keyboard;
}


static int
start_console(struct console* con)
{
        memset(con, 0, sizeof(struct console));
        con->console_fd = -1;
        con->tty_master_fd = -1;
        con->tty_slave_fd = -1;
        con->console_writer = -1;

        con->console_fd = open("/dev/console", O_WRONLY);
        if (con->console_fd < 0)
                return -2;

        DIR* dir = opendir("/dev/pt");
        if (dir != NULL) {
                struct dirent* entry;
                char name[64];

                while ((entry = readdir(dir)) != NULL) {
                        if (entry->d_name[0] == '.')
                                continue;

                        snprintf(name, sizeof(name), "/dev/pt/%s", entry->d_name);

                        con->tty_master_fd = open(name, O_RDWR);
                        if (con->tty_master_fd >= 0) {
                                snprintf(name, sizeof(name), "/dev/tt/%s", entry->d_name);

                                con->tty_slave_fd = open(name, O_RDWR);
                                if (con->tty_slave_fd < 0) {
                                        error("Could not open tty %s: %s!\n", name,
                                                strerror(errno));
                                        close(con->tty_master_fd);
                                } else {
                                        // set default mode
                                        struct termios termios;
                                        struct winsize size;

                                        if (tcgetattr(con->tty_slave_fd, &termios) == 0) {
                                                termios.c_iflag = ICRNL;
                                                termios.c_oflag = OPOST | ONLCR;
                                                termios.c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHONL;

                                                tcsetattr(con->tty_slave_fd, TCSANOW, &termios);
                                        }

                                        if (ioctl(con->console_fd, TIOCGWINSZ, &size,
                                                        sizeof(struct winsize)) == 0) {
                                                // we got the window size from the console
                                                ioctl(con->tty_slave_fd, TIOCSWINSZ, &size,
                                                        sizeof(struct winsize));
                                        }
                                }
                                break;
                        }
                }

                setenv("TTY", name, true);
        }

        if (con->tty_master_fd < 0 || con->tty_slave_fd < 0)
                return -3;

        con->keyboards
                = open_keyboards(con->tty_master_fd, "/dev/input/keyboard", NULL);
        if (con->keyboards == NULL)
                return -4;

        con->console_writer = spawn_thread(&console_writer, "console writer",
                B_URGENT_DISPLAY_PRIORITY, con);
        if (con->console_writer < 0)
                return -5;

        resume_thread(con->console_writer);
        setenv("TERM", "xterm", true);

        return 0;
}


static void
stop_console(struct console* con)
{
        // close TTY FDs; this will also unblock the threads
        close(con->tty_master_fd);
        close(con->tty_slave_fd);

        // close console and keyboards
        close(con->console_fd);
        wait_for_thread(con->console_writer, NULL);

        stop_keyboards(con);
}


static pid_t
start_process(int argc, const char** argv, struct console* con)
{
        int savedInput = dup(0);
        int savedOutput = dup(1);
        int savedError = dup(2);

        dup2(con->tty_slave_fd, 0);
        dup2(con->tty_slave_fd, 1);
        dup2(con->tty_slave_fd, 2);

        pid_t pid = load_image(argc, argv, (const char**)environ);
        resume_thread(pid);
        setpgid(pid, 0);
        tcsetpgrp(con->tty_slave_fd, pid);

        dup2(savedInput, 0);
        dup2(savedOutput, 1);
        dup2(savedError, 2);
        close(savedInput);
        close(savedOutput);
        close(savedError);

        return pid;
}


int
main(int argc, char** argv)
{
        // we're a session leader
        setsid();

        int err = start_console(&gConsole);
        if (err < 0) {
                error("consoled: error %d starting console.\n", err);
                return err;
        }

        // move our stdin and stdout to the console
        dup2(gConsole.tty_slave_fd, 0);
        dup2(gConsole.tty_slave_fd, 1);
        dup2(gConsole.tty_slave_fd, 2);

        if (argc > 1) {
                // a command was given: we run it only once

                // get the command argument vector
                int commandArgc = argc - 1;
                const char** commandArgv = new const char*[commandArgc + 1];
                for (int i = 0; i < commandArgc; i++)
                        commandArgv[i] = argv[i + 1];

                commandArgv[commandArgc] = NULL;

                // start the process
                pid_t process = start_process(commandArgc, commandArgv, &gConsole);

                status_t returnCode;
                wait_for_thread(process, &returnCode);
        } else {
                // no command given: start a shell in an endless loop
                for (;;) {
                        pid_t shellProcess;
                        status_t returnCode;
                        const char* shellArgv[] = { "/bin/sh", "--login", NULL };

                        shellProcess = start_process(2, shellArgv, &gConsole);

                        wait_for_thread(shellProcess, &returnCode);

                        puts("Restart shell");
                }
        }

        stop_console(&gConsole);

        return 0;
}