#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>

#ifdef HAVE_LIBPNG
#include <setjmp.h>
#include <png.h>
#endif /* HAVE_LIBPNG */

#ifdef HAVE_LIBVNCSERVER
#include <rfb/rfb.h>
#include <rfb/keysym.h>
#endif /* HAVE_LIBVNCSERVER */

#include "dcpu16.h"
#include "chargen-4x8.h"
#include "hw_lem1802.h"

#ifdef DEBUG
#define TRACE(...) do { printf("[debug] "); printf(__VA_ARGS__); printf("\n"); } while (0)
#else /* DEBUG  */
#define TRACE(...) do {} while (0)
#endif /* DEBUG */

static dcpu16_hw_signal_t lem1802_reset_;
static dcpu16_hw_signal_t lem1802_cycle_;
static dcpu16_hw_signal_t lem1802_hwi_;
static struct dcpu16_hw hw_ = {
    .name_  = "LEM1802 - Low Energy Monitor",
    .id_l   = 0xf615,
    .id_h   = 0x7349,
    .ver    = 0x1802,
    .mfg_l  = 0x8b36,
    .mfg_h  = 0x1c6c,
    .hwi    = lem1802_hwi_,
    .cycle  = lem1802_cycle_,
    .reset  = lem1802_reset_,
    .data   = (struct lem1802_ *)NULL
};

#define PIX_X 160       /* pixels in display */
#define PIX_Y 128       /* pixels in display */
#define PIX_BORDER 16   /* border pixels from edge to first tile */
#define CELL_X_SZ 4
#define CELL_Y_SZ 8
#define CELL_X ((PIX_X - (2 * PIX_BORDER)) / CELL_X_SZ) /* tiles in display */
#define CELL_Y ((PIX_Y - (2 * PIX_BORDER)) / CELL_Y_SZ) /* tiles in display */

#define PALETTE_ENTRIES 16
static const DCPU16_WORD palette_default_[PALETTE_ENTRIES] = {
    0x0000, /* black */
    0x000a, /* blue */
    0x00a0, /* green */
    0x00aa, /* cyan */
    0x0a05, /* red */
    0x0a0f, /* magenta */
    0x0aa5, /* yellow */
    0x0aaf, /* pale blue */
    0x0555, /* grey */
    0x055f, /* light blue */
    0x05f5, /* light green*/
    0x05ff, /* light cyan */
    0x0f55, /* light red */
    0x0f5f, /* light magenta */
    0x0ff5, /* light yellow */
    0x0fff, /* white */
};

struct pixel_ {
    unsigned char r;
    unsigned char g;
    unsigned char b;
    unsigned char a;
};

struct lem1802_ {
    long long cycle_activated; /* for tracking 'turn on delay' */

    DCPU16_WORD video_base;
    DCPU16_WORD font_base;
    DCPU16_WORD palette_base;
    DCPU16_WORD border_color;
    struct pixel_ *pixbuf;

    unsigned int refresh_rate; /* redraw every n cycles */
    unsigned int refresh_tally_; /* tick */
    
    unsigned int blink_rate; /* toggle every n cycles? still figuring this out.. */
    unsigned int blink_tally_; /* tick */
    unsigned int blink_state;

    int (*render)(void *, struct pixel_ *, size_t, size_t);
    void *renderer_data;
};

static inline
void pixel_color_(struct pixel_ *pix, DCPU16_WORD color) {
    pix->r = (color & 0x000f) | ((color & 0x000f) << 8);
    pix->g = ((color & 0x00f0) >> 8) | (color & 0x00f0);
    pix->b = ((color & 0x0f00) >> 8) | ((color & 0x0f00) >> 16);
    pix->a = ((color & 0xf000) >> 16) | ((color & 0xf000) >> 24);
}

static
void pixbuf_border_paint_(struct pixel_ *pixbuf, struct pixel_ *border) {
    size_t x, y, i;

    TRACE("%s>> painted border", __func__);

    /* top */
    for (y = 0; y < PIX_BORDER; y++) {
        for (x = 0; x < PIX_X; x++) {
            i = (y * PIX_X) + x;
            pixbuf[i] = *border;
            i = ((PIX_Y - y) * PIX_X) + x;
            pixbuf[i] = *border;
        }
    }

    /* sides */
    for (y = PIX_BORDER; y < (PIX_Y - PIX_BORDER + 1); y++)
        for (x = 0; x < PIX_BORDER; x++) {
            i = (y * PIX_X) + x;
            pixbuf[i] = *border;
            pixbuf[i + (PIX_X - PIX_BORDER)] = *border;
        }
}

static
void font_tile_paint_(struct pixel_ *p, struct pixel_ *fg, struct pixel_ *bg, DCPU16_WORD *tile) {
    size_t pix_x, pix_y;
    unsigned char *font_bitmap = (unsigned char *)tile;

    TRACE("%s>> fg:(%u,%u,%u) bg:(%u,%u,%u) font_bitmap:%02x %02x %02x %02x", __func__,
          fg->r, fg->g, fg->b,
          bg->r, bg->g, bg->b,
          font_bitmap[0], font_bitmap[1], font_bitmap[2], font_bitmap[3]);

    for (pix_x = 0; pix_x < CELL_X_SZ; pix_x++) {
        for (pix_y = 0; pix_y < CELL_Y_SZ; pix_y++) {
            if ((font_bitmap[pix_x] >> pix_y) & 0x01)
                p[((CELL_Y_SZ - pix_y - 1) * PIX_X) + pix_x] = *fg;
            else
                p[((CELL_Y_SZ - pix_y - 1) * PIX_X) + pix_x] = *bg;
        }
    }
}

static
void pixbuf_addr_paint_(struct pixel_ *pixbuf, DCPU16_WORD *mem, DCPU16_WORD base, DCPU16_WORD addr, DCPU16_WORD *palette, DCPU16_WORD *tiles, unsigned int blink_state) {
    struct pixel_ *tilestart = pixbuf; /* start of display */
    unsigned int cell_x = addr % (PIX_X / CELL_X_SZ),
                 cell_y = addr / (PIX_X / CELL_X_SZ);
    struct pixel_ fg, bg;
    DCPU16_WORD *font_bitmap;
    int blink;

    cell_x = (addr - base) % CELL_X;
    cell_y = (addr - base) / CELL_X;

    TRACE("%s>> addr:0x%04x col:%u row:%u v:%hu",
          __func__,
          addr,
          cell_x, cell_y, mem[addr]);

    blink = mem[addr] & 0x0080;

    /* tiles take two words each */
    font_bitmap = tiles + (2 * (mem[addr] & 0x7f));

    pixel_color_(&bg, palette[(mem[addr] >> 8) & 0x0f]);
    if (blink && blink_state)
        pixel_color_(&fg, palette[(mem[addr] >> 8) & 0x0f]);
    else
        pixel_color_(&fg, palette[(mem[addr] >> 12) & 0x0f]);

    tilestart += (PIX_X * PIX_BORDER); /* skip top border */
    tilestart += (CELL_Y_SZ * PIX_X) * cell_y; /* skip down to row */

    tilestart += PIX_BORDER; /* skip side border */
    tilestart += (CELL_X_SZ) * cell_x; /* skip to column */

    font_tile_paint_(tilestart, &fg, &bg, font_bitmap);
}

static
void lem1802_pixbuf_refresh_full_(struct lem1802_ *display, DCPU16_WORD *mem) {
    struct pixel_ border;
    size_t tile;

    TRACE("%s>> video_base:0x%04x", __func__, display->video_base);

    if (display->video_base == 0) {
        /* disconnected, blank display.  static might be fun, too */
        memset(display->pixbuf, 0, PIX_X * PIX_Y * sizeof *display->pixbuf);
        return;
    }

    pixel_color_(&border, display->border_color);
    pixbuf_border_paint_(display->pixbuf, &border);

    for (tile = 0; tile < CELL_X * CELL_Y; tile++) {
        pixbuf_addr_paint_(display->pixbuf,
                           mem,
                           display->video_base,
                           display->video_base + tile,
                           display->palette_base ? mem + display->palette_base : palette_default_,
                           display->font_base ? mem + display->font_base : (unsigned short *)chargen_4x8_glyphs,
                           display->blink_state);
    }
}

static
int pixbuf_render_pnm_(void *data, struct pixel_ *pixbuf, size_t x, size_t y) {
    FILE *f = (FILE *)data;
    size_t i;
    fprintf(f, "P6\n"
               "%lu %lu\n"
               "255\n",
               x, y);
    for (i = 0; i < x * y; i++) {
        fwrite(&pixbuf[i].r, 1, 1, f);
        fwrite(&pixbuf[i].g, 1, 1, f);
        fwrite(&pixbuf[i].b, 1, 1, f);
    }
    fclose(f);

    return 0;
}

#ifdef HAVE_LIBPNG
static
void pixbuf_render_png_user_warning_(png_structp png, png_const_charp msg) {
    (void)png, (void)msg;
}
static
void pixbuf_render_png_user_error_(png_structp png, png_const_charp msg) {
    (void)png, (void)msg;
}
static
int pixbuf_render_png_(void *data, struct pixel_ *pixbuf, size_t x, size_t y) {
    FILE *f = (FILE *)data;
    int retval = 0;
    png_structp png;
    png_infop info;
    size_t i;

    png = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, pixbuf_render_png_user_error_, pixbuf_render_png_user_warning_);
    if (png == NULL) {
        goto f_done;
    }

    info = png_create_info_struct(png);
    if (info == NULL) {
        png_destroy_write_struct(&png, (png_infopp)NULL);
        goto f_done;
    }

    if (setjmp(png_jmpbuf(png))) {
        png_destroy_write_struct(&png, &info);
        goto f_done;
    }

    png_init_io(png, f);
    png_set_IHDR(png, info, x, y, 8, PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
    png_set_invert_alpha(png);
    png_write_info(png, info);
    for (i = 0; i < y; i++) {
        png_write_row(png, (unsigned char *)(pixbuf + (i * x)));
    }
    png_write_end(png, info);

    png_destroy_write_struct(&png, &info);

f_done:
    fclose(f);

    return retval;
}
#endif /* HAVE_LIBPNG */

#ifdef HAVE_LIBVNCSERVER
struct vnc_server_ {
    rfbScreenInfoPtr rfbScreen;
};

/* create and return a new struct vnc_server_, for use as a vnc renderer's generic data */
void *lem1802_vnc_init_data(int argc, char *argv[], struct dcpu16_hw *hw) {
    struct vnc_server_ *s;
    struct pixel_ *pixbuf = ((struct lem1802_ *)(hw->data))->pixbuf;
    int paddedWidth = PIX_X + ( (PIX_X & 3) ? (4 - (PIX_X & 3)) : 0 );
    int height = PIX_Y;
    int bitsPerSample = 8;
    int samplesPerPixel = 3;
    int bytesPerPixel = 4;

    s = calloc(1, sizeof *s);
    if (s == NULL)
        return NULL;

    s->rfbScreen = rfbGetScreen(&argc, argv, paddedWidth, height, bitsPerSample, samplesPerPixel, bytesPerPixel);
    if (s->rfbScreen == NULL) {
        free(s);
        return NULL;
    }

    s->rfbScreen->desktopName = "NYA ELEKTRISKA LEM1802";
    s->rfbScreen->alwaysShared = TRUE;

#if 0
    s->rfbScreen->kbdAddEvent = HandleKey; */
    s->rfbScreen->httpDir = "../classes";
#endif

    s->rfbScreen->frameBuffer = (char *)pixbuf;

    rfbInitServer(s->rfbScreen);

    rfbRunEventLoop(s->rfbScreen,-1,TRUE);

    TRACE("%s>> initialized new vnc server", __func__);

    return s;
}

static
int pixbuf_render_vnc_(void *data, struct pixel_ *pixbuf, size_t x, size_t y) {
    int retval = 0;
    struct vnc_server_ *s = (struct vnc_server_ *)data;

    (void)pixbuf;

    /* derp */
    rfbMarkRectAsModified(s->rfbScreen,0,0,x,y);

    TRACE("%s>>", __func__);

    return retval;
}
#endif /* HAVE_LIBVNCSERVER */


static
void lem1802_reset_(struct dcpu16 *vm, void *data) {
    struct lem1802_ *display = (struct lem1802_ *)data;

    (void)vm;

    display->cycle_activated = 0;
    display->video_base = 0;
    display->font_base = 0;
    display->palette_base = 0;
    display->border_color = 0;

    memset(display->pixbuf, 0, PIX_X * PIX_Y * sizeof *display->pixbuf);

    display->refresh_tally_ = 0;
    display->blink_tally_ = 0;
    display->blink_state = 0;

#if DEBUG
    vm->trace_cb_("%s>>", __func__);
#endif /* DEBUG */
}

static
void lem1802_cycle_(struct dcpu16 *vm, void *data) {
    struct lem1802_ *display = (struct lem1802_ *)data;

    (void)vm;
    /*
        maybe just step through video memory (if set)
        one word per clock..?  could just cheat and
        use accounting callbacks..

        for now just count cycles and issue a full refresh/render
        every so often
     */

    display->blink_tally_++;
    if (display->blink_tally_ >= display->blink_rate) {
        display->blink_tally_ = 0;
        display->blink_state ^= 1;
        TRACE("%s>> blink:%u (%u cycles)", __func__, display->blink_state, display->blink_rate);
    }

    display->refresh_tally_++;
    if (display->refresh_tally_ >= display->refresh_rate) {
        display->refresh_tally_ = 0;
        if (display->render)
            TRACE("%s>> refresh", __func__);
            lem1802_pixbuf_refresh_full_(display, vm->ram);
            display->render(display->renderer_data, display->pixbuf, PIX_X, PIX_Y);
    }
}

static
void lem1802_hwi_(struct dcpu16 *vm, void *data) {
    struct lem1802_ *display = (struct lem1802_ *)data;
    DCPU16_WORD reg_a = vm->reg[DCPU16_REG_A];
    DCPU16_WORD reg_b = vm->reg[DCPU16_REG_B];
    size_t i;

    TRACE("%s>> A:0x%04x B:0x%04x", __func__, reg_a, reg_b);

    switch (reg_a) {
        case 0: /* MEM_MAP_SCREEN */
            if (display->cycle_activated == 0 && reg_b) {
                display->cycle_activated = vm->cycle;
            }
            display->video_base = reg_b;
            if (reg_b == 0)
                display->cycle_activated = 0;
            break;

        case 1: /* MEM_MAP_FONT */
            display->font_base = reg_b;
            break;

        case 2: /* MEM_MAP_PALETTE */
            display->palette_base = reg_b;
            break;

        case 3: /* SET_BORDER_COLOR */
            display->border_color = reg_b & 0x000f;
            break;

        case 4: /* MEM_DUMP_FONT */
            for (i = 0; i < 128 ; i++) {
                vm->ram[reg_b] = chargen_4x8_glyphs[reg_b][0] << 8;
                vm->ram[reg_b] |= chargen_4x8_glyphs[reg_b][1];
                reg_b += 1;
                vm->ram[reg_b] = chargen_4x8_glyphs[reg_b][2] << 8;
                vm->ram[reg_b] |= chargen_4x8_glyphs[reg_b][3];
                reg_b += 1;
            }
            vm->cycle += 256;
            break;

        case 5: /* MEM_DUMP_PALETTE */
            for (i = 0; i < 16; i++) {
                vm->ram[reg_b] = palette_default_[i];
                reg_b += 1;
            }
            vm->cycle += 16;
            break;
    }
}

static struct renderer_ {
    char *name;
    char *args;
    int (*renderer)(void *, struct pixel_ *, size_t, size_t);
} lem1802_renderers_[] = {
    { "pnm", "filename", pixbuf_render_pnm_ },
#ifdef HAVE_LIBPNG
    { "png", "filename", pixbuf_render_png_ },
#endif /* HAVE_LIBPNG */
#ifdef HAVE_LIBVNCSERVER
    { "vnc", "", pixbuf_render_vnc_ },
#endif /* HAVE_LIBVNCSERVER */
    { "none", "", NULL },
    { NULL, NULL, NULL }
};

int lem1802_renderer_set(struct dcpu16_hw *hw, const char *renderer, void *data) {
    struct renderer_ *r;

    for (r = lem1802_renderers_; r->renderer; r++) {
        if (strcmp(renderer, r->name) == 0) {
            ((struct lem1802_ *)(hw->data))->render = r->renderer;
            ((struct lem1802_ *)(hw->data))->renderer_data = data;
            TRACE("%s>> renderer set to %s", __func__, renderer);
            return 0;
        }
    }

    return -1;
}

char *lem1802_renderers_iter(void **iterp, char **name, char **args) {
    struct renderer_ **r = (struct renderer_ **)iterp;

    if (*r == NULL)
        *r = lem1802_renderers_;
    else
        (*r)++;

    if ((*r)->name == NULL) {
        *r = NULL;
        return NULL;
    }

    *name = (*r)->name;
    *args = (*r)->args;

    return (*r)->name;
}

/* instantitate a new display */
struct dcpu16_hw *lem1802_new(struct dcpu16 *vm) {
    struct dcpu16_hw *hw;

    hw = calloc(1, sizeof *hw);
    if (hw == NULL) {
        vm->warn_cb_("%s():%s", "calloc", strerror(errno));
        return NULL;
    }

    memcpy(hw, &hw_, sizeof *hw);

    hw->data = calloc(1, sizeof(struct dcpu16_hw));
    if (hw->data == NULL) {
        vm->warn_cb_("%s():%s", "calloc", strerror(errno));
        free(hw);
        return NULL;
    }

    ((struct lem1802_ *)(hw->data))->pixbuf = calloc(1, PIX_X * PIX_Y * sizeof *((struct lem1802_ *)(hw->data))->pixbuf);
    if (((struct lem1802_ *)(hw->data))->pixbuf == NULL) {
        vm->warn_cb_("%s():%s", "calloc", strerror(errno));
        free(hw->data);
        free(hw);
        return NULL;
    }

    ((struct lem1802_ *)(hw->data))->refresh_rate = 1666;
    ((struct lem1802_ *)(hw->data))->blink_rate = 75000;

    return hw;
}

void lem1802_del(struct dcpu16_hw **hw) {
    if (hw) {
        if (*hw) {
            if ((*hw)->data) {
                if (((struct lem1802_ *)(*hw)->data)->pixbuf) {
                    free(((struct lem1802_ *)(*hw)->data)->pixbuf);
                    ((struct lem1802_ *)(*hw)->data)->pixbuf = NULL;
                }
                free((*hw)->data);
                (*hw)->data = NULL;
            }
            free(*hw);
        }
        *hw = NULL;
    }
}