#include "globals.h"

#ifdef COUNTBITS16
s32bit countbits16[65536];

static void
init_countbits()
{
  s32bit i;
  
  countbits16[0] = 0;
  
  for(i = 1; i < 65536; i++){
    countbits16[i] = (i & 1) + countbits16[i >> 1];
  }
}
#endif

#ifdef COUNTBITS8
s32bit countbits8[256];

static void
init_countbits()
{
  s32bit i;
  
  countbits8[0] = 0;
  
  for(i = 1; i < 256; i++){
    countbits8[i] = (i & 1) + countbits8[i >> 1];
  }
}
#endif

#ifdef LASTBIT16
s32bit lastbit16[65536];

static void
init_lastbit()
{
  s32bit i;
  
  for(i = 1; i < 65536; i++){
    if(i&NTH_BIT(0)) {lastbit16[i] = 0; continue;}
    if(i&NTH_BIT(1)) {lastbit16[i] = 1; continue;}
    if(i&NTH_BIT(2)) {lastbit16[i] = 2; continue;}
    if(i&NTH_BIT(3)) {lastbit16[i] = 3; continue;}
    if(i&NTH_BIT(4)) {lastbit16[i] = 4; continue;}
    if(i&NTH_BIT(5)) {lastbit16[i] = 5; continue;}
    if(i&NTH_BIT(6)) {lastbit16[i] = 6; continue;}
    if(i&NTH_BIT(7)) {lastbit16[i] = 7; continue;}
    if(i&NTH_BIT(8)) {lastbit16[i] = 8; continue;}
    if(i&NTH_BIT(9)) {lastbit16[i] = 9; continue;}
    if(i&NTH_BIT(10)) {lastbit16[i] = 10; continue;}
    if(i&NTH_BIT(11)) {lastbit16[i] = 11; continue;}
    if(i&NTH_BIT(12)) {lastbit16[i] = 12; continue;}
    if(i&NTH_BIT(13)) {lastbit16[i] = 13; continue;}
    if(i&NTH_BIT(14)) {lastbit16[i] = 14; continue;}
    if(i&NTH_BIT(15)) {lastbit16[i] = 15; continue;}
  }
  
  lastbit16[0] = 100;
}
#endif

#ifdef LASTBIT8
s32bit lastbit8[256];

static void
init_lastbit()
{
  s32bit i;
  
  for(i = 1; i < 256; i++){
    if(i&NTH_BIT(0)) {lastbit8[i] = 0; continue;}
    if(i&NTH_BIT(1)) {lastbit8[i] = 1; continue;}
    if(i&NTH_BIT(2)) {lastbit8[i] = 2; continue;}
    if(i&NTH_BIT(3)) {lastbit8[i] = 3; continue;}
    if(i&NTH_BIT(4)) {lastbit8[i] = 4; continue;}
    if(i&NTH_BIT(5)) {lastbit8[i] = 5; continue;}
    if(i&NTH_BIT(6)) {lastbit8[i] = 6; continue;}
    if(i&NTH_BIT(7)) {lastbit8[i] = 7; continue;}
  }
  
  lastbit8[0] = 100;
}
#endif

#ifdef COUNTMOVES_TABLE
s32bit move_table16[65536];

static void
init_movetable()
{
  u32bit i = 0, mask, tmp = 0, count;
  
  while(i < 65536){
    mask = i;
    count = 0;
    
    while(mask){
      tmp = (mask&-mask);           // least sig bit of m
      mask &= ~(tmp | (tmp << 1));  // remove bit and next bit.
      count++;
    }

#ifndef BOARD_SIZE_LT_16
    if(tmp & 0x00008000) count |= 0xF0000000;
#endif    

    move_table16[i] = count;
    i++;
  }
}
#else
#define init_movetable() ;
#endif

extern void
init_static_tables()
{
  init_countbits();
  init_lastbit();
  init_movetable();
}


KeyInfo      g_keyinfo[2][32][32];

static void
negate_keyinfo(KeyInfo_s *keyinfo)
{
  keyinfo->bit1_index = keyinfo->bit2_index = -1;
  keyinfo->hash_code = 0;
}

      
static void
fill_in_hash_code(KeyInfo_s *info, s32bit num_cols)
{
  s32bit r, c, hash = 0;
    
  r = info->bit1_index/num_cols;
  c = info->bit1_index%num_cols;
  
  hash = g_zobrist[r+1][c+1];
  
  r = info->bit2_index/num_cols;
  c = info->bit2_index%num_cols;
  
  hash ^= g_zobrist[r+1][c+1];

  info->hash_code = hash;
}


static void
fill_in_key_entry(KeyInfo *keyinfo, s32bit num_rows, s32bit num_cols)
{
  if(keyinfo->norm.bit1_index == -1){
    negate_keyinfo( & keyinfo->norm);
    negate_keyinfo( & keyinfo->flipV);
    negate_keyinfo( & keyinfo->flipH);
    negate_keyinfo( & keyinfo->flipVH);
  } else {
    s32bit r1, c1, r2, c2;
    
    r1 = keyinfo->norm.bit1_index/num_cols;
    c1 = keyinfo->norm.bit1_index%num_cols;
    r2 = keyinfo->norm.bit2_index/num_cols;
    c2 = keyinfo->norm.bit2_index%num_cols;
  
    keyinfo->flipV.bit1_index  = (r1*num_cols)+(num_cols - c1 - 1);
    keyinfo->flipV.bit2_index  = (r2*num_cols)+(num_cols - c2 - 1);

    keyinfo->flipH.bit1_index  = ((num_rows - r1 - 1) * num_cols) + c1;
    keyinfo->flipH.bit2_index  = ((num_rows - r2 - 1) * num_cols) + c2;

    keyinfo->flipVH.bit1_index = ( ((num_rows - r1 - 1) * num_cols)
                                   + (num_cols - c1 - 1) );
    keyinfo->flipVH.bit2_index = ( ((num_rows - r2 - 1) * num_cols)
                                   + (num_cols - c2 - 1) );

    fill_in_hash_code( & keyinfo->norm, num_cols);
    fill_in_hash_code( & keyinfo->flipV, num_cols);
    fill_in_hash_code( & keyinfo->flipH, num_cols);
    fill_in_hash_code( & keyinfo->flipVH, num_cols);
  }
}


extern void
init_less_static_tables()
{
  s32bit n_rows, n_cols, i, j, k;
  
  n_rows = g_board_size[HORIZONTAL], n_cols = g_board_size[VERTICAL];
  
  for(i = 0; i < 32; i++)
    for(j = 0; j < 32; j++)
      for(k = 0; k < 2; k++)
        negate_keyinfo( & g_keyinfo[k][i][j].norm);
  
  for(i = 0; i < n_rows; i++){
    for(j = 0; j < n_cols; j++){
      //Horizontal Entry
      if(j + 1 < n_cols){
        g_keyinfo[HORIZONTAL][i+1][j+1].norm.bit1_index = (i*n_cols)+j;
        g_keyinfo[HORIZONTAL][i+1][j+1].norm.bit2_index = (i*n_cols)+(j+1);
      }
      
      //Vertical Entry
      if(i + 1 < n_rows){
        g_keyinfo[VERTICAL][j+1][i+1].norm.bit1_index   = (i*n_cols)+j;
        g_keyinfo[VERTICAL][j+1][i+1].norm.bit2_index   = ((i+1)*n_cols)+j;
      }
    }
  }
  
  for(i = 0; i < 32; i++)
    for(j = 0; j < 32; j++)
      for(k = 0; k < 2; k++)
        fill_in_key_entry(&g_keyinfo[k][i][j], n_rows, n_cols);
}