#include "parameters.h"

#include <azur/azur.h>
#include <azur/gint/render.h>
#include <gint/drivers/r61524.h>
#include <gint/rtc.h>

#include <gint/clock.h>
#include <gint/kmalloc.h>

#include <gint/usb-ff-bulk.h>
#include <gint/usb.h>
#include <libprof.h>

#include <cstdint>
#include <fxlibc/printf.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <num/num.h>

#include "extrakeyboard.h"
#include "utilities.h"

#include "level.h"
#include "player.h"
#include "vector2D.h"

#include <vector>

bool screenshot = false;
bool record = false;
bool textoutput = false;
bool exitToOS = false;

uint8_t texttodraw = 1;
bool textbacktile = false;
bool textforetile = false;

#define SCALE_PIXEL 1
#define X_RESOL (DWIDTH / SCALE_PIXEL)
#define Y_RESOL (DHEIGHT / SCALE_PIXEL)

float elapsedTime = 0.0f;
uint32_t time_update = 0, time_render = 0;
prof_t perf_update, perf_render;

static kmalloc_arena_t extended_ram = {0};
static kmalloc_arena_t *_uram;
kmalloc_gint_stats_t *_uram_stats;
kmalloc_gint_stats_t *extram_stats;

KeyboardExtra MyKeyboard;
Level MyLevel;
Player MyPlayer(198, 180);

std::vector<Border *> MyLevelBorders;

bool drawbackground = true;
bool drawforeground = true;
bool drawnormals = true;
bool drawborders = true;

uint16_t tilecolor = C_BLACK;
uint16_t backcolor = C_WHITE;

static void hook_prefrag(int id, void *fragment, int size) {
  if (!screenshot && !record)
    return;

  /* Screenshot takes precedence */
  char const *type = screenshot ? "image" : "video";

  int pipe = usb_ff_bulk_output();

  if (id == 0) {
    usb_fxlink_header_t h;
    usb_fxlink_image_t sh;
    int size = azrp_width * azrp_height * 2;

    usb_fxlink_fill_header(&h, "fxlink", type, size + sizeof sh);
    sh.width = htole32(azrp_width);
    sh.height = htole32(azrp_height);
    sh.pixel_format = htole32(USB_FXLINK_IMAGE_RGB565);

    usb_write_sync(pipe, &h, sizeof h, false);
    usb_write_sync(pipe, &sh, sizeof sh, false);
  }

  usb_write_sync(pipe, fragment, size, false);

  if (id == azrp_frag_count - 1) {
    usb_commit_sync(pipe);
    screenshot = false;
  }
}

static void update(float dt) {
  MyPlayer.Update(dt);
  MyLevel.Update(dt);
}

static void render(void) {

  MyLevel.Render();

  //    MyLevel.RenderSelected();
  //    MyPlayer.Render();

#if (BIAS)
  if (texttodraw >= 1)
    azrp_draw_text(1, 01, "FPS  = %.0f - Mem Free = %d",
                   (float)(1000.0f / elapsedTime),
                   _uram_stats->free_memory + extram_stats->free_memory);
  if (texttodraw >= 1)
    azrp_draw_text(1, 11, "PlayX  = %d - PlayY = %d - VX = %d - VY = %d",
                   MyPlayer.tileX, MyPlayer.tileY,
                   MyPlayer.nextx.v - MyPlayer.currx.v,
                   MyPlayer.nexty.v - MyPlayer.curry.v);

  if (texttodraw >= 2)
    azrp_draw_text(1, 31, "Update = %.3f ms", (float)time_update / 1000.0f);
  if (texttodraw >= 2)
    azrp_draw_text(1, 41, "Render = %.3f ms", (float)time_render / 1000.0f);
  if (texttodraw >= 2)
    azrp_draw_text(1, 51, ">Total = %.0f ms", (float)elapsedTime);

  if (texttodraw >= 3)
    azrp_draw_text(1, 81, "Mem Used      : %d",
                   _uram_stats->used_memory + extram_stats->used_memory);
  if (texttodraw >= 3)
    azrp_draw_text(1, 91, "Mem Free      : %d",
                   _uram_stats->free_memory + extram_stats->free_memory);
  if (texttodraw >= 3)
    azrp_draw_text(1, 101, "Mem Peak Used : %d",
                   _uram_stats->peak_used_memory +
                       extram_stats->peak_used_memory);
#endif
}

static void get_inputs(float dt) {
  if (MyKeyboard.IsKeyPressed(MYKEY_SHIFT) &&
      MyKeyboard.IsKeyHoldPressed(MYKEY_EXIT)) {
    exitToOS = true;
  };

#if (DEBUG_MODE)
  if (MyKeyboard.IsKeyPressed(MYKEY_OPTN) &&
      MyKeyboard.IsKeyPressedEvent(MYKEY_7) && usb_is_open()) {
    screenshot = true;
  };
  if (MyKeyboard.IsKeyPressed(MYKEY_OPTN) &&
      MyKeyboard.IsKeyPressedEvent(MYKEY_8) && usb_is_open()) {
    record = true;
  };
  if (MyKeyboard.IsKeyPressed(MYKEY_OPTN) &&
      MyKeyboard.IsKeyPressedEvent(MYKEY_9) && usb_is_open()) {
    record = false;
  };

  if (MyKeyboard.IsKeyPressed(MYKEY_OPTN) &&
      MyKeyboard.IsKeyPressedEvent(MYKEY_VARS)) {
    drawbackground = !drawbackground;
  }
  if (MyKeyboard.IsKeyPressed(MYKEY_OPTN) &&
      MyKeyboard.IsKeyPressedEvent(MYKEY_MENU)) {
    drawforeground = !drawforeground;
  }
  if (MyKeyboard.IsKeyPressed(MYKEY_SHIFT) &&
      MyKeyboard.IsKeyPressedEvent(MYKEY_VARS)) {
    drawnormals = !drawnormals;
  }
  if (MyKeyboard.IsKeyPressed(MYKEY_SHIFT) &&
      MyKeyboard.IsKeyPressedEvent(MYKEY_MENU)) {
    drawborders = !drawborders;
  }

  if (MyKeyboard.IsKeyPressed(MYKEY_OPTN) &&
      MyKeyboard.IsKeyPressedEvent(MYKEY_0)) {
    texttodraw = 0;
  }
  if (MyKeyboard.IsKeyPressed(MYKEY_OPTN) &&
      MyKeyboard.IsKeyPressedEvent(MYKEY_1)) {
    texttodraw = 1;
  }
  if (MyKeyboard.IsKeyPressed(MYKEY_OPTN) &&
      MyKeyboard.IsKeyPressedEvent(MYKEY_2)) {
    texttodraw = 2;
  }
  if (MyKeyboard.IsKeyPressed(MYKEY_OPTN) &&
      MyKeyboard.IsKeyPressedEvent(MYKEY_3)) {
    texttodraw = 3;
  }
  if (MyKeyboard.IsKeyPressed(MYKEY_OPTN) &&
      MyKeyboard.IsKeyPressedEvent(MYKEY_4)) {
    textbacktile = !textbacktile;
  }
  if (MyKeyboard.IsKeyPressed(MYKEY_OPTN) &&
      MyKeyboard.IsKeyPressedEvent(MYKEY_5)) {
    textforetile = !textforetile;
  }

  if (MyKeyboard.IsKeyPressedEvent(MYKEY_F1)) {
    MyLevel.ChangeMap(0);
  }
  if (MyKeyboard.IsKeyPressedEvent(MYKEY_F2)) {
    MyLevel.ChangeMap(1);
  }
  if (MyKeyboard.IsKeyPressedEvent(MYKEY_F3)) {
    MyLevel.ChangeMap(2);
  }
  if (MyKeyboard.IsKeyPressedEvent(MYKEY_F4)) {
    MyLevel.ChangeMap(3);
  }
  if (MyKeyboard.IsKeyPressedEvent(MYKEY_F5)) {
    MyLevel.ChangeMap(4);
  }
  if (MyKeyboard.IsKeyPressedEvent(MYKEY_F6)) {
    MyLevel.ChangeMap(5);
  }
#endif

  /* we can have either LEFT or RIGHT or NONE OF THEM pressed for the direction
   */
  if (MyKeyboard.IsKeyPressed(MYKEY_LEFT))
    MyPlayer.Left(dt);
  else if (MyKeyboard.IsKeyPressed(MYKEY_RIGHT))
    MyPlayer.Right(dt);
  else if (MyKeyboard.IsKeyPressed(MYKEY_UP))
    MyPlayer.Up(dt);
  else if (MyKeyboard.IsKeyPressed(MYKEY_DOWN))
    MyPlayer.Down(dt);
  else
    MyPlayer.Nothing(dt);

  /* JUMP is */
  if (MyKeyboard.IsKeyPressedEvent(MYKEY_SHIFT)) {
    // MyPlayer.Jump( dt );
  }
}

bool AddMoreRAM(void) {
  /* allow more RAM */
  char const *osv = (char *)0x80020020;

  if ((!strncmp(osv, "03.", 3) && osv[3] <= '8') &&
      gint[HWCALC] == HWCALC_FXCG50) // CG-50
  {
    extended_ram.name = "extram";
    extended_ram.is_default = true;
    extended_ram.start = (void *)0x8c200000;
    extended_ram.end = (void *)0x8c4e0000;

    kmalloc_init_arena(&extended_ram, true);
    kmalloc_add_arena(&extended_ram);
    return true;
  } else if (gint[HWCALC] == HWCALC_PRIZM) // CG-10/20
  {

    extended_ram.name = "extram";
    extended_ram.is_default = true;

    uint16_t *vram1, *vram2;
    dgetvram(&vram1, &vram2);
    dsetvram(vram1, vram1);

    extended_ram.start = vram2;
    extended_ram.end = (char *)vram2 + 396 * 224 * 2;

    kmalloc_init_arena(&extended_ram, true);
    kmalloc_add_arena(&extended_ram);
    return false;

  } else if (gint[HWCALC] == HWCALC_FXCG_MANAGER) // CG-50 EMULATOR
  {

    extended_ram.name = "extram";
    extended_ram.is_default = true;
    extended_ram.start = (void *)0x88200000;
    extended_ram.end = (void *)0x884e0000;

    kmalloc_init_arena(&extended_ram, true);
    kmalloc_add_arena(&extended_ram);
    return true;
  } else {
    return false;
  }
}

void FreeMoreRAM(void) {
  memset(extended_ram.start, 0,
         (char *)extended_ram.end - (char *)extended_ram.start);
}

int main(void) {
  exitToOS = false;

  _uram = kmalloc_get_arena("_uram");

  bool canWeAllocate3Mb = AddMoreRAM();

  __printf_enable_fp();
  __printf_enable_fixed();

  azrp_config_scale(SCALE_PIXEL);

  azrp_shader_clear_configure();
  azrp_shader_image_rgb16_configure();
  azrp_shader_image_p8_configure();
  azrp_shader_image_p4_configure();
  azrp_shader_line_configure();
  azrp_shader_circle_configure();

  azrp_hook_set_prefrag(hook_prefrag);

  usb_interface_t const *interfaces[] = {&usb_ff_bulk, NULL};
  usb_open(interfaces, GINT_CALL_NULL);

  // MyLevel.ChangeMap(2, &MyPlayer);

  prof_init();

  int pointX[4] = { 50, 100, 150, 100 };
  int pointY[4] = { 80, 20, 100, 170 };

  do {
    perf_update = prof_make();
    prof_enter(perf_update);

    {
      // all the stuff to be update should be put here
      MyKeyboard.Update(elapsedTime);
      get_inputs(elapsedTime);

      update(elapsedTime);

      // update the RAM consumption status
      _uram_stats = kmalloc_get_gint_stats(_uram);
      extram_stats = kmalloc_get_gint_stats(&extended_ram);
    }

    prof_leave(perf_update);
    time_update = prof_time(perf_update);

    perf_render = prof_make();
    prof_enter(perf_render);

    {
      // all the stuff to be rendered should be put here
      azrp_clear(backcolor);

      render();
      
      azrp_filledcircle((int)MyPlayer.nextx, (int)MyPlayer.nexty, 24, C_GREEN);
      azrp_filledcircle((int)MyPlayer.currx, (int)MyPlayer.curry, 16, C_BLUE);
      azrp_filledcircle((int)MyPlayer.currx, (int)MyPlayer.curry, 8, C_RED);


      azrp_filledpoly( pointX, pointY, 4, C_RED );
      azrp_poly( pointX, pointY, 4, C_WHITE );

      azrp_line((int)MyPlayer.currx - 3, (int)MyPlayer.curry,
                (int)MyPlayer.currx + 3, (int)MyPlayer.curry, C_GREEN);
      azrp_line((int)MyPlayer.currx, (int)MyPlayer.curry - 3,
                (int)MyPlayer.currx, (int)MyPlayer.curry + 3, C_GREEN);

      azrp_line((int)MyPlayer.nextx - 3, (int)MyPlayer.nexty,
                (int)MyPlayer.nextx + 3, (int)MyPlayer.nexty, C_BLUE);
      azrp_line((int)MyPlayer.nextx, (int)MyPlayer.nexty - 3,
                (int)MyPlayer.nextx, (int)MyPlayer.nexty + 3, C_BLUE);

      azrp_update();
    }

    prof_leave(perf_render);
    time_render = prof_time(perf_render);

    elapsedTime = ((float)(time_update + time_render)) / 1000.0f;

  } while (exitToOS == false);

  prof_quit();
  usb_close();

  FreeMoreRAM();

  return 1;
}