#include <stdint.h>

#include "vdp2.h"
#include "smpc.h"
#include "scu.h"
#include "sh2.h"

#include "../common/copy.hpp"
#include "../common/vdp2_func.hpp"
#include "../common/keyboard.hpp"
#include "../common/intback.hpp"

#include "editor.hpp"

extern void * _sperrypc_bitmap_start __asm("_binary_res_sperrypc_bitmap_bin_start");

using buffer_type = editor::buffer<64, 64>;
constexpr int32_t viewport_max_col = 320 / 8;
constexpr int32_t viewport_max_row = 240 / 8;

static buffer_type buffer {viewport_max_col, viewport_max_row};

void palette_data()
{
  vdp2.cram.u16[1 + 0 ] = 0;
  vdp2.cram.u16[2 + 0 ] = 0x7fff;

  vdp2.cram.u16[1 + 16] = 0x7fff;
  vdp2.cram.u16[2 + 16] = 0;
}

namespace pix_fmt_4bpp
{
  constexpr inline uint32_t
  bit(uint8_t n, int32_t i)
  {
    i &= 7;
    auto b = (n >> (7 - i)) & 1;
    return ((b + 1) << ((7 - i) * 4));
  }

  constexpr inline uint32_t
  bits(uint8_t n)
  {
    return
        bit(n, 0) | bit(n, 1) | bit(n, 2) | bit(n, 3)
      | bit(n, 4) | bit(n, 5) | bit(n, 6) | bit(n, 7);
  }

  static_assert(bits(0b1100'1110) == 0x2211'2221);
  static_assert(bits(0b1010'0101) == 0x2121'1212);
  static_assert(bits(0b1000'0000) == 0x2111'1111);
}

void cell_data()
{
  const uint8_t * buf = reinterpret_cast<uint8_t*>(&_sperrypc_bitmap_start);

  for (int ix = 0; ix <= (0x7f - 0x20); ix++) {
    for (int y = 0; y < 8; y++) {
      uint8_t row = buf[ix * 8 + y];
      vdp2.vram.u32[(ix * 8) + y] = pix_fmt_4bpp::bits(row);
    }
  }
}

struct modifiers {
  uint8_t left_shift;
  uint8_t right_shift;
};

static modifiers modifier_state = { 0 };

void keyboard_callback(const enum keysym k, uint8_t kbd_bits)
{
  int32_t shift = modifier_state.left_shift || modifier_state.right_shift;
  int32_t c = keysym_to_char(k, shift);
  if (KEYBOARD__MAKE(kbd_bits)) {
    if (k == keysym::UNKNOWN)
      return;

    if (c != -1) {
      buffer.put(c);
    } else {
      switch (k) {
      case keysym::BACKSPACE  : buffer.backspace(); break;
      case keysym::ARROW_LEFT : buffer.cursor_left(); break;
      case keysym::ARROW_RIGHT: buffer.cursor_right(); break;
      case keysym::ARROW_UP   : buffer.cursor_up(); break;
      case keysym::ARROW_DOWN : buffer.cursor_down(); break;
      case keysym::HOME       : buffer.cursor_home(); break;
      case keysym::END        : buffer.cursor_end(); break;
      case keysym::ENTER      : buffer.enter(); break;
      case keysym::LEFT_SHIFT : modifier_state.left_shift = 1; break;
      case keysym::RIGHT_SHIFT: modifier_state.right_shift = 1; break;
      default: break;
      }
    }
  } else if (KEYBOARD__BREAK(kbd_bits)) {
    switch (k) {
    case keysym::LEFT_SHIFT : modifier_state.left_shift = 0; break;
    case keysym::RIGHT_SHIFT: modifier_state.right_shift = 0; break;
    default: break;
    }
  }
}

extern "C"
void smpc_int(void) __attribute__ ((interrupt_handler));
void smpc_int(void)
{
  scu.reg.IST &= ~(IST__SMPC);
  scu.reg.IMS = ~(IMS__SMPC | IMS__V_BLANK_IN);

  intback::keyboard_fsm(keyboard_callback);
}

constexpr int32_t plane_a = 2;
constexpr inline int32_t plane_offset(int32_t n) { return n * 0x2000; }

constexpr int32_t page_size = 64 * 64 * 2; // N0PNB__1WORD (16-bit)
constexpr int32_t plane_size = page_size * 1;

constexpr int32_t cell_size = (8 * 8) / 2; // N0CHCN__16_COLOR (4-bit)
constexpr int32_t character_size = cell_size * (1 * 1); // N0CHSZ__1x1_CELL
constexpr int32_t page_width = 64;

static int plane_ix = 0;

inline void
set_char(int32_t x, int32_t y, uint8_t palette, uint8_t c)
{
  const auto ix = (plane_offset(plane_a + plane_ix) / 2) + (y * page_width) + x;
  vdp2.vram.u16[ix] =
      PATTERN_NAME_TABLE_1WORD__PALETTE(palette)
    | PATTERN_NAME_TABLE_1WORD__CHARACTER((c - 0x20));
}

void render()
{
  for (int row = 0; row < buffer.window.cell_height; row++) {
    const buffer_type::line_type * l = buffer.lines[buffer.window.top + row];

    for (int col = 0; col < buffer.window.cell_width; col++) {
      uint8_t c;

      c = ' ';
      if (l != nullptr && (buffer.window.left + col) < l->length)
	c = l->buf[buffer.window.left + col];

      set_char(col, row, 0, c);
    }
  }
  editor::cursor& cur = buffer.cursor;
  const buffer_type::line_type * l = buffer.lines[cur.row];
  uint8_t c = (l != nullptr && cur.col < l->length) ? l->buf[cur.col] : ' ';
  set_char(cur.col - buffer.window.left, cur.row - buffer.window.top, 1, c);
}

extern "C"
void v_blank_in_int(void) __attribute__ ((interrupt_handler));
void v_blank_in_int()
{
  scu.reg.IST &= ~(IST__V_BLANK_IN);
  scu.reg.IMS = ~(IMS__SMPC | IMS__V_BLANK_IN);

  // flip planes;
  vdp2.reg.MPABN0 = MPABN0__N0MPB(0) | MPABN0__N0MPA(plane_a + plane_ix);
  plane_ix = !plane_ix;

  // wait at least 300us, as specified in the SMPC manual.
  // It appears reading FRC.H is mandatory and *must* occur before FRC.L on real
  // hardware.
  while ((sh2.reg.FTCSR & FTCSR__OVF) == 0 && sh2.reg.FRC.H == 0 && sh2.reg.FRC.L < 63);

  if ((vdp2.reg.TVSTAT & TVSTAT__VBLANK) != 0) {
    // on real hardware, SF contains uninitialized garbage bits other than the
    // lsb.
    while ((smpc.reg.SF & 1) != 0);

    smpc.reg.SF = 0;

    smpc.reg.ireg[0] = INTBACK__IREG0__STATUS_DISABLE;
    smpc.reg.ireg[1] = ( INTBACK__IREG1__PERIPHERAL_DATA_ENABLE
                       | INTBACK__IREG1__PORT2_15BYTE
                       | INTBACK__IREG1__PORT1_15BYTE
                       );
    smpc.reg.ireg[2] = INTBACK__IREG2__MAGIC;

    smpc.reg.COMREG = COMREG__INTBACK;
  }

  render();
}

void main()
{
  v_blank_in();

  // DISP: Please make sure to change this bit from 0 to 1 during V blank.
  vdp2.reg.TVMD = ( TVMD__DISP | TVMD__LSMD__NON_INTERLACE
                  | TVMD__VRESO__240 | TVMD__HRESO__NORMAL_320);

  /* set the color mode to 5bits per channel, 1024 colors */
  vdp2.reg.RAMCTL = RAMCTL__CRMD__RGB_5BIT_1024;

  /* enable display of NBG0 */
  vdp2.reg.BGON = BGON__N0ON;

  /* set character format for NBG0 to palettized 16 color
     set enable "cell format" for NBG0
     set character size for NBG0 to 1x1 cell */
  vdp2.reg.CHCTLA = CHCTLA__N0CHCN__16_COLOR
                  | CHCTLA__N0BMEN__CELL_FORMAT
                  | CHCTLA__N0CHSZ__1x1_CELL;
  /* "Note: In color RAM modes 0 and 2, 2048-color becomes 1024-color" */

  /* use 1-word (16-bit) pattern names */
  vdp2.reg.PNCN0 = PNCN0__N0PNB__1WORD;

  /* plane size */
  vdp2.reg.PLSZ = PLSZ__N0PLSZ__1x1;

  /* map plane offset
     1-word: value of bit 6-0 * 0x2000
     2-word: value of bit 5-0 * 0x4000
  */
  vdp2.reg.MPOFN = MPOFN__N0MP(0); // bits 8~6
  vdp2.reg.MPABN0 = MPABN0__N0MPB(0) | MPABN0__N0MPA(plane_a); // bits 5~0
  vdp2.reg.MPCDN0 = MPABN0__N0MPD(0) | MPABN0__N0MPC(0); // bits 5~0

  // zeroize character/cell data from 0 up to plane_a_offset
  fill<uint32_t>(&vdp2.vram.u32[(0 / 4)], 0, plane_offset(plane_a));

  // zeroize plane_a; `0` is the ascii 0x20 ("space") which doubles as
  // "transparency" character.
  fill<uint32_t>(&vdp2.vram.u32[(plane_offset(plane_a) / 4)], 0, plane_size * 2);

  palette_data();
  cell_data();

  // free-running timer
  sh2.reg.TCR = TCR__CKS__INTERNAL_DIV128;
  sh2.reg.FTCSR = 0;

  // initialize smpc
  smpc.reg.DDR1 = 0; // INPUT
  smpc.reg.DDR2 = 0; // INPUT
  smpc.reg.IOSEL = 0; // SMPC control
  smpc.reg.EXLE = 0; //

  sh2_vec[SCU_VEC__SMPC] = (u32)(&smpc_int);
  sh2_vec[SCU_VEC__V_BLANK_IN] = (u32)(&v_blank_in_int);

  scu.reg.IST = 0;
  scu.reg.IMS = ~(IMS__SMPC | IMS__V_BLANK_IN);
}