#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#define TRUE 1
#define FALSE 0
#define NUM_NEIGBHORS 8

typedef struct
  {
    int value;
    int is_mine;
    int revealed;
  } spot;

spot **build_matrix(spot **matrix, int size);
void print_matrix(spot **a, int size);
void print_line(int size);
void spread_mines(spot **matrix, int size, int mines);
void neighbor_value(spot **matrix,int size, int v, int h);
void empty_matrix(spot **a, int size);
void print_row_numbers(int size);
void move(spot **a, int size, int *revealed);
void spot_consequence(spot **a,int size,int v,int h, int *revealed);
void open_area(spot **a,int size,int v,int h, int *revealed);
int in_matrix(int v, int h, int size);

int main()
{
  int mines;
  spot **matrix;
  int matrix_size;
  int number_of_revealed = 0; //move index
  srand(time(NULL));

  printf("Enter size:\n");
  scanf("%d",&matrix_size);

  matrix = build_matrix(matrix,matrix_size);

  empty_matrix(matrix,matrix_size);

  print_matrix(matrix,matrix_size);

  printf("Enter amount of mines:\n");
  scanf("%d",&mines);

  spread_mines(matrix, matrix_size, mines);
  while (number_of_revealed < matrix_size*matrix_size-mines)
  {
    printf("Enter spot:\n");
    move(matrix,matrix_size,&number_of_revealed);
    printf("revealed: %d\n",number_of_revealed);
    print_matrix(matrix,matrix_size);
  }
  printf("\nWe have a winner!!\n");
  return 0;
}

void empty_matrix(spot **a, int size)
{
  int i,j; //loop indexs

  for (i=0; i<size; i++)
    for (j=0; j<size; j++)
    {
      a[i][j].value=0;
      a[i][j].revealed=FALSE;
      a[i][j].is_mine=FALSE;
    }
}

spot **build_matrix(spot **matrix, int size)
{
  spot **temp; //temporary matrix array
  int i; //loop index
  if ((matrix = (spot **) malloc (sizeof(spot *))) == NULL)
  {
    printf("could not allocate matrix !!");
    exit(1);
  }
  if ((temp = (spot **) realloc (matrix, size*sizeof(spot *))) == NULL)
  {
    printf("could not allocate temp !!");
    exit(1);
  }

  for (i=0; i<size; i++)
    if ((matrix[i] = (spot *) malloc (size*sizeof(spot))) == NULL)
    {
      printf("could not allocate matrix[%d]",i);
      exit(1);
    }
  return matrix;
}

void print_matrix(spot **a, int size)
{
  int i,j; //loop indexs

  printf("\n");
  print_row_numbers(size);
  printf("\n");
  print_line(size);
  printf("\n");
  for (i=0; i<size; i++)
  {
    printf("%c|",toupper('a'+i));
    for (j=0; j<size; j++)
      if (a[i][j].revealed == TRUE)
    if (a[i][j].is_mine == TRUE)
      printf(" @ |");
    else
      if (a[i][j].value == 0)
        printf("   |");
      else
        printf(" %d |",a[i][j].value);
      else
    printf(" # |");
    printf("\n");
    print_line(size);
    printf("\n");
  }
}

void print_line(int size)
{
  int i; //loop index
  printf("  ");
  for (i=0; i<size; i++)
    printf("----");
}

void spread_mines(spot **matrix, int size, int mines)
{
  int i=0; //loop index
  int v,h;//location

  while (i<mines)
  {
    v = rand()%size;
    h = rand()%size;
    if (matrix[v][h].is_mine == FALSE)
    {
      matrix[v][h].is_mine = TRUE;
      i++;
      neighbor_value(matrix,size,v,h);
    }
  }
}


void neighbor_value(spot **matrix,int size, int v, int h)
{
  int neighborv[NUM_NEIGBHORS] = { 1, 1, 1 ,0 ,0,-1,-1,-1};
  int neighborh[NUM_NEIGBHORS] = {-1, 0, 1,-1 ,1, -1, 0,1};
  int new_h=0, new_v=0;
  int i,j; //loop indexs

  for (i=0; i<NUM_NEIGBHORS; i++)
  {
    new_h = h + neighborh[i];
    new_v = v + neighborv[i];
    if (in_matrix(new_v,new_h,size))
      if (matrix[new_v][new_h].is_mine != TRUE)
    matrix[new_v][new_h].value++;
  }
}

void move(spot **a, int size,int *revealed)
{
  char v;
  int h;
  int n_v; //v as verticle number

  v = getchar();
  while (!isalpha(v))
    v = getchar();
  scanf("%d",&h);
  n_v = tolower(v) - 'a';
  while (n_v<0 || n_v>=size || h<0 || h>size)
  {
    printf("Invalid spot. Try again:\n");
    v = getchar();
    while (!isalpha(v))
      v = getchar();
    scanf("%d",&h);
    n_v = tolower(v) - 'a';
  }
  spot_consequence(a,size,n_v,h-1,revealed);

}

void print_row_numbers(int size)
{
  int i;
  printf("  ");
  for (i=0; i<size; i++)
    i<9 ? printf(" %d  ",i+1) : printf(" %d ",i+1);
}

void spot_consequence(spot **a,int size,int v,int h,int *revealed)
{
  if (a[v][h].is_mine)
  {
    a[v][h].revealed = TRUE;
    printf("BOMB!!!\n");
    print_matrix(a,size);
    exit(1);
  }
  open_area(a,size,v,h,revealed);
}

void open_area(spot **a,int size,int v,int h,int *revealed)
{
  static int nv[NUM_NEIGBHORS] = { 1, 1, 1 ,0 ,0,-1,-1,-1};
  static int nh[NUM_NEIGBHORS] = {-1, 0, 1,-1 ,1, -1, 0,1};

  int new_v, new_h;
  int i;

  if (a[v][h].revealed == TRUE)
    return;

  a[v][h].revealed = TRUE;
  *revealed=*revealed +1;

  if (a[v][h].value != 0)
    return;

  for (i=0; i<NUM_NEIGBHORS; i++)
  {
//     printf("%d",i);
    new_v = v+nv[i];
    new_h = h+nh[i];
    if (in_matrix(new_v,new_h,size))
      open_area(a,size,new_v,new_h,revealed);
  }
}

int in_matrix(int v, int h, int size)
{
  if (h >= 0 && v >= 0 && h < size && v < size)
    return 1;
  return 0;
}