public class GameGrid extends JewelPuzzleGridCaller {
	private JewelCell[][] jewelGrid;
	private Coord         selected;
	private int           width;
	private int           height;
	private ArrayList<Coord> aChangedCells;
	private ArrayList<Coord> aToBeDestroyedCells;
	private int chainCount = 0;
	private JewelGameManager myManager;
	
	public GameGrid(int width,int height, JewelGameManager myManager) {
		jewelGrid = new JewelCell[width][height];
		this.myManager = myManager;
		this.width  = width;
		this.height  = height;
		aChangedCells = new ArrayList<Coord>();
		aToBeDestroyedCells = new ArrayList<Coord>();
		selected  = new Coord(-1, -1);
	}
	
	public void initialize() {
		for (int x = 0; x < this.width; x++) {
			for (int y = 0; y < this.height; y++) {
				jewelGrid[x][y] = new JewelCell(null);
			}			
		}
		checkCellsAndPullDown();
		//updateValidMoves();
	}

	public int getWidth() {
		return width;
	}

	public int getHeight() {
		return height;
	}
	
	public boolean hasSelected(){
		return (this.selected != null && this.selected.getX() > -1 && this.selected.getY() > -1);
	}
	
	public Coord getSelected() {
		return selected;
	}
	
	public void select(int x, int y){
		this.selected.setCoords(x, y);
		callShowSelectedMarker(x, y, true);
	}

	public void deSelect(){
		this.selected.setCoords(-1, -1);
		callShowSelectedMarker(0, 0, false);
	}
	
	public JewelCell getCell(int x, int y){
		return jewelGrid[x][y];
	}
	
	public JewelCell getCell(Coord coord){
		return jewelGrid[coord.getX()][coord.getY()];
	}

	public int getChainCount() {
		return chainCount;
	}

	public void resetChainCount() {
		this.chainCount = 0;
	}	
	
	private void addCellToBeChecked(int x, int y){
		addCellToBeChecked(new Coord(x, y));
	}
	
	private void addCellToBeChecked(Coord coord){
		aChangedCells.add(coord);
	}
	
	private boolean checkChangedCellsForMatches(){
		boolean result = false;
		if (aChangedCells.size() > 0){
			for (Coord coord : aChangedCells) {
				if (checkCellForMatches(coord)){
					result = true;
				}
			}
		}
		return result;
	}

	/**
     * Check all cells from the grid for matches.
	 * @return <b>true</b> if there is at least one match, <b>false</b> otherwise.
	 */
	public boolean checkGridForMatches(){
		for (int x = 0; x < width; x++) {
			for (int y = 2; y < height; y++) {
				checkCellForMatches(new Coord(x, y));
			}
		}
		return clearMarkedCells();
	}
	
	private boolean checkCellForMatches(Coord pCoord){
		ArrayList<Coord> VLine = new ArrayList<Coord>();
		ArrayList<Coord> HLine = new ArrayList<Coord>();
		JewelType type;
		for (Coord coord : aToBeDestroyedCells) {
			// if the cell is already marked for destruction skip the check. It is doomed.
			if (coord.match(pCoord)) return false;
		}
		
		
		boolean result = false;
		final int x = pCoord.getX();
		final int y = pCoord.getY();
		type = getCell(x, y).getType();
		
		// @Anila
		// this 'for' is because my gems can have more than one type of color
		// so I check every type
		// regular 1-color gems don't need the 'for'
		for (JewelColor color : type.getColors()) {
			HLine.clear(); 
			VLine.clear(); 
			
			for (int xt = x; xt >= 0 && JewelType.isMatch(getCell(xt, y).getType(), color); xt--) {
				HLine.add(new Coord(xt, y));				
			}
			for (int xt = x +1; xt < width  && JewelType.isMatch(getCell(xt, y).getType(), color); xt++) {
				HLine.add(new Coord(xt, y));				
			}
			//yt = 2 to ignore the first 2 lines, they will be hidden unless the player has the proper ability
			for (int yt = y; yt >= 2 && JewelType.isMatch(getCell(x, yt).getType(), color); yt--) {
				VLine.add(new Coord(x, yt));				
			}
			for (int yt = y +1; yt < height  && JewelType.isMatch(getCell(x, yt).getType(), color); yt++) {
				VLine.add(new Coord(x, yt));				
			}
			
			if (HLine.size() > 2){
				aToBeDestroyedCells.addAll(HLine);
				result = true;
			}
			
			if (VLine.size() > 2){
				aToBeDestroyedCells.addAll(VLine);
				result = true;
			}
		}
		return result;
	}
	/*
	private void updateValidMoves(){
		
	}*/
	
	public boolean clearMarkedCells(){
		ArrayList<Coord> list = new ArrayList<Coord>();
		if (aToBeDestroyedCells.size() > 0){
			for (Coord coord : aToBeDestroyedCells) {
				if (!getCell(coord).isEmpty()){
					for (JewelColor color : getCell(coord).getType().getColors()) {
						myManager.matchedPoints(color, 1, coord);						
					}
					getCell(coord).setEmpty();
					list.add(coord);
				}
			}
			
			callClearMatchedCells(list);	
			aToBeDestroyedCells.clear();
			chainCount++;
			return true;
		} else {
			return false;
		}
	}
	
	public void swapCell(int x1, int y1, int x2, int y2){
		deSelect();
		JewelCell cell1 = jewelGrid[x1][y1];
		JewelCell cell2 = jewelGrid[x2][y2];
		
		jewelGrid[x1][y1] = cell2;
		jewelGrid[x2][y2] = cell1;
		
		aChangedCells.clear();
		addCellToBeChecked(x1, y1);
		addCellToBeChecked(x2, y2);
		
		if (checkChangedCellsForMatches()){
			callSwapJewels(x1, y1, x2, y2);
		} else {
			jewelGrid[x1][y1] = cell1;
			jewelGrid[x2][y2] = cell2;
			callSwapJewelsFailed(x1, y1, x2, y2);
		}
	}
	
	/**
	 * Pull all gems down from bottom to top creating new gems as needed
	 * @return <b>true</b> if pulled at least one gem, <b>false</b> if all lines were filled and no one was pulled.
	 */
	public boolean checkCellsAndPullDown(){
		ArrayList<MoveCoord> list = new ArrayList<MoveCoord>();
		for (int x = 0; x < width; x++) {
			list.addAll(cellPullDown(x));
		}
		if (list.size() > 0) callExecutePullDown(list);
		return list.size() > 0;
	}

	private ArrayList<MoveCoord> cellPullDown(int x){
		ArrayList<MoveCoord> list = new ArrayList<MoveCoord>();
		final int BOTTOM = height -1;
		JewelCell upcell;
		
		for (int y = BOTTOM; y >= 0; y--) {
			JewelCell cell = getCell(x, y);
			if (cell.isEmpty()){
				Coord toCoord = new Coord(x, y); 
				Coord fromCoord = new Coord(x, -1);
				boolean foundCell = false;
				for (int curY = y -1; curY >= 0 && !foundCell; curY--){
					if (curY >= 0 && !(upcell = getCell(x, curY)).isEmpty()){
						cell.setType(upcell.getType());
						upcell.setEmpty();
						fromCoord.setCoords(x, curY);
						foundCell = true;
					} 
				}
				if (foundCell){
					list.add(new MoveCoord(fromCoord, toCoord));					
				} else {
					list.add(new MoveCoord(fromCoord, toCoord, cell.newType()));			
				}
			}
		}
		return list;
	}
}