#include "overworld_map.h"

#include "Data/rom.h"
#include "Graphics/tile.h"

namespace yaze {
namespace Application {
namespace Data {

using namespace Core;
using namespace Graphics;

OverworldMap::OverworldMap(Data::ROM rom,
                           const std::vector<Graphics::Tile16> tiles16,
                           byte index)
    : rom_(rom), index(index), tiles16_(tiles16), parent(index) {
  if (index != 0x80) {
    if (index <= 150) {
      if (rom_.GetRawData()[Constants::overworldMapSize + (index & 0x3F)] !=
          0) {
        largeMap = true;
      }
    }
  }

  if (index < 64) {
    sprgfx[0] = rom_.GetRawData()[Constants::overworldSpriteset + parent];
    sprgfx[1] = rom_.GetRawData()[Constants::overworldSpriteset + parent + 64];
    sprgfx[2] = rom_.GetRawData()[Constants::overworldSpriteset + parent + 128];
    gfx = rom_.GetRawData()[Constants::mapGfx + parent];
    palette = rom_.GetRawData()[Constants::overworldMapPalette + parent];
    sprpalette[0] =
        rom_.GetRawData()[Constants::overworldSpritePalette + parent];
    sprpalette[1] =
        rom_.GetRawData()[Constants::overworldSpritePalette + parent + 64];
    sprpalette[2] =
        rom_.GetRawData()[Constants::overworldSpritePalette + parent + 128];
    musics[0] = rom_.GetRawData()[Constants::overworldMusicBegining + parent];
    musics[1] = rom_.GetRawData()[Constants::overworldMusicZelda + parent];
    musics[2] =
        rom_.GetRawData()[Constants::overworldMusicMasterSword + parent];
    musics[3] = rom_.GetRawData()[Constants::overworldMusicAgahim + parent];
  } else if (index < 128) {
    sprgfx[0] = rom_.GetRawData()[Constants::overworldSpriteset + parent + 128];
    sprgfx[1] = rom_.GetRawData()[Constants::overworldSpriteset + parent + 128];
    sprgfx[2] = rom_.GetRawData()[Constants::overworldSpriteset + parent + 128];
    gfx = rom_.GetRawData()[Constants::mapGfx + parent];
    palette = rom_.GetRawData()[Constants::overworldMapPalette + parent];
    sprpalette[0] =
        rom_.GetRawData()[Constants::overworldSpritePalette + parent + 128];
    sprpalette[1] =
        rom_.GetRawData()[Constants::overworldSpritePalette + parent + 128];
    sprpalette[2] =
        rom_.GetRawData()[Constants::overworldSpritePalette + parent + 128];

    musics[0] = rom_.GetRawData()[Constants::overworldMusicDW + (parent - 64)];
  } else {
    if (index == 0x94) {
      parent = 128;
    } else if (index == 0x95) {
      parent = 03;
    } else if (index == 0x96)  // pyramid bg use 0x5B map
    {
      parent = 0x5B;
    } else if (index == 0x97)  // pyramid bg use 0x5B map
    {
      parent = 0x00;
    } else if (index == 156) {
      parent = 67;
    } else if (index == 157) {
      parent = 0;
    } else if (index == 158) {
      parent = 0;
    } else if (index == 159) {
      parent = 44;
    } else if (index == 136) {
      parent = 136;
    }

    messageID = rom_.GetRawData()[Constants::overworldMessages + parent];

    sprgfx[0] = rom_.GetRawData()[Constants::overworldSpriteset + parent + 128];
    sprgfx[1] = rom_.GetRawData()[Constants::overworldSpriteset + parent + 128];
    sprgfx[2] = rom_.GetRawData()[Constants::overworldSpriteset + parent + 128];
    sprpalette[0] =
        rom_.GetRawData()[Constants::overworldSpritePalette + parent + 128];
    sprpalette[1] =
        rom_.GetRawData()[Constants::overworldSpritePalette + parent + 128];
    sprpalette[2] =
        rom_.GetRawData()[Constants::overworldSpritePalette + parent + 128];

    palette =
        rom_.GetRawData()[Constants::overworldSpecialPALGroup + parent - 128];
    if (index >= 0x80 && index <= 0x8A && index != 0x88) {
      gfx = rom_.GetRawData()[Constants::overworldSpecialGFXGroup +
                              (parent - 128)];
      palette = rom_.GetRawData()[Constants::overworldSpecialPALGroup + 1];
    } else if (index == 0x88) {
      gfx = 81;
      palette = 0;
    } else  // pyramid bg use 0x5B map
    {
      gfx = rom_.GetRawData()[Constants::mapGfx + parent];
      palette = rom_.GetRawData()[Constants::overworldMapPalette + parent];
    }
  }
}

void OverworldMap::BuildMap(byte* mapParent, int count, int gameState,
                            ushort** allmapsTilesLW, ushort** allmapsTilesDW,
                            ushort** allmapsTilesSP) {
  tilesUsed = new ushort*[32];
  for (int i = 0; i < 32; i++) tilesUsed[i] = new ushort;

  if (largeMap) {
    this->parent = mapParent[index];

    if (parent != index) {
      if (!firstLoad) {
        gfx = rom_.GetRawData()[Constants::mapGfx + parent];
        palette = rom_.GetRawData()[Constants::overworldMapPalette + parent];
        firstLoad = true;
      }
    }
  }

  BuildTileset(gameState);
  BuildTiles16Gfx(count);  // build on GFX.mapgfx16Ptr
  // LoadPalette();

  int world = 0;

  if (index < 64) {
    tilesUsed = allmapsTilesLW;
  } else if (index < 128 && index >= 64) {
    tilesUsed = allmapsTilesDW;
    world = 1;
  } else {
    tilesUsed = allmapsTilesSP;
    world = 2;
  }

  int superY = ((index - (world * 64)) / 8);
  int superX = index - (world * 64) - (superY * 8);

  for (int y = 0; y < 32; y++) {
    for (int x = 0; x < 32; x++) {
      CopyTile8bpp16((x * 16), (y * 16),
                     tilesUsed[x + (superX * 32)][y + (superY * 32)], gfxPtr,
                     mapblockset16);
    }
  }
}

void OverworldMap::CopyTile8bpp16(int x, int y, int tile, int* destbmpPtr,
                                  int* sourcebmpPtr) {
  int sourceY = (tile / 8);
  int sourceX = (tile) - ((sourceY)*8);
  int sourcePtrPos = ((tile - ((tile / 8) * 8)) * 16) +
                     ((tile / 8) * 2048);  //(sourceX * 16) + (sourceY * 128);
  byte* sourcePtr = (byte*)sourcebmpPtr;

  int destPtrPos = (x + (y * 512));
  byte* destPtr = (byte*)destbmpPtr;

  for (int ystrip = 0; ystrip < 16; ystrip++) {
    for (int xstrip = 0; xstrip < 16; xstrip++) {
      destPtr[destPtrPos + xstrip + (ystrip * 512)] =
          sourcePtr[sourcePtrPos + xstrip + (ystrip * 128)];
    }
  }
}

void OverworldMap::CopyTile8bpp16From8(int xP, int yP, int tileID,
                                       int* destbmpPtr, int* sourcebmpPtr) {
  auto gfx16Data = (byte*)destbmpPtr;

  auto gfx8Data = currentOWgfx16Ptr;

  int offsets[] = {0, 8, 4096, 4104};

  auto tiles = tiles16_[tileID];

  for (auto tile = 0; tile < 4; tile++) {
    TileInfo info = tiles.tiles_info[tile];
    int offset = offsets[tile];

    for (auto y = 0; y < 8; y++) {
      for (auto x = 0; x < 4; x++) {
        CopyTileToMap(x, y, xP, yP, offset, info, gfx16Data, gfx8Data);
      }
    }
  }
}

void OverworldMap::BuildTiles16Gfx(int count) {
  byte* gfx16Data = (byte*)mapblockset16;
  byte* gfx8Data = currentOWgfx16Ptr;

  int offsets[] = {0, 8, 1024, 1032};
  auto yy = 0;
  auto xx = 0;

  for (auto i = 0; i < count; i++)  // number of tiles16 3748?
  {
    // 8x8 tile draw
    // gfx8 = 4bpp so everyting is /2F
    auto tiles = tiles16_[i];

    for (auto tile = 0; tile < 4; tile++) {
      TileInfo info = tiles16_[i].tiles_info[tile];
      int offset = offsets[tile];

      for (auto y = 0; y < 8; y++) {
        for (auto x = 0; x < 4; x++) {
          CopyTile(x, y, xx, yy, offset, info, gfx16Data, gfx8Data);
        }
      }
    }

    xx += 16;
    if (xx >= 128) {
      yy += 2048;
      xx = 0;
    }
  }
}

void OverworldMap::CopyTile(int x, int y, int xx, int yy, int offset,
                            TileInfo tile, byte* gfx16Pointer,
                            byte* gfx8Pointer)  // map,current
{
  int mx = x;
  int my = y;
  byte r = 0;

  if (tile.horizontal_mirror_ != 0) {
    mx = 3 - x;
    r = 1;
  }

  if (tile.vertical_mirror_ != 0) {
    my = 7 - y;
  }

  int tx = ((tile.id_ / 16) * 512) + ((tile.id_ - ((tile.id_ / 16) * 16)) * 4);
  auto index = xx + yy + offset + (mx * 2) + (my * 128);
  auto pixel = gfx8Pointer[tx + (y * 64) + x];

  gfx16Pointer[index + r ^ 1] = (byte)((pixel & 0x0F) + tile.palette_ * 16);
  gfx16Pointer[index + r] = (byte)(((pixel >> 4) & 0x0F) + tile.palette_ * 16);
}

void OverworldMap::CopyTileToMap(int x, int y, int xx, int yy, int offset,
                                 TileInfo tile, byte* gfx16Pointer,
                                 byte* gfx8Pointer)  // map,current
{
  int mx = x;
  int my = y;
  byte r = 0;

  if (tile.horizontal_mirror_ != 0) {
    mx = 3 - x;
    r = 1;
  }

  if (tile.vertical_mirror_ != 0) {
    my = 7 - y;
  }

  int tx = ((tile.id_ / 16) * 512) + ((tile.id_ - ((tile.id_ / 16) * 16)) * 4);
  auto index = xx + (yy * 512) + offset + (mx * 2) + (my * 512);
  auto pixel = gfx8Pointer[tx + (y * 64) + x];

  gfx16Pointer[index + r ^ 1] = (byte)((pixel & 0x0F) + tile.palette_ * 16);
  gfx16Pointer[index + r] = (byte)(((pixel >> 4) & 0x0F) + tile.palette_ * 16);
}

/*
void OverworldMap::LoadPalette() {
  int previousPalId = 0;
  int previousSprPalId = 0;
  if (index > 0) {
    previousPalId =
        rom_.GetRawData()[Constants::overworldMapPalette + parent - 1];
    previousSprPalId =
        rom_.GetRawData()[Constants::overworldSpritePalette + parent - 1];
  }

  if (palette >= 0xA3) {
    palette = 0xA3;
  }

  byte pal0 = 0;

  byte pal1 = rom_.GetRawData()[Constants::overworldMapPaletteGroup +
                                (palette * 4)];  // aux1
  byte pal2 = rom_.GetRawData()[Constants::overworldMapPaletteGroup +
                                (palette * 4) + 1];  // aux2
  byte pal3 = rom_.GetRawData()[Constants::overworldMapPaletteGroup +
                                (palette * 4) + 2];  // animated

  byte pal4 = rom_.GetRawData()[Constants::overworldSpritePaletteGroup +
                                (sprpalette[ow_.gameState] * 2)];  // spr3
  byte pal5 = rom_.GetRawData()[Constants::overworldSpritePaletteGroup +
                                (sprpalette[ow_.gameState] * 2) + 1];  // spr4

  ImVec4 aux1, aux2, main, animated, hud, spr, spr2;
  ImVec4 bgr = Palettes.overworld_GrassPalettes[0];

  if (pal1 == 255) {
    pal1 = rom_.GetRawData()[Constants::overworldMapPaletteGroup +
                             (previousPalId * 4)];
  }
  if (pal1 != 255) {
    if (pal1 >= 20) {
      pal1 = 19;
    }

    aux1 = Palettes.overworld_AuxPalettes[pal1];
  } else {
    aux1 = Palettes.overworld_AuxPalettes[0];
  }

  if (pal2 == 255) {
    pal2 = rom_.GetRawData()[Constants::overworldMapPaletteGroup +
                             (previousPalId * 4) + 1];
  }
  if (pal2 != 255) {
    if (pal2 >= 20) {
      pal2 = 19;
    }

    aux2 = Palettes.overworld_AuxPalettes[pal2];
  } else {
    aux2 = Palettes.overworld_AuxPalettes[0];
  }

  if (pal3 == 255) {
    pal3 = rom_.GetRawData()[Constants::overworldMapPaletteGroup +
                             (previousPalId * 4) + 2];
  }

  if (parent < 0x40) {
    // default LW Palette
    pal0 = 0;
    bgr = Palettes.overworld_GrassPalettes[0];
    // hardcoded LW DM palettes if we are on one of those maps (might change
    // it to read game code)
    if ((parent >= 0x03 && parent <= 0x07)) {
      pal0 = 2;
    } else if (parent >= 0x0B && parent <= 0x0E) {
      pal0 = 2;
    }
  } else if (parent >= 0x40 && parent < 0x80) {
    bgr = Palettes.overworld_GrassPalettes[1];
    // default DW Palette
    pal0 = 1;
    // hardcoded DW DM palettes if we are on one of those maps (might change
    // it to read game code)
    if (parent >= 0x43 && parent <= 0x47) {
      pal0 = 3;
    } else if (parent >= 0x4B && parent <= 0x4E) {
      pal0 = 3;
    }
  }

  if (parent == 0x88) {
    pal0 = 4;
  }
  /*else if (parent >= 128) //special area like Zora's domain, etc...
  {
      bgr = Palettes.overworld_GrassPalettes[2];
      pal0 = 4;
  }

  if (pal0 != 255) {
    main = Palettes.overworld_MainPalettes[pal0];
  } else {
    main = Palettes.overworld_MainPalettes[0];
  }

  if (pal3 >= 14) {
    pal3 = 13;
  }
  animated = Palettes.overworld_AnimatedPalettes[(pal3)];

  hud = Palettes.HudPalettes[0];
  if (pal4 == 255) {
    pal4 = rom_.GetRawData()[Constants::overworldSpritePaletteGroup +
                             (previousSprPalId * 2)];  // spr3
  }
  if (pal4 == 255) {
    pal4 = 0;
  }
  if (pal4 >= 24) {
    pal4 = 23;
  }
  spr = Palettes.spritesAux3_Palettes[pal4];

  if (pal5 == 255) {
    pal5 = rom_.GetRawData()[Constants::overworldSpritePaletteGroup +
                             (previousSprPalId * 2) + 1];  // spr3
  }
  if (pal5 == 255) {
    pal5 = 0;
  }
  if (pal5 >= 24) {
    pal5 = 23;
  }
  spr2 = Palettes.spritesAux3_Palettes[pal5];

  SetColorsPalette(parent, main, animated, aux1, aux2, hud, bgr, spr, spr2);
}


void OverworldMap::SetColorsPalette(int index, ImVec4 main, ImVec4 animated,
                                    ImVec4 aux1, ImVec4 aux2, ImVec4 hud,
                                    Color bgrcolor, ImVec4 spr, ImVec4 spr2) {
  // Palettes infos, color 0 of a palette is always transparent (the arrays
  // contains 7 colors width wide) there is 16 color per line so 16*Y

  // Left side of the palette - Main, Animated
  ImVec4 currentPalette = new Color[256];
  // Main Palette, Location 0,2 : 35 colors [7x5]
  int k = 0;
  for (int y = 2; y < 7; y++) {
    for (int x = 1; x < 8; x++) {
      currentPalette[x + (16 * y)] = main[k];
      k++;
    }
  }

  // Animated Palette, Location 0,7 : 7colors
  for (int x = 1; x < 8; x++) {
    currentPalette[(16 * 7) + (x)] = animated[(x - 1)];
  }

  // Right side of the palette - Aux1, Aux2

  // Aux1 Palette, Location 8,2 : 21 colors [7x3]
  k = 0;
  for (int y = 2; y < 5; y++) {
    for (int x = 9; x < 16; x++) {
      currentPalette[x + (16 * y)] = aux1[k];
      k++;
    }
  }

  // Aux2 Palette, Location 8,5 : 21 colors [7x3]
  k = 0;
  for (int y = 5; y < 8; y++) {
    for (int x = 9; x < 16; x++) {
      currentPalette[x + (16 * y)] = aux2[k];
      k++;
    }
  }

  // Hud Palette, Location 0,0 : 32 colors [16x2]
  k = 0;
  for (int i = 0; i < 32; i++) {
    currentPalette[i] = hud[i];
  }

  // Hardcoded grass color (that might change to become invisible instead)
  for (int i = 0; i < 8; i++) {
    currentPalette[(i * 16)] = bgrcolor;
    currentPalette[(i * 16) + 8] = bgrcolor;
  }

  // Sprite Palettes
  k = 0;
  for (int y = 8; y < 9; y++) {
    for (int x = 1; x < 8; x++) {
      currentPalette[x + (16 * y)] = Palettes.spritesAux1_Palettes[1][k];
      k++;
    }
  }

  // Sprite Palettes
  k = 0;
  for (int y = 8; y < 9; y++) {
    for (int x = 9; x < 16; x++) {
      currentPalette[x + (16 * y)] = Palettes.spritesAux3_Palettes[0][k];
      k++;
    }
  }

  // Sprite Palettes
  k = 0;
  for (int y = 9; y < 13; y++) {
    for (int x = 1; x < 16; x++) {
      currentPalette[x + (16 * y)] = Palettes.globalSprite_Palettes[0][k];
      k++;
    }
  }

  // Sprite Palettes
  k = 0;
  for (int y = 13; y < 14; y++) {
    for (int x = 1; x < 8; x++) {
      currentPalette[x + (16 * y)] = spr[k];
      k++;
    }
  }

  // Sprite Palettes
  k = 0;
  for (int y = 14; y < 15; y++) {
    for (int x = 1; x < 8; x++) {
      currentPalette[x + (16 * y)] = spr2[k];
      k++;
    }
  }

  // Sprite Palettes
  k = 0;
  for (int y = 15; y < 16; y++) {
    for (int x = 1; x < 16; x++) {
      currentPalette[x + (16 * y)] = Palettes.armors_Palettes[0][k];
      k++;
    }
  }

  try {
    ColorPalette pal = GFX.editort16Bitmap.Palette;
    for (int i = 0; i < 256; i++) {
      pal.Entries[i] = currentPalette[i];
      pal.Entries[(i / 16) * 16] = Color.Transparent;
    }

    GFX.mapgfx16Bitmap.Palette = pal;
    GFX.mapblockset16Bitmap.Palette = pal;

    for (int i = 0; i < 256; i++)
    {
        if (index == 3)
        {

        }
        else if (index == 4)
        {
            pal.Entries[(i / 16) * 16] = Color.Transparent;
        }
    }
    gfxBitmap.Palette = pal;
  } catch (Exception e) {
    // TODO: Add exception message.
  }
}
*/

void OverworldMap::BuildTileset(int gameState) {
  int indexWorld = 0x20;
  if (parent < 0x40) {
    indexWorld = 0x20;
  } else if (parent >= 0x40 && parent < 0x80) {
    indexWorld = 0x21;
  } else if (parent == 0x88) {
    indexWorld = 36;
  }

  // Sprites Blocksets
  staticgfx[8] = 115 + 0;
  staticgfx[9] = 115 + 1;
  staticgfx[10] = 115 + 6;
  staticgfx[11] = 115 + 7;
  for (int i = 0; i < 4; i++) {
    staticgfx[12 + i] =
        (byte)(rom_.GetRawData()[Constants::sprite_blockset_pointer +
                                 (sprgfx[gameState] * 4) + i] +
               115);
  }

  // Main Blocksets
  for (int i = 0; i < 8; i++) {
    staticgfx[i] = rom_.GetRawData()[Constants::overworldgfxGroups2 +
                                     (indexWorld * 8) + i];
  }

  if (rom_.GetRawData()[Constants::overworldgfxGroups + (gfx * 4)] != 0) {
    staticgfx[3] = rom_.GetRawData()[Constants::overworldgfxGroups + (gfx * 4)];
  }
  if (rom_.GetRawData()[Constants::overworldgfxGroups + (gfx * 4) + 1] != 0) {
    staticgfx[4] =
        rom_.GetRawData()[Constants::overworldgfxGroups + (gfx * 4) + 1];
  }
  if (rom_.GetRawData()[Constants::overworldgfxGroups + (gfx * 4) + 2] != 0) {
    staticgfx[5] =
        rom_.GetRawData()[Constants::overworldgfxGroups + (gfx * 4) + 2];
  }
  if (rom_.GetRawData()[Constants::overworldgfxGroups + (gfx * 4) + 3] != 0) {
    staticgfx[6] =
        rom_.GetRawData()[Constants::overworldgfxGroups + (gfx * 4) + 3];
  }

  // Hardcoded overworld GFX Values, for death mountain
  if ((parent >= 0x03 && parent <= 0x07) ||
      (parent >= 0x0B && parent <= 0x0E)) {
    staticgfx[7] = 89;
  } else if ((parent >= 0x43 && parent <= 0x47) ||
             (parent >= 0x4B && parent <= 0x4E)) {
    staticgfx[7] = 89;
  } else {
    staticgfx[7] = 91;
  }

  byte* currentmapgfx8Data = new byte[(128 * 512) / 2];
  // (byte*)GFX.currentOWgfx16Ptr.ToPointer();  // loaded gfx for the current
  //                                            // map (empty at this point)
  byte* allgfxData = new byte[(128 * 7136) / 2];
  // (byte*)GFX.allgfx16Ptr
  //     .ToPointer();  // all gfx of the game pack of 2048 bytes (4bpp)

  for (int i = 0; i < 16; i++) {
    for (int j = 0; j < 2048; j++) {
      byte mapByte = allgfxData[j + (staticgfx[i] * 2048)];
      switch (i) {
        case 0:
        case 3:
        case 4:
        case 5:
          mapByte += 0x88;
          break;
      }

      currentmapgfx8Data[(i * 2048) + j] = mapByte;  // Upload used gfx data
    }
  }
}

}  // namespace Data
}  // namespace Application
}  // namespace yaze