package de.hs_mannheim.informatik.spreadsheet;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;



/**
 * A simplified spreadsheet class for the PR1 programming lab at Hochschule Mannheim.
 * One aspect worth mentioning is that it only supports long numbers, not doubles.
 *
 * @author  Oliver Hummel
 */
public class Spreadsheet {
	Cell[][] cells;

	/**
	 * Constructor that creates a Spreadsheet of size rows * cols.
	 * @param rows number of rows
	 * @param cols number of columns
	 */
	public Spreadsheet(int rows, int cols) throws IllegalArgumentException {

		if(rows < 1 || rows > 99 || cols < 1 || cols > 26){
			throw new IllegalArgumentException("Range in rows 1-99; Range in cols 1-26");
		}else {
			cells = new Cell[rows][cols];

			for (int r = 0; r < rows; r++)
				for (int c = 0; c < cols; c++)
					cells[r][c] = new Cell();
		}
	}

	// -----
	// retrieve or change values of cells

	private String get(int row, int col) {
		return cells[row][col].getValue();
	}

	public String get(String cellName) {
		cellName = cellName.toUpperCase();
		return get(getRow(cellName), getCol(cellName));
	}

	private void put(int row, int col, String value) {
		if (!value.startsWith("="))
			cells[row][col].setValue(value);
		else {
			cells[row][col].setFormula(value);
			evaluateCell(row, col);
		}
	}

	public void put(String cellName, String value) {
		cellName = cellName.toUpperCase();
		put(getRow(cellName), getCol(cellName), value);
	}

	private int getCol(String cellName) {
		return cellName.charAt(0) - 'A';
	}

	private int getRow(String cellName) {
		if(cellName.length()==3){
			return Integer.parseInt(cellName.substring(1))-1;}
		return cellName.charAt(1) - '1';
	}

	// -----
	// business logic

	/**
	 * A method for reading in data from a CSV file.
	 * @param path The file to read.
	 * @param separator The char used to split up the input, e.g. a comma or a semicolon.
	 * @exception IOException If path does not exist.
	 */
	public void readCsv(String path, String separator) throws FileNotFoundException {

			ArrayList<String> lines = new ArrayList<>();
			Scanner scan = new Scanner(new File(path));

			while (scan.hasNextLine()) {
				lines.add(scan.nextLine());
			}

			String[] linesArray = lines.toArray(new String[lines.size()]);
			ArrayList<int[]> values = new ArrayList<>();
			for(int i = 0; i < linesArray.length; i++) {
				//System.out.println(linesArray[i]);
				String[] zwischenSchritt = linesArray[i].split(separator);
				for (int j = 0; j < zwischenSchritt.length; j++) {
					System.out.println(zwischenSchritt[j]);
					if(zwischenSchritt[j].startsWith("=")){
						values.add(new int[]{i, j});
					}else{
						this.put(i, j, zwischenSchritt[j]);
					}

				}
				for(int[] cell : values){
					String[] value = linesArray[cell[0]].split(",");
					String formula = value[cell[1]];
					this.put(cell[0], cell[1], formula);
				}
				scan.close();
			}


	}
	/**
	 * A method for saving data to a CSV file.
	 * @param path The file to write.
	 * @exception IOException If path does not exist.
	 */
	public void saveCsv(String path) throws FileNotFoundException {
		PrintWriter out = new PrintWriter(path);

		for (Cell[] row : cells) {
			for (Cell cell : row) {
				if (!cell.getFormula().isEmpty())
					out.print("=" + cell.getFormula());
				else
					out.print(cell.getValue());

				if (cell != row[cells[0].length-1])
					out.print(",");
			}
			out.println();
		}

		out.close();
	}

	/**
	 * This method does the actual evaluation/calcluation of a specific cell
	 * @param row the row of the cell to be evaluated
	 * @param col the col of the cell to be evaluated
	 */
	private void evaluateCell(int row, int col) {
		String formula = cells[row][col].getFormula();
		String result = "";
		int colon = formula.indexOf(':');
		String endSubstring = formula.substring((colon + 1), (formula.length()-1));

		if (formula.startsWith("SUMME("))  // e.g. SUMME(A3:A8)
			result = "" + sum(formula.substring(6, colon), endSubstring);
		else if (formula.startsWith("PRODUKT("))  // e.g. PRODUKT(A3:B9)
			result = "" + prod(formula.substring(8, colon), endSubstring);
		else if (formula.startsWith("MITTELWERT("))  // e.g. MITTELWERT(A3:A5)
			result = "" + mit(formula.substring(11, colon), endSubstring);
		else if (formula.startsWith("STABW("))  // e.g. STABW(C6:D8) -> Standardabweichung
			result = "" + stabw(formula.substring(6, colon), endSubstring);
		else if (formula.startsWith("MIN("))  // e.g. MIN(C13:H13) -> kleinster Wert
			result = "" + min(formula.substring(4, colon), endSubstring);
		else if (formula.startsWith("MAX("))  // e.g. MAX(A1:A10) -> größter Wert
			result = "" + max(formula.substring(4, colon), endSubstring);
		else if (!formula.isEmpty()) {
			try {
				result = "" + calculate(formula);
			} catch(ArithmeticException ae) {
				result = "exc.";
			}
		}

		cells[row][col].setValue("" + result);
	}

	/**
	 * Method for calculating the amount of cells with values inside a rectangular block of cells, such as from A1 to B3.
	 * @param startCellName The name of the cell in the upper left corner of the rectangle.
	 * @param endCellName The name of the cell in the lower right corner of the rectangle.
	 * @return The counted cells with values calculated.
	 */
	private long counterOfCellsWithValue(String startCellName, String endCellName){
		long counter = 0;
		for(char col = startCellName.charAt(0); col <= endCellName.charAt(0); col++){

			for(int row = Integer.parseInt(startCellName.substring(1)); row <= Integer.parseInt(endCellName.substring(1)); row++) {
				String value = get((row - 1), (col - 'A'));

				if(!value.isEmpty()){
					counter++;
				}
			}
		}
		return counter;
	}

	/**
	 * Method for calculating the sum of a rectangular block of cells, such as from A1 to B3.
	 * @param startCellName The name of the cell in the upper left corner of the rectangle.
	 * @param endCellName The name of the cell in the lower right corner of the rectangle.
	 * @return The sum calculated.
	 */
	private long sum(String startCellName, String endCellName) {
		long result = 0;

		for(char col = startCellName.charAt(0); col <= endCellName.charAt(0); col++){

			for(int row = Integer.parseInt(startCellName.substring(1)); row <= Integer.parseInt(endCellName.substring(1)); row++) {

				String value = get((row - 1), (col - 'A')); //"-1" because we start with 1 instead of 0. "-A" because A in ascii is 65, but we start with 0

				if(!value.isEmpty()){
					result += Long.parseLong(value);
				}
			}
		}
		return result;
	}

	/**
	 * Method for calculating the product of a rectangular block of cells, such as from A1 to B3.
	 * @param startCellName The name of the cell in the upper left corner of the rectangle.
	 * @param endCellName The name of the cell in the lower right corner of the rectangle.
	 * @return The product calculated.
	 */
	private long prod(String startCellName, String endCellName) {
		long result = 0;

		for(char col = startCellName.charAt(0); col <= endCellName.charAt(0); col++){

			for(int row = Integer.parseInt(startCellName.substring(1)); row <= Integer.parseInt(endCellName.substring(1)); row++) {

				String value = get((row - 1), (col - 'A'));
				System.out.println(value);

				if(result == 0){
					result = Long.parseLong(value);

				}
				else if(!value.isEmpty() && !(value.equals("0"))){
					result *= Long.parseLong(value);
				}

			}
		}
		return result;
	}

	/**
	 * Method for calculating the arithmetic average of a rectangular block of cells, such as from A1 to B3.
	 * @param startCellName The name of the cell in the upper left corner of the rectangle.
	 * @param endCellName The name of the cell in the lower right corner of the rectangle.
	 * @return The arithmetic average calculated.
	 */
	private long mit(String startCellName, String endCellName) {

		return sum(startCellName, endCellName)/ counterOfCellsWithValue(startCellName, endCellName);
	}

	/**
	 * Method for calculating the standard deviation of a rectangular block of cells, such as from A1 to B3.
	 * @param startCellName The name of the cell in the upper left corner of the rectangle.
	 * @param endCellName The name of the cell in the lower right corner of the rectangle.
	 * @return The standard deviation calculated.
	 */
	private long stabw(String startCellName, String endCellName) {
		long mean = mit(startCellName, endCellName);
		long counter = counterOfCellsWithValue(startCellName, endCellName);
		long result = 0;

		for(char col = startCellName.charAt(0); col <= endCellName.charAt(0); col++) {

			for (int row = Integer.parseInt(startCellName.substring(1)); row <= Integer.parseInt(endCellName.substring(1)); row++) {

				String value = get((row - 1), (col - 'A'));

				if(!value.isEmpty()){
					result += (long) Math.pow(Long.parseLong(value) - mean, 2);
				}
			}
		}
		return (long) Math.sqrt(result / counter);
	}

	/**
	 * Method for finding the maximum value of a rectangular block of cells, such as from A1 to B3.
	 * @param startCellName The name of the cell in the upper left corner of the rectangle.
	 * @param endCellName The name of the cell in the lower right corner of the rectangle.
	 * @return The minimum value of the block.
	 */
	private long min(String startCellName, String endCellName) {
		long result = 0;

		for(char col = startCellName.charAt(0); col <= endCellName.charAt(0); col++){

			for(int row = Integer.parseInt(startCellName.substring(1)); row <= Integer.parseInt(endCellName.substring(1)); row++) {

				String value = get((row - 1), (col - 'A')); //"-1" because we start with 1 instead of 0. "-A" because A in ascii is 65, but we start with 0

				if((col == startCellName.charAt(0)) && (row == Integer.parseInt(startCellName.substring(1)))) {
					result = Long.parseLong(value);
				}
				else if(!value.isEmpty() && (Long.parseLong(value) < result)){
					result = Long.parseLong(value);
				}
			}
		}

		return result;
	}

	/**
	 * Method for finding the maximum value of a rectangular block of cells, such as from A1 to B3.
	 * @param startCellName The name of the cell in the upper left corner of the rectangle.
	 * @param endCellName The name of the cell in the lower right corner of the rectangle.
	 * @return The maximum value of the block.
	 */
	private long max(String startCellName, String endCellName) {
		long result = 0;

		for(char col = startCellName.charAt(0); col <= endCellName.charAt(0); col++){

			for(int row = Integer.parseInt(startCellName.substring(1)); row <= Integer.parseInt(endCellName.substring(1)); row++) {

				String value = get((row - 1), (col - 'A')); //"-1" because we start with 1 instead of 0. "-A" because A in ascii is 65, but we start with 0

				if((col == startCellName.charAt(0)) && (row == Integer.parseInt(startCellName.substring(1)))) {
					result = Long.parseLong(value);
				}
				else if(!value.isEmpty() && (Long.parseLong(value) > result)){
					result = Long.parseLong(value);
				}
			}
		}

		return result;
	}


	/**
	 * This method calculates the result of a "normal" algebraic expression. It only needs to support
	 * expressions like =B4 or =2+A3-B2, i.e. only with int numbers and other cells and with plus,
	 * minus, times, split only. An expression always starts with either a number or a cell name. If it
	 * continues, it is guaranteed that this is followed by an operator and either a number or a
	 * cell name again. It is NOT required to implement dot before dash or parentheses in formulas.
	 * @param formula The expression to be evaluated.
	 * @return The result calculated.
	 */
	private long calculate(String formula) throws ArithmeticException {
		Matcher m = Pattern.compile("([A-Z][0-9]*)|[-\\+\\*/]|[0-9]*").matcher(formula);

		long res = 0;
		char operator = '+';

		while (m.find()) {
			String s = m.group();
			long value;

			if(s.isEmpty()){
				continue;
			}

			if (!(s.matches("[-\\+\\*/]"))) {
				if(s.matches("[A-Z][0-9]*")) {
					int col = this.getCol(s);
					int row = this.getRow(s);

					value = Long.parseLong(cells[row][col].getValue());

				}else{
					value = Long.parseLong(s);
				}

				switch(operator) {
					case '+':
						res += value;
						break;
					case '-':
						res -= value;
						break;
					case '*':
						res *= value;
						break;
					case '/':
						if (res != 0) {
							res /= value;
							break;
						}
				}
			}else{
				operator = s.charAt(0);
			}
		}
		return res;
	}

	// -----

	public String toString() {
		StringBuilder sb = new StringBuilder();

		sb.append("    ");
		for (int i = 0; i < cells[0].length; i++) {
			sb.append("  " + (char)('A'+ i) + "  | ");
		}

		int rc = 1;
		for (Cell[] r : cells) {
			sb.append(System.lineSeparator());
			sb.append(String.format("%2s", rc++) + ": ");

			for (Cell c : r) {
				sb.append(c + " | ");
			}

		}
		return sb.toString();
	}

}