/**

 * SQL-DK

 * Copyright © 2013 František Kučera (frantovo.cz)

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program. If not, see <http://www.gnu.org/licenses/>.

 */

package info.globalcode.sql.dk.formatting;

import info.globalcode.sql.dk.Parameter;

import info.globalcode.sql.dk.configuration.DatabaseDefinition;

import java.util.EmptyStackException;

import java.util.EnumSet;

import java.util.List;

import java.util.Stack;

/**

 * <ol>

 * <li>ensures integrity – if methods are called in correct order and context</li>

 * <li>provides default implmentations of methods that does not produce any output for given

 * events</li>

 * </ol>

 *

 * @author Ing. František Kučera (frantovo.cz)

 */

public abstract class AbstractFormatter implements Formatter {

	private Stack<State> state = new Stack<>();

	private FormatterContext formatterContext;

	private ColumnsHeader currentColumnsHeader;

	private String currentQuery;

	private int currentColumnsCount;

	private int currentRowCount;

	private int resultSetCount;

	public AbstractFormatter(FormatterContext formatterContext) {

		this.formatterContext = formatterContext;

		state.push(State.ROOT);

	}

	protected String getCurrentRelationName() {

		if (getFormatterContext().getRelationNames() == null || getFormatterContext().getRelationNames().size() < resultSetCount) {

			return "r" + resultSetCount;

		} else {

			return getFormatterContext().getRelationNames().get(resultSetCount - 1);

		}

	}

	/*

	 * root

	 * .batch

	 * ..database

	 * ...statement

	 * ....@query

	 * ....@parameters

	 * ....resultSet

	 * .....row

	 * ......@columnValue

	 * ....@updatesResult

	 */

	protected enum State {

		ROOT,

		BATCH,

		DATABASE,

		STATEMENT,

		RESULT_SET,

		ROW

	}

	/**

	 * Go down in hierarchy.

	 * Pushes new state and verifies the old one.

	 *

	 * @param current the new state – currently entering

	 * @param expected expected previous states (any of them is valid)

	 * @return previous state

	 * @throws IllegalStateException if previous state was not one from expected

	 */

	private State pushState(State current, EnumSet expected) {

		State previous = state.peek();

		if (expected.contains(previous)) {

			state.push(current);

			return previous;

		} else {

			throw new IllegalStateException("Formatter was in wrong state: " + previous + " when it should be in one of: " + expected);

		}

	}

	protected State peekState(EnumSet expected) {

		State current = state.peek();

		if (expected.contains(current)) {

			return current;

		} else {

			throw new IllegalStateException("Formatter is in wrong state: " + current + " when it should be in one of: " + expected);

		}

	}

	/**

	 * Go up in hierarchy.

	 * Pops the superior state/branch.

	 *

	 * @param expected expected superior state

	 * @return the superior state

	 * @throws IllegalStateException if superior state was not one from expected or if there is no

	 * more superior state (we are at root level)

	 */

	private State popState(EnumSet expected) {

		try {

			state.pop();

			State superior = state.peek();

			if (expected.contains(superior)) {

				return superior;

			} else {

				throw new IllegalStateException("Formatter had wrong superior state: " + superior + " when it should be in one of: " + expected);

			}

		} catch (EmptyStackException e) {

			throw new IllegalStateException("Formatter was already at root level – there is nothing above that.", e);

		}

	}

	@Override

	public void writeStartBatch() {

		pushState(State.BATCH, EnumSet.of(State.ROOT));

		resultSetCount = 0;

	}

	@Override

	public void writeEndBatch() {

		popState(EnumSet.of(State.ROOT));

	}

	@Override

	public void writeStartDatabase(DatabaseDefinition databaseDefinition) {

		pushState(State.DATABASE, EnumSet.of(State.BATCH));

	}

	@Override

	public void writeEndDatabase() {

		popState(EnumSet.of(State.BATCH));

	}

	@Override

	public void writeStartStatement() {

		pushState(State.STATEMENT, EnumSet.of(State.DATABASE));

	}

	@Override

	public void writeEndStatement() {

		popState(EnumSet.of(State.DATABASE));

	}

	@Override

	public void writeStartResultSet(ColumnsHeader header) {

		pushState(State.RESULT_SET, EnumSet.of(State.STATEMENT));

		resultSetCount++;

		currentRowCount = 0;

		currentColumnsHeader = header;

	}

	@Override

	public void writeEndResultSet() {

		popState(EnumSet.of(State.STATEMENT));

		currentColumnsHeader = null;

	}

	@Override

	public void writeQuery(String sql) {

		peekState(EnumSet.of(State.STATEMENT));

		if (currentColumnsHeader == null) {

			currentQuery = sql;

		} else {

			throw new IllegalStateException("Query string '" + sql + "' must be set before columns header – was already set: " + currentColumnsHeader);

		}

	}

	@Override

	public void writeParameters(List<? extends Parameter> parameters) {

		peekState(EnumSet.of(State.STATEMENT));

		if (currentColumnsHeader != null) {

			throw new IllegalStateException("Parameters '" + parameters + "' must be set before columns header – was already set: " + currentColumnsHeader);

		}

		if (currentQuery == null && parameters != null) {

			throw new IllegalStateException("Parameters '" + parameters + "' must be set after query – was not yet set.");

		}

	}

	@Override

	public void writeStartRow() {

		pushState(State.ROW, EnumSet.of(State.RESULT_SET));

		currentColumnsCount = 0;

		currentRowCount++;

	}

	@Override

	public void writeEndRow() {

		popState(EnumSet.of(State.RESULT_SET));

	}

	@Override

	public void writeColumnValue(Object value) {

		peekState(EnumSet.of(State.ROW));

		currentColumnsCount++;

		int declaredCount = currentColumnsHeader.getColumnCount();

		if (currentColumnsCount > declaredCount) {

			throw new IllegalStateException("Current columns count is " + currentColumnsCount + " which is more than declared " + declaredCount + " in header.");

		}

	}

	@Override

	public void writeUpdatesResult(int updatedRowsCount) {

		peekState(EnumSet.of(State.STATEMENT));

	}

	@Override

	public void close() throws FormatterException {

	}

	public FormatterContext getFormatterContext() {

		return formatterContext;

	}

	protected ColumnsHeader getCurrentColumnsHeader() {

		return currentColumnsHeader;

	}

	/**

	 * @return column number, 1 = first

	 */

	protected int getCurrentColumnsCount() {

		return currentColumnsCount;

	}

	protected boolean isCurrentColumnFirst() {

		return currentColumnsCount == 1;

	}

	protected boolean isCurrentColumnLast() {

		return currentColumnsCount == currentColumnsHeader.getColumnCount();

	}

	/**

	 * @return row number, 1 = first

	 */

	protected int getCurrentRowCount() {

		return currentRowCount;

	}

}