/**
- # players
- length of run required to win
- grid dimensions & size of those dimensions
- which faces are open
**/

#include <stdarg.h>
#include "math.h"

#include <assert.h>
#include <vector>
using std::vector;
#include <set>
using std::set;

#include "Output.h"
#include "Move.h"

#define ABS(x) ((x < 0) ? -x : x)

class Board {
public:
	//default dummy constructor
	Board();
	Board(int numDimensions);
	//copy constructor
	Board(const Board &copy){
		possibleMoves = copy.possibleMoves;
		numDimensions = copy.numDimensions;
		dimensions = copy.dimensions;
		openFaces = copy.openFaces;
		numSquares = copy.numSquares;
		squares = copy.squares;
		squareIds = copy.squareIds;
		pos = copy.pos;
		numDirections = copy.numDirections;
		directions = copy.directions;
	}

	void SetDimensionSize(int d, int sz);

	// where in the "falling" dimension will the player's piece rest
	int GetStoppingIndex(Move& move);

	void MakeMove(Move& move);

	void Print();

	bool HasRun(int runLength, bool print);
	bool IsWin(int runLength, char player);
	bool IsDraw();
	int numPiecesA();
	int numPiecesB();
	bool fullBoard();

	void SetOpenFace(int f);
	bool IsOpenFace(int f);
	bool IsLegal(Move& move);

	int getNumSquares(){return numSquares;}

	vector<Move> possibleMoves; 
private:
	int numDimensions;
	vector<int> dimensions;

	set<int> openFaces;
	
	int numSquares;
	vector<int> squares;
	vector<SquareId> squareIds;
	int pos;

	int numDirections;
	vector<SquareId> directions;

	int GetValue(int i);
	int GetValue(SquareId& square);
	void SetValue(int val, int i);
	void SetValue(int val, SquareId& square);


	SquareId& IndexToSquare(int index);
	int SquareToIndex(SquareId& square);

	void EnumerateDirections(int dim, SquareId& square);
	void EnumerateSquares(int dim, SquareId& square);

	void PrintSquare(SquareId& sq, bool debug);

	bool InBounds(SquareId& sq);
	SquareId& CalculateNeighbor(SquareId& sq, SquareId& dir);
};