// *******************************************************************
//   (C) Copyright 2013 Leiden Institute of Advanced Computer Science
//   Universiteit Leiden
//   All Rights Reserved
// *******************************************************************
// Dou Shou Qi (interface)
// *******************************************************************
// FILE INFORMATION:
//   File:     cstio_interface.h
//   Author:   Jonathan K. Vis
//   Revision: 1.01a
//   Date:     2013/04/17
// *******************************************************************
// DESCRIPTION:
//   A basic cstdio interface.
// *******************************************************************

#if !defined(__cstdio_interface_h__)
#define __cstdio_interface_h__

#include "../core/location.h"
#include "../core/move.h"
#include "../core/pieces.h"
#include "../core/position.h"
#include "../core/types.h"

#include <cstdio>


typedef char char_t;


static uint32_t const FILE_A = 0;
static uint32_t const FILE_B = 1;
static uint32_t const FILE_C = 2;
static uint32_t const FILE_D = 3;
static uint32_t const FILE_E = 4;
static uint32_t const FILE_F = 5;
static uint32_t const FILE_G = 6;

static uint32_t const RANK_1 = 8;
static uint32_t const RANK_2 = 7;
static uint32_t const RANK_3 = 6;
static uint32_t const RANK_4 = 5;
static uint32_t const RANK_5 = 4;
static uint32_t const RANK_6 = 3;
static uint32_t const RANK_7 = 2;
static uint32_t const RANK_8 = 1;
static uint32_t const RANK_9 = 0;

static char_t const CAPTURE_SYMBOL = 'x';

static char_t const SIDE_TO_MOVE_SYMBOL[2] =
{
  '0',
  '1'
}; // SIDE_TO_MOVE_SYMBOL

static char_t const FILE_SYMBOL[7] =
{
  'a',
  'b',
  'c',
  'd',
  'e',
  'f',
  'g'
}; // FILE_SYMBOL

static char_t const PIECE_SYMBOL[17] =
{
  'R',
  'r',
  'C',
  'c',
  'W',
  'w',
  'D',
  'd',
  'P',
  'p',
  'T',
  't',
  'L',
  'l',
  'E',
  'e'
}; // PIECE_SYMBOL

static char_t const RANK_SYMBOL[9] =
{
  '9',
  '8',
  '7',
  '6',
  '5',
  '4',
  '3',
  '2',
  '1'
}; // RANK_SYMBOL

static char_t const TERRAIN_SYMBOL[6] =
{
  '.',
  '~',
  '^',
  '^',
  '#',
  '#'
}; // TERRAIN_SYMBOL

static char_t const LOCATION_LABEL[64][2] =
{
  {FILE_SYMBOL[FILE_A], RANK_SYMBOL[RANK_9]},
  {FILE_SYMBOL[FILE_B], RANK_SYMBOL[RANK_9]},
  {FILE_SYMBOL[FILE_C], RANK_SYMBOL[RANK_9]},
  {FILE_SYMBOL[FILE_D], RANK_SYMBOL[RANK_9]},
  {FILE_SYMBOL[FILE_E], RANK_SYMBOL[RANK_9]},
  {FILE_SYMBOL[FILE_F], RANK_SYMBOL[RANK_9]},
  {FILE_SYMBOL[FILE_G], RANK_SYMBOL[RANK_9]},
  {FILE_SYMBOL[FILE_A], RANK_SYMBOL[RANK_8]},
  {FILE_SYMBOL[FILE_B], RANK_SYMBOL[RANK_8]},
  {FILE_SYMBOL[FILE_C], RANK_SYMBOL[RANK_8]},
  {FILE_SYMBOL[FILE_D], RANK_SYMBOL[RANK_8]},
  {FILE_SYMBOL[FILE_E], RANK_SYMBOL[RANK_8]},
  {FILE_SYMBOL[FILE_F], RANK_SYMBOL[RANK_8]},
  {FILE_SYMBOL[FILE_G], RANK_SYMBOL[RANK_8]},
  {FILE_SYMBOL[FILE_A], RANK_SYMBOL[RANK_7]},
  {FILE_SYMBOL[FILE_B], RANK_SYMBOL[RANK_7]},
  {FILE_SYMBOL[FILE_C], RANK_SYMBOL[RANK_7]},
  {FILE_SYMBOL[FILE_D], RANK_SYMBOL[RANK_7]},
  {FILE_SYMBOL[FILE_E], RANK_SYMBOL[RANK_7]},
  {FILE_SYMBOL[FILE_F], RANK_SYMBOL[RANK_7]},
  {FILE_SYMBOL[FILE_G], RANK_SYMBOL[RANK_7]},
  {FILE_SYMBOL[FILE_A], RANK_SYMBOL[RANK_6]},
  {FILE_SYMBOL[FILE_B], RANK_SYMBOL[RANK_6]},
  {FILE_SYMBOL[FILE_C], RANK_SYMBOL[RANK_6]},
  {FILE_SYMBOL[FILE_D], RANK_SYMBOL[RANK_6]},
  {FILE_SYMBOL[FILE_E], RANK_SYMBOL[RANK_6]},
  {FILE_SYMBOL[FILE_F], RANK_SYMBOL[RANK_6]},
  {FILE_SYMBOL[FILE_G], RANK_SYMBOL[RANK_6]},
  {FILE_SYMBOL[FILE_A], RANK_SYMBOL[RANK_5]},
  {FILE_SYMBOL[FILE_B], RANK_SYMBOL[RANK_5]},
  {FILE_SYMBOL[FILE_C], RANK_SYMBOL[RANK_5]},
  {FILE_SYMBOL[FILE_D], RANK_SYMBOL[RANK_5]},
  {FILE_SYMBOL[FILE_E], RANK_SYMBOL[RANK_5]},
  {FILE_SYMBOL[FILE_F], RANK_SYMBOL[RANK_5]},
  {FILE_SYMBOL[FILE_G], RANK_SYMBOL[RANK_5]},
  {FILE_SYMBOL[FILE_A], RANK_SYMBOL[RANK_4]},
  {FILE_SYMBOL[FILE_B], RANK_SYMBOL[RANK_4]},
  {FILE_SYMBOL[FILE_C], RANK_SYMBOL[RANK_4]},
  {FILE_SYMBOL[FILE_D], RANK_SYMBOL[RANK_4]},
  {FILE_SYMBOL[FILE_E], RANK_SYMBOL[RANK_4]},
  {FILE_SYMBOL[FILE_F], RANK_SYMBOL[RANK_4]},
  {FILE_SYMBOL[FILE_G], RANK_SYMBOL[RANK_4]},
  {FILE_SYMBOL[FILE_A], RANK_SYMBOL[RANK_3]},
  {FILE_SYMBOL[FILE_B], RANK_SYMBOL[RANK_3]},
  {FILE_SYMBOL[FILE_C], RANK_SYMBOL[RANK_3]},
  {FILE_SYMBOL[FILE_D], RANK_SYMBOL[RANK_3]},
  {FILE_SYMBOL[FILE_E], RANK_SYMBOL[RANK_3]},
  {FILE_SYMBOL[FILE_F], RANK_SYMBOL[RANK_3]},
  {FILE_SYMBOL[FILE_G], RANK_SYMBOL[RANK_3]},
  {FILE_SYMBOL[FILE_A], RANK_SYMBOL[RANK_2]},
  {FILE_SYMBOL[FILE_B], RANK_SYMBOL[RANK_2]},
  {FILE_SYMBOL[FILE_C], RANK_SYMBOL[RANK_2]},
  {FILE_SYMBOL[FILE_D], RANK_SYMBOL[RANK_2]},
  {FILE_SYMBOL[FILE_E], RANK_SYMBOL[RANK_2]},
  {FILE_SYMBOL[FILE_F], RANK_SYMBOL[RANK_2]},
  {FILE_SYMBOL[FILE_G], RANK_SYMBOL[RANK_2]},
  {FILE_SYMBOL[FILE_A], RANK_SYMBOL[RANK_1]},
  {FILE_SYMBOL[FILE_B], RANK_SYMBOL[RANK_1]},
  {FILE_SYMBOL[FILE_C], RANK_SYMBOL[RANK_1]},
  {FILE_SYMBOL[FILE_D], RANK_SYMBOL[RANK_1]},
  {FILE_SYMBOL[FILE_E], RANK_SYMBOL[RANK_1]},
  {FILE_SYMBOL[FILE_F], RANK_SYMBOL[RANK_1]},
  {FILE_SYMBOL[FILE_G], RANK_SYMBOL[RANK_1]},
  {CAPTURE_SYMBOL, CAPTURE_SYMBOL}
}; // LOCATION_LABEL


static inline uint32_t get_file(char_t const symbol)
{
  if (symbol == FILE_SYMBOL[FILE_A])
  {
    return FILE_A;
  } // if
  if (symbol == FILE_SYMBOL[FILE_B])
  {
    return FILE_B;
  } // if
  if (symbol == FILE_SYMBOL[FILE_C])
  {
    return FILE_C;
  } // if
  if (symbol == FILE_SYMBOL[FILE_D])
  {
    return FILE_D;
  } // if
  if (symbol == FILE_SYMBOL[FILE_E])
  {
    return FILE_E;
  } // if
  if (symbol == FILE_SYMBOL[FILE_F])
  {
    return FILE_F;
  } // if
  if (symbol == FILE_SYMBOL[FILE_G])
  {
    return FILE_G;
  } // if
  return CAPTURED;
} // get_file

static inline uint32_t get_rank(char_t const symbol)
{
  if (symbol == RANK_SYMBOL[RANK_1])
  {
    return RANK_1;
  } // if
  if (symbol == RANK_SYMBOL[RANK_2])
  {
    return RANK_2;
  } // if
  if (symbol == RANK_SYMBOL[RANK_3])
  {
    return RANK_3;
  } // if
  if (symbol == RANK_SYMBOL[RANK_4])
  {
    return RANK_4;
  } // if
  if (symbol == RANK_SYMBOL[RANK_5])
  {
    return RANK_5;
  } // if
  if (symbol == RANK_SYMBOL[RANK_6])
  {
    return RANK_6;
  } // if
  if (symbol == RANK_SYMBOL[RANK_7])
  {
    return RANK_7;
  } // if
  if (symbol == RANK_SYMBOL[RANK_8])
  {
    return RANK_8;
  } // if
  if (symbol == RANK_SYMBOL[RANK_9])
  {
    return RANK_9;
  } // if
  return 0;
} // get_rank

static inline uint32_t get_location(char_t const file_symbol,
                                    char_t const rank_symbol)
{
  return get_file(file_symbol) + 7 * get_rank(rank_symbol);
} // get_location

static inline uint32_t get_piece(char_t const symbol)
{
  if (symbol == PIECE_SYMBOL[WHITE_RAT])
  {
    return WHITE_RAT;
  } // if
  if (symbol == PIECE_SYMBOL[BLACK_RAT])
  {
    return BLACK_RAT;
  } // if
  if (symbol == PIECE_SYMBOL[WHITE_CAT])
  {
    return WHITE_CAT;
  } // if
  if (symbol == PIECE_SYMBOL[BLACK_CAT])
  {
    return BLACK_CAT;
  } // if
  if (symbol == PIECE_SYMBOL[WHITE_WOLF])
  {
    return WHITE_WOLF;
  } // if
  if (symbol == PIECE_SYMBOL[BLACK_WOLF])
  {
    return BLACK_WOLF;
  } // if
  if (symbol == PIECE_SYMBOL[WHITE_DOG])
  {
    return WHITE_DOG;
  } // if
  if (symbol == PIECE_SYMBOL[BLACK_DOG])
  {
    return BLACK_DOG;
  } // if
  if (symbol == PIECE_SYMBOL[WHITE_PANTHER])
  {
    return WHITE_PANTHER;
  } // if
  if (symbol == PIECE_SYMBOL[BLACK_PANTHER])
  {
    return BLACK_PANTHER;
  } // if
  if (symbol == PIECE_SYMBOL[WHITE_TIGER])
  {
    return WHITE_TIGER;
  } // if
  if (symbol == PIECE_SYMBOL[BLACK_TIGER])
  {
    return BLACK_TIGER;
  } // if
  if (symbol == PIECE_SYMBOL[WHITE_LION])
  {
    return WHITE_LION;
  } // if
  if (symbol == PIECE_SYMBOL[BLACK_LION])
  {
    return BLACK_LION;
  } // if
  if (symbol == PIECE_SYMBOL[WHITE_ELEPHANT])
  {
    return WHITE_ELEPHANT;
  } // if
  if (symbol == PIECE_SYMBOL[BLACK_ELEPHANT])
  {
    return BLACK_ELEPHANT;
  } // if
  return NONE;
} // get_piece

static inline void read_move(Move &move,
                             FILE* stream = stdin)
{
  move.piece = get_piece(static_cast<char_t>(fgetc(stream)));
  int symbol = fgetc(stream);
  if (symbol == CAPTURE_SYMBOL)
  {
    symbol = fgetc(stream);
  } // if
  move.to = get_location(static_cast<char_t>(symbol),
                         static_cast<char_t>(fgetc(stream)));
  return;
} // read_move

static inline void write_move(Move const &move,
                              FILE*       stream = stderr)
{
  fputc(PIECE_SYMBOL[move.piece], stream);
  if (move.is_capture())
  {
    fputc(CAPTURE_SYMBOL, stream);
  } // if
  fwrite(LOCATION_LABEL[move.to], sizeof(char_t), 2, stream);
  return;
} // write_move

static inline void draw_board(Position const &position,
                              FILE*           stream = stderr)
{
  fputs("     ", stream);
  fputc(FILE_SYMBOL[FILE_A], stream);
  fputc(' ', stream);
  fputc(FILE_SYMBOL[FILE_B], stream);
  fputc(' ', stream);
  fputc(FILE_SYMBOL[FILE_C], stream);
  fputc(' ', stream);
  fputc(FILE_SYMBOL[FILE_D], stream);
  fputc(' ', stream);
  fputc(FILE_SYMBOL[FILE_E], stream);
  fputc(' ', stream);
  fputc(FILE_SYMBOL[FILE_F], stream);
  fputc(' ', stream);
  fputc(FILE_SYMBOL[FILE_G], stream);
  fputs("\n\n", stream);
  uint32_t location = 0;
  for (int rank = 0; rank < 9; ++rank)
  {
    fputs("  ", stream);
    fputc(RANK_SYMBOL[rank], stream);
    fputs("  ", stream);
    for (int file = 0; file < 7; ++file)
    {
      if (position.board(location) == NONE)
      {
        fputc(TERRAIN_SYMBOL[TERRAIN[location]], stream);
      } // if
      else
      {
        fputc(PIECE_SYMBOL[position.board(location)], stream);
      } // else
      fputc(' ', stream);
      ++location;
    } // for
    fputs(" ", stream);
    fputc(RANK_SYMBOL[rank], stream);
    fputc('\n', stream);
  } // for
  fputs("\n     ", stream);
  fputc(FILE_SYMBOL[FILE_A], stream);
  fputc(' ', stream);
  fputc(FILE_SYMBOL[FILE_B], stream);
  fputc(' ', stream);
  fputc(FILE_SYMBOL[FILE_C], stream);
  fputc(' ', stream);
  fputc(FILE_SYMBOL[FILE_D], stream);
  fputc(' ', stream);
  fputc(FILE_SYMBOL[FILE_E], stream);
  fputc(' ', stream);
  fputc(FILE_SYMBOL[FILE_F], stream);
  fputc(' ', stream);
  fputc(FILE_SYMBOL[FILE_G], stream);
  fputc('\n', stream);
  return;
} // draw_board

static inline void get_configuration(Position const &position,
                                     char_t          string[33])
{
  string[0] = SIDE_TO_MOVE_SYMBOL[position.turn() & 1];
  string[1] = LOCATION_LABEL[position.piece(WHITE_RAT)][0];
  string[2] = LOCATION_LABEL[position.piece(WHITE_RAT)][1];
  string[3] = LOCATION_LABEL[position.piece(BLACK_RAT)][0];
  string[4] = LOCATION_LABEL[position.piece(BLACK_RAT)][1];
  string[5] = LOCATION_LABEL[position.piece(WHITE_CAT)][0];
  string[6] = LOCATION_LABEL[position.piece(WHITE_CAT)][1];
  string[7] = LOCATION_LABEL[position.piece(BLACK_CAT)][0];
  string[8] = LOCATION_LABEL[position.piece(BLACK_CAT)][1];
  string[9] = LOCATION_LABEL[position.piece(WHITE_WOLF)][0];
  string[10] = LOCATION_LABEL[position.piece(WHITE_WOLF)][1];
  string[11] = LOCATION_LABEL[position.piece(BLACK_WOLF)][0];
  string[12] = LOCATION_LABEL[position.piece(BLACK_WOLF)][1];
  string[13] = LOCATION_LABEL[position.piece(WHITE_DOG)][0];
  string[14] = LOCATION_LABEL[position.piece(WHITE_DOG)][1];
  string[15] = LOCATION_LABEL[position.piece(BLACK_DOG)][0];
  string[16] = LOCATION_LABEL[position.piece(BLACK_DOG)][1];
  string[17] = LOCATION_LABEL[position.piece(WHITE_PANTHER)][0];
  string[18] = LOCATION_LABEL[position.piece(WHITE_PANTHER)][1];
  string[19] = LOCATION_LABEL[position.piece(BLACK_PANTHER)][0];
  string[20] = LOCATION_LABEL[position.piece(BLACK_PANTHER)][1];
  string[21] = LOCATION_LABEL[position.piece(WHITE_TIGER)][0];
  string[22] = LOCATION_LABEL[position.piece(WHITE_TIGER)][1];
  string[23] = LOCATION_LABEL[position.piece(BLACK_TIGER)][0];
  string[24] = LOCATION_LABEL[position.piece(BLACK_TIGER)][1];
  string[25] = LOCATION_LABEL[position.piece(WHITE_LION)][0];
  string[26] = LOCATION_LABEL[position.piece(WHITE_LION)][1];
  string[27] = LOCATION_LABEL[position.piece(BLACK_LION)][0];
  string[28] = LOCATION_LABEL[position.piece(BLACK_LION)][1];
  string[29] = LOCATION_LABEL[position.piece(WHITE_ELEPHANT)][0];
  string[30] = LOCATION_LABEL[position.piece(WHITE_ELEPHANT)][1];
  string[31] = LOCATION_LABEL[position.piece(BLACK_ELEPHANT)][0];
  string[32] = LOCATION_LABEL[position.piece(BLACK_ELEPHANT)][1];
  return;
} // get_configuration

static inline void set_configuration(Position    &position,
                                     char_t const string[33])
{
  position.clear();
  if (string[0] == SIDE_TO_MOVE_SYMBOL[BLACK])
  {
    position.do_null_move();
  } // if
  position.set_piece(WHITE_RAT,
                     get_location(string[1], string[2]));
  position.set_piece(BLACK_RAT,
                     get_location(string[3], string[4]));
  position.set_piece(WHITE_CAT,
                     get_location(string[5], string[6]));
  position.set_piece(BLACK_CAT,
                     get_location(string[7], string[8]));
  position.set_piece(WHITE_WOLF,
                     get_location(string[9], string[10]));
  position.set_piece(BLACK_WOLF,
                     get_location(string[11], string[12]));
  position.set_piece(WHITE_DOG,
                     get_location(string[13], string[14]));
  position.set_piece(BLACK_DOG,
                     get_location(string[15], string[16]));
  position.set_piece(WHITE_PANTHER,
                     get_location(string[17], string[18]));
  position.set_piece(BLACK_PANTHER,
                     get_location(string[19], string[20]));
  position.set_piece(WHITE_TIGER,
                     get_location(string[21], string[22]));
  position.set_piece(BLACK_TIGER,
                     get_location(string[23], string[24]));
  position.set_piece(WHITE_LION,
                     get_location(string[25], string[26]));
  position.set_piece(BLACK_LION,
                     get_location(string[27], string[28]));
  position.set_piece(WHITE_ELEPHANT,
                     get_location(string[29], string[30]));
  position.set_piece(BLACK_ELEPHANT,
                     get_location(string[31], string[32]));
  return;
} // set_configuration

#endif