#include <genesis.h>
#include "resources.h"

// 迷路サイズ（タイル単位）※奇数で壁1マス厚の通路生成
#define MAZE_W 39
#define MAZE_H 27

// タイル番号（VRAM上のインデックス）
#define TILE_BASE     TILE_USER_INDEX
#define TILE_PATH     (TILE_BASE + 0)  // 0: 通路
#define TILE_WALL     (TILE_BASE + 1)  // 1: 壁
#define TILE_GOAL     (TILE_BASE + 2)  // 2: ゴール

// プレイヤー移動関連
#define STEP_PIXELS       8
#define FRAMES_PER_PIXEL  2
#define STEP_FRAMES       (STEP_PIXELS * FRAMES_PER_PIXEL)

#define PAD1 JOY_1

// 迷路データ：0=通路, 1=壁, 2=ゴール
static u8 maze[MAZE_H][MAZE_W];

// ヘルパー：方向をシャッフル
static inline void shuffleDirs(s16 dirs[4])
{
  for (s16 i = 3; i > 0; i--)
  {
    s16 j = random() % (i + 1);
    s16 tmp = dirs[i];
    dirs[i] = dirs[j];
    dirs[j] = tmp;
  }
}

// 再帰的バックトラッキング（セル間隔2で掘る）
static void carve(s16 x, s16 y)
{
  maze[y][x] = 0; // 通路にする

  // 方向ベクトル（上, 右, 下, 左）
  static const s16 dirX[4] = { 0,  1,  0, -1 };
  static const s16 dirY[4] = { -1, 0,  1,  0 };

  s16 dirs[4] = {0, 1, 2, 3};
  shuffleDirs(dirs);

  for (u16 i = 0; i < 4; i++)
  {
    s16 d  = dirs[i];
    s16 nx = x + dirX[d] * 2;
    s16 ny = y + dirY[d] * 2;

    // 範囲を (1,1) ～ (MAZE_W-2, MAZE_H-2) に制限
    if (nx >= 1 && nx < (MAZE_W - 1) && ny >= 1 && ny < (MAZE_H - 1))
    {
      if (maze[ny][nx] == 1)
      {
        // 間の壁を通路に
        maze[y + dirY[d]][x + dirX[d]] = 0;
        carve(nx, ny);
      }
    }
  }
}

// 迷路生成
static void generateMaze(void)
{
  // すべて壁に
  for (u16 y = 0; y < MAZE_H; y++)
    for (u16 x = 0; x < MAZE_W; x++)
      maze[y][x] = 1;

  // (1,1) から掘る
  carve(1, 1);

  // ゴール（右下 - 1マス内側）を通路に
  maze[MAZE_H - 2][MAZE_W - 2] = 0;
}

// 迷路描画（BG_B / パレット1）
static void drawMaze(void)
{
  VDP_loadTileSet(maze_tiles.tileset, TILE_BASE, DMA);
  PAL_setPalette(PAL1, maze_tiles.palette->data, DMA);

  for (u16 y = 0; y < MAZE_H; y++)
  {
    for (u16 x = 0; x < MAZE_W; x++)
    {
      u16 tileIndex = TILE_WALL;
      if (maze[y][x] == 0) tileIndex = TILE_PATH;
      if (x == (MAZE_W - 2) && y == (MAZE_H - 2)) tileIndex = TILE_GOAL;

      u16 attr = TILE_ATTR_FULL(PAL1, 0, 0, 0, tileIndex);
      VDP_setTileMapXY(BG_B, attr, x, y);
    }
  }
}

// テキスト表示（BG_A）
static void printCentered(const char* msg, u16 y)
{
  u16 len = strlen(msg);
  s16 x = (40 - len) / 2;
  if (x < 0) x = 0;
  VDP_drawText(msg, x, y);
}

// ボタン入力待ち
static void waitAnyButton(void)
{
  VDP_clearPlane(BG_A, TRUE);
  printCentered("HIT ANY BUTTON", 14);

  while (1)
  {
    u16 pad = JOY_readJoypad(PAD1);
    if (pad != 0) break;
    SYS_doVBlankProcess();
  }
  VDP_clearPlane(BG_A, TRUE);
}

// プレイヤー
static Sprite* playerSpr;
static s16 playerX, playerY;
static s16 targetX, targetY;
static s16 moveDX, moveDY;
static s16 moveFrameCount;

static inline u16 tileAt(s16 px, s16 py)
{
  s16 tx = px / 8;
  s16 ty = py / 8;
  if (tx < 0 || ty < 0 || tx >= MAZE_W || ty >= MAZE_H) return 1;
  if (tx == (MAZE_W - 2) && ty == (MAZE_H - 2)) return 2;
  return maze[ty][tx];
}

static inline bool canStartStep(s16 dirX, s16 dirY)
{
  s16 nextPX = playerX + dirX * STEP_PIXELS;
  s16 nextPY = playerY + dirY * STEP_PIXELS;
  u16 t = tileAt(nextPX, nextPY);
  return (t == 0 || t == 2);
}

static void beginStep(s16 dirX, s16 dirY)
{
  moveDX = dirX;
  moveDY = dirY;
  targetX = playerX + dirX * STEP_PIXELS;
  targetY = playerY + dirY * STEP_PIXELS;
  moveFrameCount = STEP_FRAMES;
}

static void updatePlayer(void)
{
  if (moveFrameCount > 0)
  {
    if ((moveFrameCount % FRAMES_PER_PIXEL) == 0)
    {
      playerX += moveDX;
      playerY += moveDY;
      SPR_setPosition(playerSpr, playerX, playerY);
    }
    moveFrameCount--;
    if (moveFrameCount == 0)
    {
      playerX = targetX;
      playerY = targetY;
      SPR_setPosition(playerSpr, playerX, playerY);
    }
    return;
  }

  u16 pad = JOY_readJoypad(PAD1);
  if (pad & BUTTON_UP)    { if (canStartStep(0, -1)) beginStep(0, -1); }
  else if (pad & BUTTON_DOWN) { if (canStartStep(0,  1)) beginStep(0,  1); }
  else if (pad & BUTTON_LEFT) { if (canStartStep(-1, 0)) beginStep(-1, 0); }
  else if (pad & BUTTON_RIGHT){ if (canStartStep( 1, 0)) beginStep( 1, 0); }
}

// ゴール判定
static void checkGoal(void)
{
  s16 tx = playerX / 8;
  s16 ty = playerY / 8;
  if (tx == (MAZE_W - 2) && ty == (MAZE_H - 2))
  {
    printCentered("GOAL!", 1);
  }
}

// メイン
int main(bool hard)
{
  VDP_setScreenWidth320();
  VDP_clearPlane(BG_A, TRUE);
  VDP_clearPlane(BG_B, TRUE);

  SPR_init();
  PAL_setPalette(PAL2, player.palette->data, DMA);

  waitAnyButton();
  setRandomSeed(getTick());

  generateMaze();
  drawMaze();

  playerX = 8; // タイル(1,1) → ピクセル(8,8)
  playerY = 8;
  playerSpr = SPR_addSprite(&player, playerX, playerY, 
                            TILE_ATTR(PAL2, 0, FALSE, FALSE));

  while (1)
  {
    updatePlayer();
    checkGoal();
    SPR_update();
    SYS_doVBlankProcess();
  }

  return 0;
}
