package de.hs_mannheim.informatik.spreadsheet;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
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) {

		if(rows>99)
			rows = 99;
		else if(rows<1)
			rows = 1;
		if(cols < 1)
			cols = 1;
		else if(cols > 26)
			cols = 26;

		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));
	}

	public String getCellName(int row, int col) {
		return "" + ((char) ('A' + col)) + (row+1);
	}

	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()>2)
			return Integer.parseInt(""+cellName.charAt(1)+cellName.charAt(2)) - 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.
	 * @param starCellName The upper left cell where data from the CSV file should be inserted.
	 * @return Nothing.
	 * @throws IOException If path does not exist.
	 */
	public void readCsv(String path, char separator, String startCellName) throws FileNotFoundException {
		Scanner sc = new Scanner(new File(path));
		ArrayList<String> memList = new ArrayList<>();

		while (sc.hasNextLine()) {
			memList.add(sc.nextLine());
		}

		String[][] memArr = new String[memList.size()][];
		for(int i = 0; i < memList.size(); i++)
			memArr[i] = (memList.get(i)).split(String.valueOf(separator));

		for (int r = getRow(startCellName); r < memList.size(); r++)
			for (int c = getCol(startCellName); c < memList.get(0).length(); c++)
				if(c<memArr[r].length)
					put(r, c, memArr[r][c]);

		sc.close();
	}

	/**
	 * A method for saving data to a CSV file.
	 *
	 * @param path The file to write.
	 * @return Nothing.
	 * @throws 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 cellName the name of the cell to be evaluated
	 * @return Nothing.
	 */
	private void evaluateCell(int row, int col) {
		String formula = cells[row][col].getFormula();
		String result = "";

		String substringStartCell1 = formula.substring(formula.length() - 6, formula.length() - 4);
		String substringStart2 = formula.substring(formula.length() - 6, formula.length() - 3);
		String substringEndCell = formula.substring(formula.length() - 3, formula.length() - 1);


		if (formula.startsWith("SUMME("))  // e.g. SUMME(A3:A8)
			if(formula.length()<13)
				result = "" + sum(substringStartCell1, substringEndCell);
			else if(formula.length()<14&&substringStart2.contains(":"))
				result = "" + sum(substringStartCell1, substringEndCell);
			else if(formula.length()<14&&!substringStart2.contains(":"))
				result = "" + sum(substringStart2, substringEndCell);
			else if(formula.length()<15)
				result = "" + sum(substringStart2, substringEndCell);
			else
				result = "0";


		else if (formula.startsWith("PRODUKT("))  // e.g. PRODUKT(A3:B9)
			if(formula.length()<15)
				result = "" + product(substringStartCell1, substringEndCell);
			else if(formula.length()<16&&substringStart2.contains(":"))
				result = "" + product(substringStartCell1, substringEndCell);
			else if(formula.length()<16&&!substringStart2.contains(":"))
				result = "" + product(substringStart2, substringEndCell);
			else if(formula.length()<17)
				result = "" + product(substringStart2, substringEndCell);
			else
				result = "0";


		else if (formula.startsWith("MITTELWERT("))  // e.g. MITTELWERT(A3:A5)
			if(formula.length()<17)
				result = "" + average(substringStartCell1, substringEndCell);
			else if(formula.length()<18&&substringStart2.contains(":"))
				result = "" + average(substringStartCell1, substringEndCell);
			else if(formula.length()<18&&!substringStart2.contains(":"))
				result = "" + average(substringStart2, substringEndCell);
			else if(formula.length()<19)
				result = "" + average(substringStart2, substringEndCell);
			else
				result = "0";


		else if (formula.startsWith("STABW("))  // e.g. STABW(C6:D8) -> Standardabweichung
			if(formula.length()<13)
				result = "" + standardDeviation(substringStartCell1, substringEndCell);
			else if(formula.length()<14&&substringStart2.contains(":"))
				result = "" + standardDeviation(substringStartCell1, substringEndCell);
			else if(formula.length()<14&&!substringStart2.contains(":"))
				result = "" + standardDeviation(substringStart2, substringEndCell);
			else if(formula.length()<15)
				result = "" + standardDeviation(substringStart2, substringEndCell);
			else
				result = "0";


		else if (formula.startsWith("MIN("))  // e.g. MIN(C13:H13) -> größter Wert
			result = "TODO"; // TODO
		else if (formula.startsWith("MAX("))  // e.g. MAX(A1:A10) -> Standardabweichung
			result = "TODO"; // TODO
		else if (!formula.isEmpty()) {
			try {
				result = "" + calculate(formula);
			} catch (ArithmeticException ae) {
				result = "exc.";
			}
		}

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

	/**
	 * 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(int r = getRow(startCellName); r<getRow(endCellName)+1; r++)
			for(int c = getCol(startCellName); c<getCol(endCellName)+1; c++)
				try {
					result += Long.parseLong(cells[r][c].getValue());
				} catch (NumberFormatException n){}

		return result;
	}
	private long product(String startCellName, String endCellName) {
		long result = Long.parseLong(cells[0][0].getValue());;

		for(int r = getRow(startCellName); r<getRow(endCellName)+1; r++)
			for(int c = getCol(startCellName); c<getCol(endCellName)+1; c++)
				try {
					result *= Long.parseLong(cells[r+1][c+1].getValue());
				} catch (NumberFormatException n){}

		return result;
	}
	private long average(String startCellName, String endCellName){
		long result = 0;
		int counter = 0;
		for(int r = getRow(startCellName); r<getRow(endCellName)+1; r++)
			for(int c = getCol(startCellName); c<getCol(endCellName)+1; c++)
				try {
					result += Long.parseLong(cells[r][c].getValue());
					counter ++;
				} catch (NumberFormatException n){}
		result /= counter;
		return result;
	}
	private double standardDeviation(String startCellName, String endCellName){
		ArrayList<String> cellNames = new ArrayList<>();

		long avg = 0;
		int counter = 0;
		for(int r = getRow(startCellName); r<getRow(endCellName)+1; r++)
			for(int c = getCol(startCellName); c<getCol(endCellName)+1; c++)
				try {
					avg += Long.parseLong(cells[r][c].getValue());
					counter ++;
					cellNames.add(getCellName(r, c));
				} catch (NumberFormatException n){}
		avg /= counter;
		//average

		ArrayList<String> copyCellNames = new ArrayList<>(cellNames);
		double[] frequency = new double[cellNames.size()];
		Arrays.fill(frequency,1);
		ArrayList<Double> relativeFrequency = new ArrayList<>();
		double mem = 0;

		for(int i = 0; i< cellNames.size(); i++) {
			for(int t = 0; t<cellNames.size(); t++){
				if(((get(cellNames.get(i)).isEmpty())&&!(get(cellNames.get(t)).isEmpty()))&&(Double.parseDouble(get(cellNames.get(t)))==0)&&(t!=i)){
					cellNames.remove(t);
					frequency[i]++;
					t = 0;
				}else if((!(get(cellNames.get(i)).isEmpty())&&(get(cellNames.get(t)).isEmpty()))&&(Double.parseDouble(get(cellNames.get(i)))==0)&&(t!=i)){
					cellNames.remove(t);
					frequency[i]++;
					t = 0;
				}else if((get(cellNames.get(i)).isEmpty())&&(get(cellNames.get(t)).isEmpty())&&(t!=i)){
					cellNames.remove(t);
					frequency[i]++;
					t = 0;
				}else if((t!=i)&&(Double.parseDouble(get(cellNames.get(i))))==(Double.parseDouble(get(cellNames.get(t))))){
					cellNames.remove(t);
					frequency[i] ++;
					t = 0;
				}
			}
		}
		//delete all duplicates

		for(int i = 0; i< cellNames.size(); i++)
			relativeFrequency.add(i,frequency[i]/copyCellNames.size());


		if(get(cellNames.get(0)).isEmpty())
			mem = ((0 - avg)*(0 - avg))
					* relativeFrequency.get(0);

		else
			mem = ((Double.parseDouble(get(cellNames.get(0))) - avg)*(Double.parseDouble(get(cellNames.get(0))) - avg))
					* relativeFrequency.get(0);

		for(int i = 1; i<cellNames.size(); i++)
			if(get(cellNames.get(i)).isEmpty())
				mem += ((0 - avg)*(0 - avg))
						* relativeFrequency.get(i);
			else
				mem += ((Double.parseDouble(get(cellNames.get(i))) - avg)*(Double.parseDouble(get(cellNames.get(i))) - avg))
						* relativeFrequency.get(i);
		return Math.sqrt(mem);
		//standardDeviation formula
	}

	/**
	 * 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 result = 0;
		long currentOperand = 0;
		String currentOperator = "+";
		boolean firstOperator = true;

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

			if (s.matches(("[0-9]+")))
				currentOperand = Long.parseLong(s);
			else if ((s.matches("[A-Z][1-9]*") || s.matches("[A-Z][1-9]*+")) && get(s).isEmpty())
				currentOperand = 0;
			else if ((s.matches("[A-Z][1-9]*") || s.matches("[A-Z][1-9]*+"))) {
				currentOperand = Long.parseLong(get(s));
			} else {
				if (!firstOperator) {
					result = evaluateOperator(result, currentOperand, currentOperator);
				} else {
					result = currentOperand;
					firstOperator = false;
				}
				currentOperator = s;
			}
		}

		if (!firstOperator) {
			result = evaluateOperator(result, currentOperand, currentOperator);
		} else
			result = currentOperand;

		return result;
	}
	private long evaluateOperator(long result, long currentOperand, String currentOperator) {
		switch (currentOperator) {
			case "+":
				return result + currentOperand;
			case "-":
				return result - currentOperand;
			case "*":
				return result * currentOperand;
			case "/":
				return result / currentOperand;
			default:
				throw new IllegalArgumentException("Invalid operator: " + currentOperator);
		}
	}

	///--- ui methods
	public void updateSpreadsheet() {
		for (int r = 0; r < cells.length; r++)
			for (int c = 0; c < cells[r].length; c++)
				evaluateCell(r, c);
	}
	public String toString() {
		StringBuilder sb = new StringBuilder();

		sb.append(System.lineSeparator());
		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());
			for (int i = 0; i < cells[0].length; i++) {
				sb.append("----------------");
			}
			sb.append("------");
			sb.append(System.lineSeparator());
			sb.append(String.format(" " + "%2s", rc++) + "  |");

			for (Cell c : r) {
				sb.append(" " + String.format("%13s", c) + " |");
			}

		}
		sb.append(System.lineSeparator());
		for (int i = 0; i < cells[0].length; i++) {
			sb.append("----------------");
		}
		sb.append("------");
		sb.append(System.lineSeparator());
		return sb.toString();


	}
}