#include <tty.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <new_tty.h>

#include <builtin_games/miner.h>

/*
  static const size_t VGA_WIDTH = 80;
  static const size_t VGA_HEIGHT = 25;
*/

/* clear screen */
void cls(void)
{
  terminal_clear();
}

static bool pointer_valid(void* ptr)
{
  if (ptr/* && (ptr < (heap_end + 4096))*/)
  {
    return true;
  }

  return false;
}

static inline bool valid_pointer(void* ptr)
{
  return pointer_valid(ptr);
}

/*const char PLAYER = '@';
const char ENEMY  = '*';
const char PLAYER_BULLET = '^';
const char ENEMY_BULLET  = '`'
const char BOMB = '*';
const char EMPTY = ' ';*/

#define MAP_ROWS 25
#define MAP_COLUMNS 25

#define PLAYER_STARTING_POS (MAP_COLUMNS / 2) /* for MAP_COLUMNS being 25, this will be 12. */

#define STARTING_ENEMY_NUM 4

enum {
  PLAYER = '@',
  PLAYER_BULLET = '^',
  ENEMY = '%',
  ENEMY_BULLET = '`',
  BOMB = '*',
  EMPTY = ' ',
};

struct bullet {
  bool players; /* if enemies, false */

  int row;
  int column;
};

struct game_vars {
  tty_t* tty;
  uint32_t stored_tty_flags;

  int v;

  char c;

  int player_score;
  int player_credits;

  bool error;

  int num_enemies;
  int num_enemy_step;
  char** map; /* char map[MAP_ROWS][MAP_COLUMNS] */

  bool enemys[MAP_COLUMNS]; /* enemy bitmap */

  struct bullet* bullets;
  int num_bullets;
};


void init_map(struct game_vars* gv)
{
  for (int i = 0; i < MAP_ROWS; i++)
  {
    for (int j = 0; j < MAP_COLUMNS; j++)
    {
      gv->map[i][j] = EMPTY;
    }
  }
  
  gv->map[0][PLAYER_STARTING_POS] = PLAYER;

  int enemy_pos = 0;

  for (int b = 0; b < STARTING_ENEMY_NUM; b++)
  {
    gv->map[24][enemy_pos] = ENEMY;
    enemy_pos++;
    gv->num_enemies++;
    gv->enemys[b] = true;
  }

  if (!valid_pointer(gv->map))
  {
    gv->error = true;
  }
}

void ai(struct game_vars* gv)
{
  for (int i = 0; i < MAP_COLUMNS; i++)
  {
    if ((gv->map[24][i] == ENEMY) && (gv->map[0][i] == PLAYER))
    {
      gv->map[23][i] = ENEMY_BULLET;
      int num_bullets = gv->num_bullets;
      gv->bullets[num_bullets].players = false;
      gv->bullets[num_bullets].column = i;
      gv->bullets[num_bullets].row = 23;
      gv->num_bullets++;
    }
  }
}

void tick(struct game_vars* gv)
{
  for (int i = 0; i < gv->num_bullets; i++)
  {
    struct bullet* b = &gv->bullets[i];
    gv->map[b->row][b->column] = EMPTY;
    b->column++;
    b->row++;
    gv->map[b->row][b->column] = b->players ? PLAYER_BULLET : ENEMY_BULLET;
  }
}

int init_game(struct game_vars* ptr)
{
  if (ptr)
  {
    ptr->error = false;
    
    init_map(ptr);
    
    ptr->num_enemy_step++;
    
    return 0;
  }

  return -1;
}

void miner_main(void)
{
#if 0
  cls();

  struct game_vars gv = { .tty = get_active_tty(), .stored_tty_flags = tty_get_flags(get_active_tty()),
                          .v = 0, .c = 0,
                          .player_score = 0, .player_credits = 0,
                          .error = false,
                          .num_enemies = STARTING_ENEMY_NUM, .num_enemy_step = 0,
                          .map = malloc(MAP_COLUMNS * MAP_ROWS),
                          .bullets = NULL, .num_bullets = 0,
                        };

  memset(gv.enemys, 0, sizeof(gv.enemys));

  if (!gv.map)
  {
    goto quit;
  }

  printf("gv.map = %p\n", gv.map);

  gv.tty->flags |= TTY_RAW;
  gv.tty->flags &= ~TTY_CANONICAL;
  gv.tty->flags &= ~TTY_ECHO; /* disable echo */

  printf("\n\tMiner\n\t\tMine ores to sell for money and upgrade your drone\n\n\n\t\t\tHIT ENTER TO CONTINUE, TAB TO EXIT\n");

  /*while (gv.c != '\n' && gv.c != '\t')
  {
    gv.c = getchar();
  }

  if (gv.c == '\t')
  {
    goto quit;
  }

  cls();*/

  while (1)
  {
    gv.c = getchar();
    
    if (gv.c == '\t')
    {
      goto quit;
    }
    
    sleep(500);
  }

quit:

  gv.tty->flags = gv.stored_tty_flags;
  if (gv.map && pointer_valid(gv.map))
  {
    free(gv.map);
  }

  cls();

  printf("Goodbye!\n");

  sleep(2000);

  cls();
#endif
}