package minesweeper.solver;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import minesweeper.gamestate.GameStateModel;
import minesweeper.gamestate.MoveMethod;
import minesweeper.solver.BoardStateCache.AdjacentSquares;
import minesweeper.solver.BoardStateCache.Cache;
import minesweeper.solver.utility.Logger;
import minesweeper.solver.utility.Logger.Level;
import minesweeper.structure.Action;
import minesweeper.structure.Area;
import minesweeper.structure.Location;

public class BoardState {

	private final static int[] DX = {0, 1, 1, 1, 0, -1, -1, -1};
	private final static int[] DY = {-1, -1, 0, 1, 1, 1, 0, -1};

	//private AdjacentSquares[][] adjacentLocations1;
	//private AdjacentSquares[][] adjacentLocations2;

	private int[][] board;
	private boolean[][] revealed;
	private boolean[][] confirmedMine;
	private boolean[][] flagOnBoard;
	
	//private int[][] clearAll;

	private int[][] adjFlagsConfirmed;
	private int[][] adjFlagsOnBoard;
	private int[][] adjUnrevealed;

	// this holds the actions made against each location and a list of actions generated this turn
	private Action[][] action;
	private List<Action> actionList = new ArrayList<Action>();

	private final GameStateModel myGame;
	private final Solver solver;
	private final int height;
	private final int width;

	private int totalFlags = 0;
	private int confirmedMinesTotal = 0;
	private int numOfHidden = 0;

	private int[] unplayedMoves;

	private int testMoveBalance = 0;
	
	private Set<Location> livingWitnesses = new HashSet<>();
	
	private final Cache cache;
	
	public BoardState(Solver solver) {

		this.solver = solver;
		this.myGame = solver.getGame();
		this.width = myGame.getWidth();
		this.height = myGame.getHeight();

		confirmedMine = new boolean[myGame.getWidth()][myGame.getHeight()];
		adjFlagsConfirmed =  new int[myGame.getWidth()][myGame.getHeight()];
		adjUnrevealed = new int[myGame.getWidth()][myGame.getHeight()];
		revealed = new boolean[myGame.getWidth()][myGame.getHeight()];
		board = new int[myGame.getWidth()][myGame.getHeight()];
		
		flagOnBoard = new boolean[myGame.getWidth()][myGame.getHeight()];
		adjFlagsOnBoard = new int[myGame.getWidth()][myGame.getHeight()];
		
		action = new Action[myGame.getWidth()][myGame.getHeight()];

		// look up the adjacent squares details
		cache = BoardStateCache.getInstance().getAdjacentSquares1(myGame.getWidth(), myGame.getHeight());
		//adjacentLocations1 = cache.adjacentLocations1;
		//adjacentLocations2 = cache.adjacentLocations2;
		

		final int bottom = myGame.getHeight() - 1;
		final int right =  myGame.getWidth() - 1;

		//  set up how many adjacent locations there are to each square - they are all unrevealed to start with
		for (int x=0; x < width; x++) {
			for (int y=0; y < height; y++) {

				int adjacent = 8;
				// corners
				if (x == 0 && y == 0 || x == 0 && y == bottom || x == right && y == 0 || x == right && y == bottom) {
					adjacent = 3; 
					// the edge
				} else if (x == 0 || y == 0 || x == right || y == bottom){
					adjacent = 5;
				}

				adjUnrevealed[x][y] = adjacent;
				
			}
		}


	}

	public void process() {

		totalFlags = 0;
		confirmedMinesTotal = 0;
		numOfHidden = 0;

		// clear down this array, which is a lot faster then defining it fresh
		for (int i=0; i < width; i++) {
			for (int j=0; j < height; j++) {
				adjFlagsOnBoard[i][j] = 0;
			}
		}

		// clear down the moves we collected last turn
		actionList.clear();
		
		// load up what we can see on the board
		for (int i=0; i < width; i++) {
			for (int j=0; j < height; j++) {
				
				Location location = getLocation(i, j);
				
				flagOnBoard[i][j] = false; // until proven otherwise
				int info = myGame.query(location);

				Action act = action[i][j];

				// if the move isn't a certainty then don't bother with it. The opening book is a certainty on the first move, but isn't really if the player plays somewhere else.
				if (act != null && (!act.isCertainty() || act.getMoveMethod() == MoveMethod.BOOK)) {
					action[i][j] = null;
					act = null;
				}

				if (info != GameStateModel.HIDDEN) {
					if (info == GameStateModel.FLAG) {
						totalFlags++;
						flagOnBoard[i][j] = true;
						
						// inform its neighbours they have a flag on the board
						for (int k=0; k < DX.length; k++) {
							if (i + DX[k] >= 0 && i + DX[k] < width && j + DY[k] >= 0 && j + DY[k] < height) {
								adjFlagsOnBoard[i + DX[k]][j + DY[k]]++;
							}
						}    							

						if (confirmedMine[i][j]) {    // mine found by solver
							confirmedMinesTotal++;
						} else {
							numOfHidden++;           // flag on the board but we can't confirm it
						}

						// if the board is a flag, but we are 100% sure its a clear then remove the flag
						// then clear the square
						if (act != null && act.getAction() == Action.CLEAR && act.isCertainty()) {
							actionList.add(new Action(act, Action.FLAG, MoveMethod.CORRECTION, "Remove flag", BigDecimal.ONE, 0));
							actionList.add(act);
						}

					} else {

						// if this is a new unrevealed location then set it up and inform it's neighbours they have one less unrevealed adjacent location
						if (!revealed[i][j]) {

							livingWitnesses.add(location);  // add this to living witnesses
							//display("Location (" + i + "," + j + ") is revealed");
							
							revealed[i][j] = true;
							board[i][j] = info;            

							for (int k=0; k < DX.length; k++) {
								if (i + DX[k] >= 0 && i + DX[k] < width && j + DY[k] >= 0 && j + DY[k] < height) {
									adjUnrevealed[i + DX[k]][j + DY[k]]--;
								}
							}    	

						}

					}
				} else {
					if ((solver.getPlayStyle().flagless || solver.getPlayStyle().efficiency) && confirmedMine[i][j]) {  // if we are playing flags free then all confirmed mines are consider to be flagged
						confirmedMinesTotal++;   
						totalFlags++;
					} else {
						numOfHidden++;
					}

					// if we have an action against this location which we are 100% sure about then do it
					if (act != null && act.isCertainty()) {
						if ((solver.getPlayStyle().flagless || solver.getPlayStyle().efficiency) && act.getAction() == Action.FLAG) {
							// unless the we are playing flag free and it's a flag
						} else {
							actionList.add(act);
						}

					}
				}

			}
		}
		
		List<Location> toRemove = new ArrayList<>();
		for (Location wit: livingWitnesses) {
			if (this.countAdjacentUnrevealed(wit) == 0) {
				//display("Location " + wit.display() + " is now a dead witness");
				toRemove.add(wit);
			}
		}
		livingWitnesses.removeAll(toRemove);
		
		
		// this sorts the moves by when they were discovered
		Collections.sort(actionList, Action.SORT_BY_MOVE_NUMBER);

		unplayedMoves = new int[MoveMethod.values().length];

		// accumulate how many unplayed moves there are by method
		for (Action a: actionList) {
			unplayedMoves[a.getMoveMethod().ordinal()]++;
		}

		getLogger().log(Level.INFO, "Moves left to play is %d", actionList.size());
		for (int i=0; i < unplayedMoves.length; i++) {
			if (unplayedMoves[i] != 0) {
				getLogger().log(Level.INFO, "   %s has %d moves unplayed",MoveMethod.values()[i], unplayedMoves[i]);
			}
		}


	}

	protected int getGameWidth() {
		return width;
	}

	protected int getGameHeight() {
		return height;
	}

	protected int getMines() {
		return this.myGame.getMines();
	}

	
	//public void setAction(Action a) {
	//	setAction(a, true);
	//}

	/**
	 * Register the action against the location(x,y);
	 * Optionally add the action to the list of actions to play this turn
	 */
	public void setAction(Action a) {

		//display("Setting action at " + a.display());
		
		if (action[a.x][a.y] != null) {
			return;
		}

		action[a.x][a.y] = a;

		if (a.getAction() == Action.FLAG) {
			setMineFound(a);
		}
		
		if ((solver.getPlayStyle().flagless || solver.getPlayStyle().efficiency)  && a.getAction() == Action.FLAG) {
			// if it is flag free or efficiency and we have discovered a mine then don't flag it
		} else if (isFlagOnBoard(a) && a.getAction() == Action.FLAG) {
			// if the flag is already on the board then nothing to do
		} else if (isFlagOnBoard(a) && a.getAction() == Action.CLEAR) {
			// if a flag is blocking the clear move then remove the flag first
			actionList.add(new Action(a, Action.FLAG, MoveMethod.CORRECTION, "Remove flag", BigDecimal.ONE, 0));
			actionList.add(a);			
		} else {
			actionList.add(a);
		}


	}

	protected boolean alreadyActioned(Location l) {
		return alreadyActioned(l.x, l.y);
	}

	protected boolean alreadyActioned(int x, int y) {
		return (action[x][y] != null);
	}


	protected List<Action> getActions() {
		return this.actionList;
	}

	/**
	 * This will consider chords when returning the moves to play
	 */
	/*
	protected List<Action> getActionsWithChords() {

		// if we aren't using chords or none are available then skip all this expensive processing
		if (chordLocations.isEmpty() || !solver.isPlayChords()) {
			return getActions();
		}
		
		List<Action> actions = new ArrayList<>();
		boolean[][] processed = new boolean[myGame.getWidth()][myGame.getHeight()];
		
		// sort the most beneficial chords to the top
		Collections.sort(chordLocations, ChordLocation.SORT_BY_BENEFIT_DESC);
		
		List<ChordLocation> toDelete = new ArrayList<>();
		
		for (ChordLocation cl: chordLocations) {
			
			int benefit = 0;
			int cost = 0;
			
			for (Location l: getAdjacentSquaresIterable(cl)) {
				// flag not yet on board
				if (!processed[l.x][l.y] && isConfirmedFlag(l) && !isFlagOnBoard(l)) {
					cost++;
				}
				if (!processed[l.x][l.y] && isUnrevealed(l)) {
					benefit++;
				}
			}			
			
			
			if (benefit - cost > 1) {

				for (Location l: getAdjacentSquaresIterable(cl)) {
					// flag not yet on board
					if (!processed[l.x][l.y] && isConfirmedFlag(l) && !isFlagOnBoard(l)) {
						actions.add(new Action(l, Action.FLAG, MoveMethod.TRIVIAL, "Place flag", BigDecimal.ONE, 0));
					}
					// flag on board in error
					if (!processed[l.x][l.y] && !isConfirmedFlag(l) && isFlagOnBoard(l)) {
						actions.add(new Action(l, Action.FLAG, MoveMethod.CORRECTION, "Remove flag", BigDecimal.ONE, 0));
					}
					processed[l.x][l.y] = true;
				}
				// now add the clear all
				actions.add(new Action(cl, Action.CLEARALL, MoveMethod.TRIVIAL, "Clear All", BigDecimal.ONE, 1));	
				
			} else {
				//toDelete.add(cl);
			}
		}
		
		chordLocations.removeAll(toDelete);

		// now add the the actions that haven't been resolved by a chord play
		for (Action act: actionList) {
			if (!processed[act.x][act.y]) {
				processed[act.x][act.y] = true;
			}
			actions.add(act);
		}

		return actions;
	}
	*/
	/**
	 * Get the probability of a mine being in this square (based upon the actions still pending)
	 */
	protected BigDecimal getProbability(int x, int y) {
		
		for (Action act: actionList) {
			if (act.x == x && act.y== y) {
				if (act.getAction() == Action.FLAG) {
					return BigDecimal.ZERO;
				} else if (act.getAction() == Action.CLEAR) {
					return act.getBigProb();
				}
				
			}
		}		
		
		
		return null;
		
	}
	
	
	//protected int getActionsCount() {
	//	return this.actionList.size();
	//}
	
	/**
	 * Add a isolated dead tile
	 */
	//protected void addIsolatedDeadTile(Location loc) {
	//	isolatedDeadTiles.add(loc);
	//}
	
	//public int getIsolatedDeadTileCount() {
	//	return this.isolatedDeadTiles.size();
	//}
	
	/**
	 * Returns and removes the first Isolated Dead Tile in the set
	 */
	//public Location getIsolatedDeadTile() {
	//	for (Location loc: isolatedDeadTiles) {
	//		//isolatedDeadTiles.remove(loc);
	//		return loc;
	//	}
	//	return null;
	//}

	protected List<Location> getWitnesses(Collection<? extends Location> square) {
		return new ArrayList<Location>(getWitnessesArea(square).getLocations());
	}
	
	/**
	 * From the given locations, generate all the revealed squares that can witness these locations
	 */
	protected Area getWitnessesArea(Collection<? extends Location> square) {

		Set<Location> work = new HashSet<>(10);

		for (Location loc: square) {

			for (Location adj: this.getAdjacentSquaresIterable(loc)) {
				// determine the number of distinct witnesses
				if (isRevealed(adj)) {
					work.add(adj);
				}            		
			}            
		}

		return new Area(work);

	}
	
	/**
	 * From the given locations, generate an area containing all the un-revealed squares around them
	 */
	protected Area getUnrevealedArea(List<? extends Location> witnesses) {
		return new Area(getUnrevealedSquaresDo(witnesses));
	}
	
	/**
	 * From the given locations, generate all the un-revealed squares around them
	 */
	protected List<Location> getUnrevealedSquares(List<? extends Location> witnesses) {
		return new ArrayList<Location>(getUnrevealedSquaresDo(witnesses));
	}
	
	
	private Set<Location> getUnrevealedSquaresDo(List<? extends Location> witnesses) {

		Set<Location> work = new HashSet<>(witnesses.size() * 3);       

		for (Location loc: witnesses) {
			
			for (Location adj: this.getAdjacentSquaresIterable(loc)) {

				if (isUnrevealed(adj)) {
					work.add(adj);
				}            		
			}
			
		}

		return work;
	}
	
	/**
	 * Return all the unrevealed Locations on the board
	 */
	protected List<Location> getAllUnrevealedSquares() {

		ArrayList<Location> work = new ArrayList<>(width * height);       

		for (int i=0; i < width; i++) {
			for (int j=0; j < height; j++) {
				if (isUnrevealed(i,j)) {
					work.add(getLocation(i,j));
				}
			}
		}                        

		return work;
	}

	protected List<Location> getAllLivingWitnesses() {
		return new ArrayList<>(livingWitnesses);
	}
	
	
	/**
	 * Return a list of Unrevealed Locations adjacent to this one
	 */
	protected List<Location> getAdjacentUnrevealedSquares(Location loc) {

		return getAdjacentUnrevealedSquares(loc, 1);
	}

	/**
	 * Return an Area of un-revealed Locations adjacent to this one
	 */
	protected Area getAdjacentUnrevealedArea(Location loc) {

		return new Area(getAdjacentUnrevealedSquares(loc, 1));
	}
	
	
	/**
	 * Return a list of Unrevealed Locations adjacent to this one
	 */
	protected List<Location> getAdjacentUnrevealedSquares(Location loc, int size ) {

		ArrayList<Location> work = new ArrayList<>();       

		for (Location a: getAdjacentSquaresIterable(loc, size)) {
			if (isUnrevealed(a)) {
				work.add(a);
			}
		}

		return work;
	}

	/**
	 * Return the Location for this position, avoids having to instantiate one
	 */
	protected Location getLocation(int x, int y) {
		if (x < 0 || x >= this.width || y < 0 || y >= this.height) {
			return null;
		} else {
			return cache.getLocation(x, y);
		}

	}
	
	
	/**
	 * This returns the adjacent squares to a depth of size away. So (l,2) returns the 24 squares 2 deep surrounding l.
	 */
	protected Iterable<Location> getAdjacentSquaresIterable(Location loc, int size) {
		if (size == 1) {
			return getAdjacentSquaresIterable(loc);
		} else {
			return cache.adjacentLocations2[loc.x][loc.y];
		}
		
	}

	protected Iterable<Location> getAdjacentSquaresIterable(Location loc) {
		return cache.adjacentLocations1[loc.x][loc.y];
	}


	/**
	 * Done as part of validating Locations, must be undone using clearWitness()
	 */
	protected void setWitnessValue(Location l, int value) {    	 
		board[l.x][l.y] = value;
		revealed[l.x][l.y] = true;
		
		testMoveBalance++;
		
	}

	/**
	 * Done as part of validating Locations
	 */
	protected void clearWitness(Location l) {    	 
		board[l.x][l.y] = 0;
		revealed[l.x][l.y] = false;
		
		testMoveBalance--;
		
	}

	/**
	 * Method to read our own array of reveal values.
	 */
	protected int getWitnessValue(Location l) {
		return getWitnessValue(l.x, l.y);
	}

	/**
	 * Method to read our own array of reveal values.
	 */
	protected int getWitnessValue(int x, int y) {
		if (isUnrevealed(x,y)) {
			throw new RuntimeException("Trying to get a witness value for an unrevealed square");
		}
		return board[x][y];
	}    

	/**
	 * indicates a flag is on the board, but the solver can't confirm it
	 */
	protected boolean isUnconfirmedFlag(Location l) {
		return isUnconfirmedFlag(l.x, l.y);
	}

	/**
	 * indicates a flag is on the board, but the solver can't confirm it
	 */
	protected boolean isUnconfirmedFlag(int x, int y) {
		return flagOnBoard[x][y] && !confirmedMine[x][y];
	}        

	/**
	 * indicates a flag is on the board
	 */
	protected boolean isFlagOnBoard(Location l) {
		return isFlagOnBoard(l.x, l.y);
	}

	/**
	 * indicates a flag is on the board
	 */
	protected boolean isFlagOnBoard(int x, int y) {
		return flagOnBoard[x][y];
	}        


	protected void setFlagOnBoard(Location l) {
		setFlagOnBoard(l.x, l.y);
	}

	protected void setFlagOnBoard(int x, int y) {
		flagOnBoard[x][y] = true;
	}

	protected void setMineFound(Location loc) {

		if (isConfirmedMine(loc)) {
			return;
		}

		confirmedMinesTotal++;
		confirmedMine[loc.x][loc.y] = true;

		// if the flag isn't already on the board then this is also another on the total of all flags
		if (!flagOnBoard[loc.x][loc.y]) {
			totalFlags++;
		}

		// let all the adjacent squares know they have one more flag next to them and one less unrevealed location
		for (Location a: getAdjacentSquaresIterable(loc)) {
			adjFlagsConfirmed[a.x][a.y]++;
			adjUnrevealed[a.x][a.y]--;
		}
		
	}

	protected void unsetMineFound(Location loc) {

		if (!isConfirmedMine(loc)) {
			return;
		}

		confirmedMinesTotal--;
		confirmedMine[loc.x][loc.y] = false;


		// if the flag isn't already on the board then this is also another on the total of all flags
		if (!flagOnBoard[loc.x][loc.y]) {
			totalFlags--;
		}

		// let all the adjacent squares know they have one less mine next to them and one more unrevealed location
		for (Location a: getAdjacentSquaresIterable(loc)) {
			adjFlagsConfirmed[a.x][a.y]--;
			adjUnrevealed[a.x][a.y]++;
		}
		
	}
	
	/**
	 * Since Flag Free is a thing, we can't rely on the GameState to tell us where the flags are,
	 * so this replaces that.
	 */
	protected boolean isConfirmedMine(Location l) {
		return isConfirmedMine(l.x, l.y);
	}

	/**
	 * Since Flag Free is a thing, we can't rely on the GameState to tell us where the flags are,
	 * so this replaces that.
	 */
	protected boolean isConfirmedMine(int x, int y) {
		return confirmedMine[x][y];
	}    

	/**
	 * Returns whether the location is revealed
	 */
	protected boolean isRevealed(Location l) {
		return isRevealed(l.x, l.y);
	}    

	/**
	 * Returns whether the location is revealed
	 */
	protected boolean isRevealed(int x, int y) {
		return revealed[x][y];
	}    

	/**
	 * Returns whether the location is unrevealed (neither revealed nor a confirmed flag)
	 */
	protected boolean isUnrevealed(Location l) {
		return isUnrevealed(l.x, l.y);
	}    

	/**
	 * Returns whether the location is unrevealed (neither revealed nor a confirmed flag)
	 */
	protected boolean isUnrevealed(int x, int y) {
		return !confirmedMine[x][y] && !revealed[x][y];
	}    

	/**
	 * count how many confirmed flags are adjacent to this square
	 */
	protected int countAdjacentConfirmedFlags(Location l) {
		return countAdjacentConfirmedFlags(l.x, l.y);
	}

	/**
	 * count how many confirmed flags are adjacent to this square
	 */
	protected int countAdjacentConfirmedFlags(int x, int y) {

		return adjFlagsConfirmed[x][y];

	}

	/**
	 * count how many flags are adjacent to this square on the board
	 */
	protected int countAdjacentFlagsOnBoard(Location l) {
		return countAdjacentFlagsOnBoard(l.x, l.y);
	}

	/**
	 * count how many flags are adjacent to this square on the board
	 */
	protected int countAdjacentFlagsOnBoard(int x, int y) {

		return adjFlagsOnBoard[x][y];

	}
	
	
	/**
	 * count how many confirmed and unconfirmed flags are adjacent to this square
	 */
	protected int countAllFlags(int x, int y) {

		int result = 0;

		for (int i=0; i < DX.length; i++) {
			if (x + DX[i] >= 0 && x + DX[i] < width && y + DY[i] >= 0 && y + DY[i] < height) {
				if (confirmedMine[x + DX[i]][y + DY[i]] || flagOnBoard[x + DX[i]][y + DY[i]]) {
					result++;
				}
			}
		}

		return result;

	}

	/**
	 * count how many adjacent squares are neither flags nor revealed
	 */
	protected int countAdjacentUnrevealed(Location l) {

		return countAdjacentUnrevealed(l.x, l.y);

	}

	/**
	 * count how many adjacent squares are neither confirmed flags nor revealed
	 */
	protected int countAdjacentUnrevealed(int x, int y) {

		return adjUnrevealed[x][y];

	}    

	/**
	 * count how many squares are neither confirmed flags nor revealed
	 */    
	protected int getTotalUnrevealedCount() {

		return numOfHidden;

	}

	/**
	 * Returns the number of mines the solver knows the location of
	 */
	protected int getConfirmedMineCount() {

		return confirmedMinesTotal;

	}

	/**
	 * Number of flags on the board both confirmed and unconfirmed
	 */
	protected int getTotalFlagCount() {
		return this.totalFlags;
	}

	protected int getUnplayedMoves(MoveMethod method) {
		return unplayedMoves[method.ordinal()];
	}


	// check for flags which can be determined to be wrong
	protected boolean validateData() {

		for (int i=0; i < width; i++) {
			for (int j=0; j < height; j++) {

				// if there is an unconfirmed flag on the board but the solver
				// thinks it is clear then the flag is wrong
				if (isUnconfirmedFlag(i,j) && action[i][j] != null && action[i][j].getAction() == Action.CLEAR) {
					getLogger().log(Level.INFO, "Flag in Error at (%d, %d) confirmed CLEAR", i, j);
					return false;
				}

				if (isRevealed(i,j) && getWitnessValue(i,j) != 0) {
					int flags = countAllFlags(i,j);

					// if we have too many flags by a revealed square then a mistake has been made
					if (getWitnessValue(i,j) < flags) {
						getLogger().log(Level.INFO, "Flag in Error at witness (%d, %d) Overloads: Flags %d" ,i, j, flags);
						return false;
					}
				}

			}        

		}

		return true;

	}

	/**
	 * Returns true if the board is consider high mine density
	 * @return
	 */
	public boolean isHighDensity() {
		
		int minesLeft = getMines() - getConfirmedMineCount();
		int tilesLeft = getTotalUnrevealedCount();
		
		return (minesLeft * 5 > tilesLeft * 2) && Solver.CONSIDER_HIGH_DENSITY_STRATEGY;
	}
	

	public int getTestMoveBalance() {
		return this.testMoveBalance;
	}
	
	protected Logger getLogger() {
		return solver.logger;
	}
	
	//protected void display(String text) {
	//	solver.display(text);
	//}

	protected Solver getSolver() {
		return solver;
	}

}