#include <cstdint>

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

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

#include "input.hpp"
#include "vram.hpp"
#include "font.hpp"

#include "gen/tilesets.hpp"
#include "gen/sprites.hpp"
#include "pokemon.hpp"
#include "gen/maps.hpp"
#include "actor.hpp"
#include "player.hpp"

#include "cell_offset.hpp"

#include "window/window.hpp"
#include "window/window_stack.hpp"

struct draw_t {
  struct {
    uint16_t font; // div 32
    uint16_t tilesets[tileset_t::count]; // div 32
    uint16_t spritesheets[spritesheet_t::count]; // div 128
    struct {
      uint16_t front;
      uint16_t back;
    } pokemon[pokemon_t::count]; // div 16
  } base_pattern;
};

struct state_t {
  draw_t draw;
  player_state_t player[1];
};

static state_t state = { map_t::pallet_town, map_t::last_map, 0 };

uint32_t load_tileset(uint32_t top, enum tileset_t::tileset tileset)
{
  const uint32_t base_address = top = cell_data(tilesets[tileset].tileset, top);
  state.draw.base_pattern.tilesets[tileset] = base_address / 32;

  return top;
}

uint32_t load_spritesheet(uint32_t top, enum spritesheet_t::spritesheet spritesheet)
{
  const spritesheet_t& s = spritesheets[spritesheet];
  const uint32_t base_address = top = character_pattern_table(s.spritesheet, top);
  state.draw.base_pattern.spritesheets[spritesheet] = base_address / 128;

  return top;
}

uint32_t load_pokemon(uint32_t top, enum pokemon_t::pokemon _pokemon)
{
  const pokemon_t& p = pokemon[_pokemon];
  const uint32_t base_address_front = top = character_pattern_table(p.pic.front, top);
  const uint32_t base_address_back = top = character_pattern_table(p.pic.back, top);
  state.draw.base_pattern.pokemon[_pokemon].front = base_address_front / 16;
  state.draw.base_pattern.pokemon[_pokemon].back = base_address_back / 16;
  return top;
}

void load_vram()
{
  vdp2.reg.CYCA0 = 0xeeee'eeee;
  vdp2.reg.CYCA1 = 0xeeee'eeee;
  vdp2.reg.CYCB0 = 0xeeee'eeee;
  vdp2.reg.CYCB1 = 0xeeee'eeee;

  uint32_t vdp2_top = (sizeof (union vdp2_vram));
  vdp2_top = load_font(vdp2_top);
  state.draw.base_pattern.font = vdp2_top / 32;

  for (uint32_t i = 0; i < tileset_t::count; i++)
    vdp2_top = load_tileset(vdp2_top, static_cast<enum tileset_t::tileset>(i));

  vdp2.reg.CYCA0 = 0x01ff'ffff;
  vdp2.reg.CYCA1 = 0x01ff'ffff;
  vdp2.reg.CYCB0 = 0x45ff'ffff;
  vdp2.reg.CYCB1 = 0x45ff'ffff;

  uint32_t vdp1_top = (sizeof (union vdp1_vram));
  for (uint32_t i = 0; i < spritesheet_t::count; i++)
    vdp1_top = load_spritesheet(vdp1_top, static_cast<enum spritesheet_t::spritesheet>(i));

  for (uint32_t i = 0; i < pokemon_t::count; i++)
    vdp1_top = load_pokemon(vdp1_top, static_cast<enum pokemon_t::pokemon>(i));
}

static inline uint32_t facing_offset(const actor_t::direction facing)
{
  switch (facing) {
  default: [[fallthrough]];
  case actor_t::down:  return 0;
  case actor_t::up:    return 1;
  case actor_t::left:  return 2;
  case actor_t::right: return 2;
  }
}

static inline uint32_t facing_inverted(const actor_t::direction facing, const uint32_t animation_cycle)
{
  switch (facing) {
  default:             [[fallthrough]];
  case actor_t::down:  [[fallthrough]];
  case actor_t::up:
    return (animation_cycle & 1) ? CTRL__DIR__INVERTED_HORIZONTALLY : CTRL__DIR__NOT_INVERTED;
  case actor_t::left:
    return CTRL__DIR__NOT_INVERTED;
  case actor_t::right:
    return CTRL__DIR__INVERTED_HORIZONTALLY;
  }
}

void render_sprite(const uint32_t ix, const enum spritesheet_t::spritesheet sprite_id,
		   const enum actor_t::direction facing, const uint32_t animation_frame, const uint32_t animation_cycle,
		   const screen_t& screen, const offset_t& offset,
		   int32_t y_offset)
{
  const uint32_t sprite_offset = facing_offset(facing) + animation_frame;
  const uint32_t base_pattern = state.draw.base_pattern.spritesheets[sprite_id];
  const uint32_t character_address = ((base_pattern + sprite_offset) * 128) / 8;

  vdp1.vram.cmd[ix].CTRL = CTRL__JP__JUMP_NEXT | CTRL__COMM__NORMAL_SPRITE | facing_inverted(facing, animation_cycle);
  vdp1.vram.cmd[ix].LINK = 0;
  // The "end code" is 0xf, which is being used in the mai sprite palette. If
  // both transparency and end codes are enabled, it seems there are only 14
  // usable colors in the 4-bit color mode.
  vdp1.vram.cmd[ix].PMOD = PMOD__ECD | PMOD__COLOR_MODE__COLOR_BANK_16;
  vdp1.vram.cmd[ix].COLR = COLR__COLOR_BANK__4BPP__PALETTE(1)
                         | COLR__COLOR_BANK__TYPE0__PR(1);
  vdp1.vram.cmd[ix].SRCA = character_address;
  vdp1.vram.cmd[ix].SIZE = SIZE__X(16) | SIZE__Y(16);
  vdp1.vram.cmd[ix].XA = (cell_offset::x * 8) + screen.x * 16 - offset.x;
  vdp1.vram.cmd[ix].YA = (cell_offset::y * 8) + screen.y * 16 + y_offset - offset.y;
}

uint32_t pokemon_sprite_dimension(const uint32_t size)
{
  switch (size) {
  default: [[fallthrough]];
  case 256: return 32;
  case 400: return 40;
  case 576: return 48;
  case 784: return 56;
  }
}

void render_pokemon(const uint32_t ix, const enum pokemon_t::pokemon pokemon_id,
		    const screen_cell_t& screen_cell, bool horizontal_inversion)
{
  const uint32_t base_pattern = state.draw.base_pattern.pokemon[pokemon_id].front;
  const uint32_t character_address = (base_pattern * 16) / 8;
  const uint32_t dimension = pokemon_sprite_dimension(pokemon[pokemon_id].pic.front.size);

  int32_t x_offset;
  int32_t y_offset;
  switch (dimension) {
  default:
  case 40: x_offset = 2; y_offset = 2; break;
  case 48: x_offset = 1; y_offset = 1; break;
  case 56: x_offset = 1; y_offset = 0; break;
  }

  uint16_t dir = horizontal_inversion ? CTRL__DIR__INVERTED_HORIZONTALLY : 0;

  vdp1.vram.cmd[ix].CTRL = CTRL__JP__JUMP_NEXT | CTRL__COMM__NORMAL_SPRITE | dir;
  vdp1.vram.cmd[ix].LINK = 0;
  // The "end code" is 0xf, which is being used in the mai sprite palette. If
  // both transparency and end codes are enabled, it seems there are only 14
  // usable colors in the 4-bit color mode.
  vdp1.vram.cmd[ix].PMOD = PMOD__ECD | PMOD__COLOR_MODE__COLOR_BANK_16;
  vdp1.vram.cmd[ix].COLR = COLR__COLOR_BANK__4BPP__PALETTE(0)
                         | COLR__COLOR_BANK__TYPE0__PR(0);
  vdp1.vram.cmd[ix].SRCA = character_address;
  vdp1.vram.cmd[ix].SIZE = SIZE__X(dimension) | SIZE__Y(dimension);
  vdp1.vram.cmd[ix].XA = (cell_offset::x * 8) + (screen_cell.x + x_offset) * 8;
  vdp1.vram.cmd[ix].YA = (cell_offset::y * 8) + (screen_cell.y + y_offset) * 8;
}

void render_sprites(const offset_t& offset)
{
  uint32_t ix = 2;

  /*
  const uint32_t animation_frame = ((state.player.frame & 0b1000) != 0) * 3;
  render_sprite(ix,
		spritesheet_t::red,
		state.player.facing, animation_frame, state.player.cycle,
		{4, 4},
		{0, 0},
		state.player.y_offset());
  ix++;

  const object_t& obj = map_objects[state.map];
  for (uint32_t i = 0; i < obj.object_length; i++) {
    const object_event_t& event = obj.object_events[i];
    const world_t world = { event.position.x, event.position.y };
    render_sprite(ix,
		  event.sprite_id,
		  actor_t::down, 0, 0,
		  world.to_screen(state.player.world),
		  offset,
		  -4);
    ix++;
  }
  */

  constexpr uint16_t top_x = 80 - 1;
  constexpr uint16_t top_y = 48 - 1;
  constexpr uint16_t bot_x = 239 + 1;
  constexpr uint16_t bot_y = 191 + 1;

  vdp1.vram.cmd[ix].CTRL = CTRL__JP__JUMP_NEXT | CTRL__COMM__POLYLINE;
  vdp1.vram.cmd[ix].LINK = 0;
  // "Set [ECD] to '1' for polygons, polylines, and lines"
  // "Be sure to set [SPD] to '1' for polygons, polylines, and lines"
  //
  // The "user clip mode" bit is not set in PMOD here, so setting "user clip
  // coordinates" has no effect on this draw command. However, "system clip
  // coordinates" and "local coordinates" are always applied, and must be set to
  // reasonable values.
  vdp1.vram.cmd[ix].PMOD = PMOD__ECD | PMOD__SPD;
  vdp1.vram.cmd[ix].COLR = COLR__RGB | rgb15(255, 0, 255);
  vdp1.vram.cmd[ix].XA = top_x;
  vdp1.vram.cmd[ix].YA = top_y;
  vdp1.vram.cmd[ix].XB = bot_x;
  vdp1.vram.cmd[ix].YB = top_y;
  vdp1.vram.cmd[ix].XC = bot_x;
  vdp1.vram.cmd[ix].YC = bot_y;
  vdp1.vram.cmd[ix].XD = top_x;
  vdp1.vram.cmd[ix].YD = bot_y;

  ix++;

  vdp1.vram.cmd[ix].CTRL = CTRL__END;
}

void render_map()
{
  //const map_t& map = maps[state.map];
  //const uint32_t base_pattern = state.draw.base_pattern.tilesets[map.tileset];
  //vdp2.reg.PNCN0 = PNCN0__N0PNB__1WORD | PNCN0__N0CNSM | PNCN0__N0SCN((base_pattern >> 10) & 0x1f);

  for (int32_t y = (0 - 1); y < (9 + 2); y++) {
    for (int32_t x = (0 - 2); x < (10 + 2); x++) {
      /*
      render_screen(base_pattern,
		    map,
		    state.player.world,
		    {x, y}
		    );
      */
    }
  }
}

void update()
{
  //state.player.tick();

  enum window_t::input_event window_input_event;

  if      (event::cursor_left() ) window_input_event = window_t::input_left;
  else if (event::cursor_right()) window_input_event = window_t::input_right;
  else if (event::cursor_up()   ) window_input_event = window_t::input_up;
  else if (event::cursor_down() ) window_input_event = window_t::input_down;
  else if (event::button_a() )    window_input_event = window_t::input_a;
  else if (event::button_b() )    window_input_event = window_t::input_b;
  else return;

  state.player[0].window_stack.update(window_input_event,
				      state.player[0].trainer);
}

static uint32_t frame = 0;

void render()
{
  frame++;

  const offset_t offset = state.player[0].actor.offset();

  render_sprites(offset);

  vdp1.reg.PTMR = PTMR__PTM__NOW;

  vdp2.reg.SCXIN0 = offset.x;
  vdp2.reg.SCXDN0 = 0;
  vdp2.reg.SCYIN0 = offset.y;
  vdp2.reg.SCYDN0 = 0;

  //render_map();
  state.player[0].window_stack.draw(state.draw.base_pattern.font,
				    state.player[0].trainer);

  vdp2.reg.BGON = BGON__N0ON | BGON__N0TPON | BGON__N1ON;
}

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);

  sh2.reg.FRC.H = 0;
  sh2.reg.FRC.L = 0;
  sh2.reg.FTCSR = 0; // clear flags

  render();
  update();

  // 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);

  // 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].val = INTBACK__IREG0__STATUS_DISABLE;
  smpc.reg.IREG[1].val = ( INTBACK__IREG1__PERIPHERAL_DATA_ENABLE
                         | INTBACK__IREG1__PORT2_15BYTE
                         | INTBACK__IREG1__PORT1_15BYTE
                         );
  smpc.reg.IREG[2].val = INTBACK__IREG2__MAGIC;

  smpc.reg.COMREG = COMREG__INTBACK;
}

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::fsm(digital_callback, nullptr);
}

void init_vdp1()
{
  /* TVM settings must be performed from the second H-blank IN interrupt after the
  V-blank IN interrupt to the H-blank IN interrupt immediately after the V-blank
  OUT interrupt. */
  // "normal" display resolution, 16 bits per pixel, 512x256 framebuffer
  vdp1.reg.TVMR = TVMR__TVM__NORMAL;

  // swap framebuffers every 1 cycle; non-interlace
  vdp1.reg.FBCR = 0;

  // during a framebuffer erase cycle, write the color "black" to each pixel
  constexpr uint16_t black = 0x0000;
  vdp1.reg.EWDR = black;

  // the EWLR/EWRR macros use somewhat nontrivial math for the X coordinates
  // erase upper-left coordinate
  vdp1.reg.EWLR = EWLR__16BPP_X1(0) | EWLR__Y1(0);

  // erase lower-right coordinate
  vdp1.reg.EWRR = EWRR__16BPP_X3(319) | EWRR__Y3(239);

  vdp1.vram.cmd[0].CTRL = CTRL__JP__JUMP_NEXT | CTRL__COMM__SYSTEM_CLIP_COORDINATES;
  vdp1.vram.cmd[0].LINK = 0;
  vdp1.vram.cmd[0].XC = 319;
  vdp1.vram.cmd[0].YC = 239;

  vdp1.vram.cmd[1].CTRL = CTRL__JP__JUMP_NEXT | CTRL__COMM__LOCAL_COORDINATE;
  vdp1.vram.cmd[1].LINK = 0;
  vdp1.vram.cmd[1].XA = 0;
  vdp1.vram.cmd[1].YA = 0;

  vdp1.vram.cmd[2].CTRL = CTRL__END;

  // start drawing (execute the command list) on every frame
  //vdp1.reg.PTMR = PTMR__PTM__FRAME_CHANGE;
}

void init_vdp2()
{
  // sprite type
  vdp2.reg.SPCTL = SPCTL__SPTYPE(0) // 2-bit priority
                 | SPCTL__SPCLMD; // enable RGB data from VDP1

  vdp2.reg.PRISA = PRISA__S0PRIN(7)  // Sprite register 0 PRIority Number
                 | PRISA__S1PRIN(5); // Sprite register 1 PRIority Number
  vdp2.reg.PRINA = PRINA__N0PRIN(4)
                 | PRINA__N1PRIN(6);

  // 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);

  vdp2.reg.EXTEN = 0;

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

  /* disable display of NBG0 */
  vdp2.reg.BGON = 0;

  /* 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
                  | CHCTLA__N1CHCN__16_COLOR
                  | CHCTLA__N1BMEN__CELL_FORMAT
                  | CHCTLA__N1CHSZ__1x1_CELL;

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

  /* map plane offset
     1-word: value of bit 6-0 * 0x2000
     2-word: value of bit 5-0 * 0x4000
  */
  constexpr int nbg0_plane = 0;
  constexpr int nbg1_plane = 1;
  //constexpr int plane_a_offset = plane_a * 0x2000;

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

  // bits 8~6
  vdp2.reg.MPOFN = MPOFN__N0MP(nbg0_plane >> 6)
                 | MPOFN__N1MP(nbg1_plane >> 6);
  vdp2.reg.MPN0 = MPN0__N0MP(nbg0_plane);
  vdp2.reg.MPN1 = MPN1__N1MP(nbg1_plane);

  const uint32_t base_pattern = state.draw.base_pattern.font;
  vdp2.reg.PNCN1 = PNCN1__N1PNB__1WORD | PNCN1__N1CNSM | PNCN1__N1SCN((base_pattern >> 10) & 0x1f);
  const uint32_t value = ((base_pattern + 127) & 0xfff) | PATTERN_NAME_TABLE_1WORD__PALETTE(1);
  fill<uint32_t>(&vdp2.vram.u32[0x2000 / 4], value | value << 16, 0x2000);

  palette_data();
}

void main()
{
  //state.map = map_t::pallet_town;
  //state.map = map_t::pewter_gym;
  //state.map = map_t::viridian_forest;
  //state.map = map_t::route_2;
  //state.player.world.x = 6;
  //state.player.world.y = 6;
  default_party(state.player[0].trainer.party);

  load_vram();

  v_blank_in();

  init_vdp1();
  init_vdp2();

  constexpr uint16_t top_x = 80 - 1;
  constexpr uint16_t top_y = 48 - 1;
  constexpr uint16_t bot_x = 239 + 1;
  constexpr uint16_t bot_y = 191 + 1;
  vdp2.reg.WPSX0 = top_x << 1;
  vdp2.reg.WPSY0 = top_y;
  vdp2.reg.WPEX0 = bot_x << 1;
  vdp2.reg.WPEY0 = bot_y;

  vdp2.reg.WCTLA = WCTLA__N0W0E | WCTLA__N0W0A__OUTSIDE;
  vdp2.reg.WCTLC = WCTLC__SPW0E | WCTLC__SPW0A__OUTSIDE;

  // 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);

  window_stack_t& window_stack = state.player[0].window_stack;
  window_stack.ix = 0;
  window_stack.stack[0].type = window_descriptor_t::fight;
  window_stack.stack[0].window = { 0 };
}