/*
 * Copyright 2005-2010, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 *
 * Copyright 2001-2002, Travis Geiselbrecht. All rights reserved.
 * Distributed under the terms of the NewOS License.
 */


#include <Drivers.h>
#include <KernelExport.h>

#include <console.h>
#include <lock.h>

#include <string.h>
#include <stdio.h>
#include <termios.h>


#define DEVICE_NAME "console"

#define TAB_SIZE 8
#define TAB_MASK 7

#define FMASK 0x0f
#define BMASK 0x70

typedef enum {
        CONSOLE_STATE_NORMAL = 0,
        CONSOLE_STATE_GOT_ESCAPE,
        CONSOLE_STATE_SEEN_BRACKET,
        CONSOLE_STATE_NEW_ARG,
        CONSOLE_STATE_PARSING_ARG,
} console_state;

typedef enum {
        SCREEN_ERASE_WHOLE,
        SCREEN_ERASE_UP,
        SCREEN_ERASE_DOWN
} erase_screen_mode;

typedef enum {
        LINE_ERASE_WHOLE,
        LINE_ERASE_LEFT,
        LINE_ERASE_RIGHT
} erase_line_mode;

#define MAX_ARGS 8

static struct console_desc {
        mutex   lock;

        int32   lines;
        int32   columns;

        uint8   attr;
        uint8   saved_attr;
        bool    bright_attr;
        bool    reverse_attr;

        int32   x;                                              /* current x coordinate */
        int32   y;                                              /* current y coordinate */
        int32   saved_x;                                /* used to save x and y */
        int32   saved_y;

        int32   scroll_top;     /* top of the scroll region */
        int32   scroll_bottom;  /* bottom of the scroll region */

        /* state machine */
        console_state state;
        int32   arg_count;
        int32   args[MAX_ARGS];

        char    module_name[B_FILE_NAME_LENGTH];
        console_module_info *module;
} sConsole;

int32 api_version = B_CUR_DRIVER_API_VERSION;

static int32 sOpenMask;


static inline void
update_cursor(struct console_desc *console, int x, int y)
{
        console->module->move_cursor(x, y);
}


static void
gotoxy(struct console_desc *console, int newX, int newY)
{
        if (newX >= console->columns)
                newX = console->columns - 1;
        if (newX < 0)
                newX = 0;
        if (newY >= console->lines)
                newY = console->lines - 1;
        if (newY < 0)
                newY = 0;

        console->x = newX;
        console->y = newY;
}


static void
reset_console(struct console_desc *console)
{
        console->attr = 0x0f;
        console->scroll_top = 0;
        console->scroll_bottom = console->lines - 1;
        console->bright_attr = true;
        console->reverse_attr = false;
}


/*!     Scroll from the cursor line up to the top of the scroll region up one line.
*/
static void
scrup(struct console_desc *console)
{
        // see if cursor is outside of scroll region
        if (console->y < console->scroll_top || console->y > console->scroll_bottom)
                return;

        if (console->y - console->scroll_top > 1) {
                // move the screen up one
                console->module->blit(0, console->scroll_top + 1, console->columns,
                        console->y - console->scroll_top, 0, console->scroll_top);
        }

        // clear the bottom line
        console->module->fill_glyph(0, console->y, console->columns, 1, ' ',
                console->attr);
}


/*!     Scroll from the cursor line down to the bottom of the scroll region down
        one line.
*/
static void
scrdown(struct console_desc *console)
{
        // see if cursor is outside of scroll region
        if (console->y < console->scroll_top || console->y > console->scroll_bottom)
                return;

        if (console->scroll_bottom - console->y > 1) {
                // move the screen down one
                console->module->blit(0, console->y, console->columns,
                        console->scroll_bottom - console->y, 0, console->y + 1);
        }

        // clear the top line
        console->module->fill_glyph(0, console->y, console->columns, 1, ' ',
                console->attr);
}


static void
lf(struct console_desc *console)
{
        //dprintf("lf: y %d x %d scroll_top %d scoll_bottom %d\n", console->y, console->x, console->scroll_top, console->scroll_bottom);

        if (console->y == console->scroll_bottom ) {
                // we hit the bottom of our scroll region
                scrup(console);
        } else if(console->y < console->scroll_bottom) {
                console->y++;
        }
}


static void
rlf(struct console_desc *console)
{
        if (console->y == console->scroll_top) {
                // we hit the top of our scroll region
                scrdown(console);
        } else if (console->y > console->scroll_top) {
                console->y--;
        }
}


static void
cr(struct console_desc *console)
{
        console->x = 0;
}


static void
del(struct console_desc *console)
{
        if (console->x > 0) {
                console->x--;
        } else if (console->y > 0) {
        console->y--;
        console->x = console->columns - 1;
    } else {
        //This doesn't work...
        //scrdown(console);
        //console->y--;
        //console->x = console->columns - 1;
        return;
    }
        console->module->put_glyph(console->x, console->y, ' ', console->attr);
}


static void
erase_line(struct console_desc *console, erase_line_mode mode)
{
        switch (mode) {
                case LINE_ERASE_WHOLE:
                        console->module->fill_glyph(0, console->y, console->columns, 1, ' ',
                                console->attr);
                        break;
                case LINE_ERASE_LEFT:
                        console->module->fill_glyph(0, console->y, console->x + 1, 1, ' ',
                                console->attr);
                        break;
                case LINE_ERASE_RIGHT:
                        console->module->fill_glyph(console->x, console->y,
                                console->columns - console->x, 1, ' ', console->attr);
                        break;
                default:
                        return;
        }
}


static void
erase_screen(struct console_desc *console, erase_screen_mode mode)
{
        switch (mode) {
                case SCREEN_ERASE_WHOLE:
                        console->module->clear(console->attr);
                        break;
                case SCREEN_ERASE_UP:
                        console->module->fill_glyph(0, 0, console->columns, console->y + 1,
                                ' ', console->attr);
                        break;
                case SCREEN_ERASE_DOWN:
                        console->module->fill_glyph(console->y, 0, console->columns,
                                console->lines - console->y, ' ', console->attr);
                        break;
                default:
                        return;
        }
}


static void
save_cur(struct console_desc *console, bool saveAttrs)
{
        console->saved_x = console->x;
        console->saved_y = console->y;

        if (saveAttrs)
                console->saved_attr = console->attr;
}


static void
restore_cur(struct console_desc *console, bool restoreAttrs)
{
        console->x = console->saved_x;
        console->y = console->saved_y;

        if (restoreAttrs)
                console->attr = console->saved_attr;
}


static char
console_putch(struct console_desc *console, const char c)
{
        if (++console->x >= console->columns) {
                cr(console);
                lf(console);
        }
        console->module->put_glyph(console->x - 1, console->y, c, console->attr);
        return c;
}


static void
tab(struct console_desc *console)
{
        console->x = (console->x + TAB_SIZE) & ~TAB_MASK;
        if (console->x >= console->columns) {
                console->x -= console->columns;
                lf(console);
        }
}


static void
set_scroll_region(struct console_desc *console, int top, int bottom)
{
        if (top < 0)
                top = 0;
        if (bottom >= console->lines)
                bottom = console->lines - 1;
        if (top > bottom)
                return;

        console->scroll_top = top;
        console->scroll_bottom = bottom;
}


static void
set_vt100_attributes(struct console_desc *console, int32 *args, int32 argCount)
{
        if (argCount == 0) {
                // that's the default (attributes off)
                argCount++;
                args[0] = 0;
        }

        for (int32 i = 0; i < argCount; i++) {
                //dprintf("set_vt100_attributes: %ld\n", args[i]);
                switch (args[i]) {
                        case 0: // reset
                                console->attr = 0x0f;
                                console->bright_attr = true;
                                console->reverse_attr = false;
                                break;
                        case 1: // bright
                                console->bright_attr = true;
                                console->attr |= 0x08; // set the bright bit
                                break;
                        case 2: // dim
                                console->bright_attr = false;
                                console->attr &= ~0x08; // unset the bright bit
                                break;
                        case 4: // underscore we can't do
                                break;
                        case 5: // blink
                                console->attr |= 0x80; // set the blink bit
                                break;
                        case 7: // reverse
                                console->reverse_attr = true;
                                console->attr = ((console->attr & BMASK) >> 4)
                                        | ((console->attr & FMASK) << 4);
                                if (console->bright_attr)
                                        console->attr |= 0x08;
                                break;
                        case 8: // hidden?
                                break;

                        /* foreground colors */
                        case 30: console->attr = (console->attr & ~FMASK) | 0 | (console->bright_attr ? 0x08 : 0); break; // black
                        case 31: console->attr = (console->attr & ~FMASK) | 4 | (console->bright_attr ? 0x08 : 0); break; // red
                        case 32: console->attr = (console->attr & ~FMASK) | 2 | (console->bright_attr ? 0x08 : 0); break; // green
                        case 33: console->attr = (console->attr & ~FMASK) | 6 | (console->bright_attr ? 0x08 : 0); break; // yellow
                        case 34: console->attr = (console->attr & ~FMASK) | 1 | (console->bright_attr ? 0x08 : 0); break; // blue
                        case 35: console->attr = (console->attr & ~FMASK) | 5 | (console->bright_attr ? 0x08 : 0); break; // magenta
                        case 36: console->attr = (console->attr & ~FMASK) | 3 | (console->bright_attr ? 0x08 : 0); break; // cyan
                        case 37: console->attr = (console->attr & ~FMASK) | 7 | (console->bright_attr ? 0x08 : 0); break; // white

                        /* background colors */
                        case 40: console->attr = (console->attr & ~BMASK) | (0 << 4); break; // black
                        case 41: console->attr = (console->attr & ~BMASK) | (4 << 4); break; // red
                        case 42: console->attr = (console->attr & ~BMASK) | (2 << 4); break; // green
                        case 43: console->attr = (console->attr & ~BMASK) | (6 << 4); break; // yellow
                        case 44: console->attr = (console->attr & ~BMASK) | (1 << 4); break; // blue
                        case 45: console->attr = (console->attr & ~BMASK) | (5 << 4); break; // magenta
                        case 46: console->attr = (console->attr & ~BMASK) | (3 << 4); break; // cyan
                        case 47: console->attr = (console->attr & ~BMASK) | (7 << 4); break; // white
                }
        }
}


static bool
process_vt100_command(struct console_desc *console, const char c,
        bool seenBracket, int32 *args, int32 argCount)
{
        bool ret = true;

        //dprintf("process_vt100_command: c '%c', argCount %ld, arg[0] %ld, arg[1] %ld, seenBracket %d\n",
        //      c, argCount, args[0], args[1], seenBracket);

        if (seenBracket) {
                switch(c) {
                        case 'H': // set cursor position
                        case 'f':
                        {
                                int32 row = argCount > 0 ? args[0] : 1;
                                int32 col = argCount > 1 ? args[1] : 1;
                                if (row > 0)
                                        row--;
                                if (col > 0)
                                        col--;
                                gotoxy(console, col, row);
                                break;
                        }
                        case 'A':       // move up
                        {
                                int32 deltaY = argCount > 0 ? -args[0] : -1;
                                if (deltaY == 0)
                                        deltaY = -1;
                                gotoxy(console, console->x, console->y + deltaY);
                                break;
                        }
                        case 'e':
                        case 'B':       // move down
                        {
                                int32 deltaY = argCount > 0 ? args[0] : 1;
                                if (deltaY == 0)
                                        deltaY = 1;
                                gotoxy(console, console->x, console->y + deltaY);
                                break;
                        }
                        case 'D':       // move left
                        {
                                int32 deltaX = argCount > 0 ? -args[0] : -1;
                                if (deltaX == 0)
                                        deltaX = -1;
                                gotoxy(console, console->x + deltaX, console->y);
                                break;
                        }
                        case 'a':
                        case 'C':       // move right
                        {
                                int32 deltaX = argCount > 0 ? args[0] : 1;
                                if (deltaX == 0)
                                        deltaX = 1;
                                gotoxy(console, console->x + deltaX, console->y);
                                break;
                        }
                        case '`':
                        case 'G':       // set X position
                        {
                                int32 newX = argCount > 0 ? args[0] : 1;
                                if (newX > 0)
                                        newX--;
                                gotoxy(console, newX, console->y);
                                break;
                        }
                        case 'd':       // set y position
                        {
                                int32 newY = argCount > 0 ? args[0] : 1;
                                if (newY > 0)
                                        newY--;
                                gotoxy(console, console->x, newY);
                                break;
                        }
                        case 's':       // save current cursor
                                save_cur(console, false);
                                break;
                        case 'u':       // restore cursor
                                restore_cur(console, false);
                                break;
                        case 'r':       // set scroll region
                        {
                                int32 low = argCount > 0 ? args[0] : 1;
                                int32 high = argCount > 1 ? args[1] : console->lines;
                                if (low <= high)
                                        set_scroll_region(console, low - 1, high - 1);
                                break;
                        }
                        case 'L':       // scroll virtual down at cursor
                        {
                                int32 lines = argCount > 0 ? args[0] : 1;
                                while (lines > 0) {
                                        scrdown(console);
                                        lines--;
                                }
                                break;
                        }
                        case 'M':       // scroll virtual up at cursor
                        {
                                int32 lines = argCount > 0 ? args[0] : 1;
                                while (lines > 0) {
                                        scrup(console);
                                        lines--;
                                }
                                break;
                        }
                        case 'K':
                                if (argCount == 0 || args[0] == 0) {
                                        // erase to end of line
                                        erase_line(console, LINE_ERASE_RIGHT);
                                } else if (argCount > 0) {
                                        if (args[0] == 1)
                                                erase_line(console, LINE_ERASE_LEFT);
                                        else if (args[0] == 2)
                                                erase_line(console, LINE_ERASE_WHOLE);
                                }
                                break;
                        case 'J':
                                if (argCount == 0 || args[0] == 0) {
                                        // erase to end of screen
                                        erase_screen(console, SCREEN_ERASE_DOWN);
                                } else {
                                        if (args[0] == 1)
                                                erase_screen(console, SCREEN_ERASE_UP);
                                        else if (args[0] == 2)
                                                erase_screen(console, SCREEN_ERASE_WHOLE);
                                }
                                break;
                        case 'm':
                                if (argCount >= 0)
                                        set_vt100_attributes(console, args, argCount);
                                break;
                        default:
                                ret = false;
                }
        } else {
                switch (c) {
                        case 'c':
                                reset_console(console);
                                break;
                        case 'D':
                                rlf(console);
                                break;
                        case 'M':
                                lf(console);
                                break;
                        case '7':
                                save_cur(console, true);
                                break;
                        case '8':
                                restore_cur(console, true);
                                break;
                        default:
                                ret = false;
                }
        }

        return ret;
}


static ssize_t
_console_write(struct console_desc *console, const void *buffer, size_t length)
{
        const char *c;
        size_t pos = 0;

        while (pos < length) {
                c = &((const char *)buffer)[pos++];

                switch (console->state) {
                        case CONSOLE_STATE_NORMAL:
                                // just output the stuff
                                switch (*c) {
                                        case '\n':
                                                lf(console);
                                                break;
                                        case '\r':
                                                cr(console);
                                                break;
                                        case 0x8: // backspace
                                                del(console);
                                                break;
                                        case '\t':
                                                tab(console);
                                                break;
                                        case '\a':
                                                // beep
                                                dprintf("<BEEP>\n");
                                                break;
                                        case '\0':
                                                break;
                                        case 0x1b:
                                                // escape character
                                                console->arg_count = 0;
                                                console->state = CONSOLE_STATE_GOT_ESCAPE;
                                                break;
                                        default:
                                                console_putch(console, *c);
                                }
                                break;
                        case CONSOLE_STATE_GOT_ESCAPE:
                                // Look for either commands with no argument, or the '['
                                // character
                                switch (*c) {
                                        case '[':
                                                console->state = CONSOLE_STATE_SEEN_BRACKET;
                                                break;
                                        default:
                                                console->args[0] = 0;
                                                process_vt100_command(console, *c, false, console->args,
                                                        0);
                                                console->state = CONSOLE_STATE_NORMAL;
                                                break;
                                }
                                break;
                        case CONSOLE_STATE_SEEN_BRACKET:
                                switch (*c) {
                                        case '0'...'9':
                                                console->arg_count = 0;
                                                console->args[console->arg_count] = *c - '0';
                                                console->state = CONSOLE_STATE_PARSING_ARG;
                                                break;
                                        case '?':
                                                // Private DEC mode parameter follows - we ignore those
                                                // anyway
                                                // TODO: check if it was really used in combination with
                                                // a mode command
                                                break;
                                        default:
                                                process_vt100_command(console, *c, true, console->args,
                                                        0);
                                                console->state = CONSOLE_STATE_NORMAL;
                                                break;
                                }
                                break;
                        case CONSOLE_STATE_NEW_ARG:
                                switch (*c) {
                                        case '0'...'9':
                                                console->arg_count++;
                                                if (console->arg_count == MAX_ARGS) {
                                                        console->state = CONSOLE_STATE_NORMAL;
                                                        break;
                                                }
                                                console->args[console->arg_count] = *c - '0';
                                                console->state = CONSOLE_STATE_PARSING_ARG;
                                                break;
                                        default:
                                                process_vt100_command(console, *c, true, console->args,
                                                        console->arg_count + 1);
                                                console->state = CONSOLE_STATE_NORMAL;
                                                break;
                                }
                                break;
                        case CONSOLE_STATE_PARSING_ARG:
                                // parse args
                                switch (*c) {
                                        case '0'...'9':
                                                console->args[console->arg_count] *= 10;
                                                console->args[console->arg_count] += *c - '0';
                                                break;
                                        case ';':
                                                console->state = CONSOLE_STATE_NEW_ARG;
                                                break;
                                        default:
                                                process_vt100_command(console, *c, true, console->args,
                                                        console->arg_count + 1);
                                                console->state = CONSOLE_STATE_NORMAL;
                                                break;
                                }
                }
        }

        return pos;
}


//      #pragma mark -


static status_t
console_open(const char *name, uint32 flags, void **cookie)
{
        if (atomic_or(&sOpenMask, 1) == 1)
                return B_BUSY;

        *cookie = &sConsole;

        status_t status = get_module(sConsole.module_name, (module_info **)&sConsole.module);
        if (status == B_OK)
                sConsole.module->clear(0x0f);

        return status;
}


static status_t
console_freecookie(void *cookie)
{
        if (sConsole.module != NULL) {
                put_module(sConsole.module_name);
                sConsole.module = NULL;
        }

        atomic_and(&sOpenMask, ~1);

        return B_OK;
}


static status_t
console_close(void *cookie)
{
//      dprintf("console_close: entry\n");

        return 0;
}


static status_t
console_read(void *cookie, off_t pos, void *buffer, size_t *_length)
{
        return B_NOT_ALLOWED;
}


static status_t
console_write(void *cookie, off_t pos, const void *buffer, size_t *_length)
{
        struct console_desc *console = (struct console_desc *)cookie;
        ssize_t written = 0;
        status_t status = B_OK;

#if 0
{
        const char *input = (const char *)buffer;
        dprintf("console_write (%lu bytes): \"", *_length);
        for (uint32 i = 0; i < *_length; i++) {
                if (input[i] < ' ')
                        dprintf("(%d:0x%x)", input[i], input[i]);
                else
                        dprintf("%c", input[i]);
        }
        dprintf("\"\n");
}
#endif

        mutex_lock(&console->lock);

        update_cursor(console, -1, -1); // hide it

        size_t bytesLeft = *_length;
        const char *str = (const char*)buffer;
        while (bytesLeft > 0) {
                char localBuffer[512];
                size_t chunkSize = min_c(sizeof(localBuffer), bytesLeft);
                if (user_memcpy(localBuffer, str, chunkSize) < B_OK) {
                        status = B_BAD_ADDRESS;
                        break;
                }
                written += _console_write(console, localBuffer, chunkSize);
                str += chunkSize;
                bytesLeft -= chunkSize;
        }
        update_cursor(console, console->x, console->y);

        mutex_unlock(&console->lock);

        if (status == B_OK)
                *_length = written;
        return status;
}


static status_t
console_ioctl(void *cookie, uint32 op, void *buffer, size_t length)
{
        struct console_desc *console = (struct console_desc *)cookie;

        if (op == TIOCGWINSZ) {
                struct winsize size;
                size.ws_xpixel = size.ws_col = console->columns;
                size.ws_ypixel = size.ws_row = console->lines;

                return user_memcpy(buffer, &size, sizeof(struct winsize));
        }

        return B_BAD_VALUE;
}


//      #pragma mark -


status_t
init_hardware(void)
{
        // iterate through the list of console modules until we find one that accepts the job
        void *cookie = open_module_list("console");
        if (cookie == NULL)
                return B_ERROR;

        bool found = false;

        char buffer[B_FILE_NAME_LENGTH];
        size_t bufferSize = sizeof(buffer);

        while (read_next_module_name(cookie, buffer, &bufferSize) == B_OK) {
                dprintf("con_init: trying module %s\n", buffer);
                if (get_module(buffer, (module_info **)&sConsole.module) == B_OK) {
                        strlcpy(sConsole.module_name, buffer, sizeof(sConsole.module_name));
                        put_module(buffer);
                        found = true;
                        break;
                }

                bufferSize = sizeof(buffer);
        }

        if (found) {
                // set up the console structure
                mutex_init(&sConsole.lock, "console lock");
                sConsole.module->get_size(&sConsole.columns, &sConsole.lines);

                reset_console(&sConsole);
                gotoxy(&sConsole, 0, 0);
                save_cur(&sConsole, true);
        }

        close_module_list(cookie);
        return found ? B_OK : B_ERROR;
}


const char **
publish_devices(void)
{
        static const char *devices[] = {
                DEVICE_NAME,
                NULL
        };

        return devices;
}


device_hooks *
find_device(const char *name)
{
        static device_hooks hooks = {
                &console_open,
                &console_close,
                &console_freecookie,
                &console_ioctl,
                &console_read,
                &console_write,
                /* Leave select/deselect/readv/writev undefined. The kernel will
                 * use its own default implementation. The basic hooks above this
                 * line MUST be defined, however. */
                NULL,
                NULL,
                NULL,
                NULL
        };

        if (!strcmp(name, DEVICE_NAME))
                return &hooks;

        return NULL;
}


status_t
init_driver(void)
{
        return B_OK;
}


void
uninit_driver(void)
{
}