acm-2008-C-Another Brick in the Wall

package acm2008;

import java.util.ArrayList;
import java.util.List;

import util.AcmUtil;

public class acm2008c {
	
	public static void main(String[] args) {
		int m,n;
		int fileContentIndex = 0;
		String input = "E:\\acm\\2008\\TD87\\c.in";
		String output = "E:\\acm\\2008\\TD87\\c.out";
		String myOutput = "E:\\acm\\2008\\TD87\\c-my.out";
		
		List<String> fileContent = AcmUtil.readFromFile(input);
		List<String> outputList = new ArrayList<String>();
		do {
			Integer[] size = AcmUtil.getMatrixSize(fileContent, fileContentIndex++);
			m = size[0];
			n = size[1];
			if (m == 0 || n == 0)
				break;
			
			String[][] matrixData = AcmUtil.getMatrixDataString(fileContent.subList(fileContentIndex, fileContentIndex + m), m, n);
			fileContentIndex += m;
			
			int row = m-1;
			int col = 0;
			int maxBrickFall = 0;
			
			while (col <= n && row > 0) {
				int brickLength = getBufferSize(matrixData, row, col);
				if (col + brickLength <= n &&  brickLength > 0) {
					// left 0
					int rightZero = getRightZero(matrixData, col, row, brickLength);
					//right 0
					int leftZero = getLeftZero(matrixData, col, row);
					
					brickLength += leftZero + rightZero;
					
					String[] buffer = new String[brickLength];
					fillBuffer(buffer, "#");
					
					
					int currentBrickFall = 0;
					int up = 0;
					while (brickLength > 0 && row - up >= 0) {
						String[] topLine = getDataLine(matrixData, row - up, col - leftZero, brickLength);
						setBrickInBeffer(brickLength, buffer, topLine);
						currentBrickFall += removeIncompleteBrickAndGetLength(buffer);
						brickLength = getBrickLengthInBuffer(buffer);
						up++;
					}
					
					
					
					if (maxBrickFall < currentBrickFall)
						maxBrickFall = currentBrickFall;
					
					col += buffer.length;
				} else {
					col++;
				}
				
				
				// end of wall
				if (col >= n) {
					col = 0;
					row -= 1;
				}
					
			}
			
			//System.out.println(maxBrickFall);
			outputList.add("" + maxBrickFall);
			
		} while(m != 0 || n != 0);
		
		AcmUtil.writeToFile(outputList, myOutput);
		System.out.println(AcmUtil.diffFile(output, myOutput));
	}

	private static int getBufferSize(String[][] matrixData, int row, int col) {
		int totalBrickLength = 0;
		int brickLength = Integer.parseInt(matrixData[row][col]);
		totalBrickLength += brickLength;
		
		return totalBrickLength;
	}
	
	private static int getRightZero(String[][] matrixData, int col, int row, int totalBrickLength) {
		int rightZero = 0;
		int rightIndex = 0;
		int endOfBrick = col + totalBrickLength;
		int count = 0;
		while (rightZero == 0 && endOfBrick + rightIndex < matrixData[0].length) {
			rightZero = Integer.parseInt(matrixData[row][endOfBrick + rightIndex]);
			if (rightZero == 0)
				count++;
			rightIndex++;
		}
		return count;
	}
	
	private static int getLeftZero(String[][] matrixData, int col, int row) {
		int leftIndex = 1;
		int rightZero = 0;
		int totalBrickLength = 0;
		while (rightZero == 0 && col - leftIndex >= 0) {
			rightZero = Integer.parseInt(matrixData[row][col - leftIndex]);
			if (rightZero == 0)
				totalBrickLength++;
			leftIndex++;
		}
		return totalBrickLength;
	}
	
	private static void setBrickInBeffer(int brickLength, String[] buffer, String[] topLine) {
		fillBuffer(buffer, "#");
		for (int i = 0; i < brickLength; i++) {
			buffer[i] = topLine[i];
		}
	}
	
	private static String[] getDataLine(String[][] matrixData, int rowNum, int colNum, int length) {
	    String rowData = String.join("", matrixData[rowNum]);
	    //System.out.println(rowData + "   "  + colNum + "   "  +  colNum + length);
	    int first = colNum <= rowData.length() ? colNum : rowData.length();
	    int second = colNum + length <= rowData.length() ? colNum + length : rowData.length();
		return rowData.substring(first, second).split("");
	}
	
	private static void fillBuffer(String[] buffer, String data) {
		for (int i=0 ; i < buffer.length; i++) {
			buffer[i] = data;
		}
	}
	
	private static int removeIncompleteBrickAndGetLength(String[] buffer) {
		int length = 0;
		for (int i=0 ; i < buffer.length; i++) {
			if (!buffer[i].equals("#") && !buffer[i].equals("0")) {
				int size = Integer.parseInt(buffer[i]);
				size = size <= buffer.length ? size : buffer.length;
				boolean isBrickComplete = isCorrectBrick(buffer, i, size);
				if (isBrickComplete) {
					i += size - 1;
					length += size;
				} else {
					buffer[i] = "#";
				}
			}
		}
		return length;
	}
	
	public static int getBrickLengthInBuffer(String[] buffer) {
		int count = 0;
		for (String brick : buffer) {
			if (!brick.equals("#"))
				count++;
		}
		return count;
	}
	
	public static boolean isCorrectBrick(String[] row, int firstIndex, int brickSize) {
		int length = Integer.parseInt(row[firstIndex]);
		while (length == 0 && firstIndex < row.length - 1) {
			firstIndex++;
			length = Integer.parseInt(row[firstIndex]);
		}

		int y = (firstIndex + brickSize <= row.length) ? firstIndex + brickSize : row.length;
		String[] rowData = String.join("", row).substring(firstIndex, y).split("");
		
		if (length > rowData.length)
			return false;
		
		boolean isSame = true;
		String firstCharacter = rowData[0];
		for (String character : rowData) {
			if (!firstCharacter.equals(character))
				isSame = false;
		}
		
		return isSame;
	}
}