/**

 * 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

 * the Free Software Foundation, either version 3 of the License, or

 * (at your option) any later version.

 *

 * 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;

import static info.globalcode.sql.dk.Functions.isNotEmpty;

import static info.globalcode.sql.dk.Functions.equalz;

import info.globalcode.sql.dk.InfoLister.InfoType;

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

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

import java.io.InputStream;

import java.io.OutputStream;

import java.util.ArrayList;

import java.util.Collection;

import java.util.EnumSet;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Set;

import java.util.regex.Pattern;

import java.util.regex.PatternSyntaxException;

/**

 * Holds options from command line, validates them, combines with configuration and provides derived

 * objects.

 *

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

 */

public class CLIOptions {

	public static final String DEFAULT_NAME_PREFIX = ":";

	public static final String DEFAULT_NAME_SUFFIX = "(?=([^\\w]|$))";

	private String sql;

	private String databaseName;

	private final Set<String> databaseNamesToTest = new LinkedHashSet<>();

	private final Set<String> databaseNamesToListProperties = new LinkedHashSet<>();

	private final Set<String> formatterNamesToListProperties = new LinkedHashSet<>();

	private String namePrefix = DEFAULT_NAME_PREFIX;

	private String nameSuffix = DEFAULT_NAME_SUFFIX;

	private String formatterName;

	private boolean batch;

	private final Properties formatterProperties = new Properties();

	private final Properties databaseProperties = new Properties();

	public enum MODE {

		QUERY_NOW,

		PREPARE_BATCH,

		EXECUTE_BATCH,

		JUST_SHOW_INFO

	}

	private final List<NamedParameter> namedParameters = new ArrayList<>();

	private final List<Parameter> numberedParameters = new ArrayList<>();

	private final EnumSet<InfoType> showInfo = EnumSet.noneOf(InfoType.class);

	public void validate() throws InvalidOptionsException {

		InvalidOptionsException e = new InvalidOptionsException();

		MODE mode = getMode();

		if (mode == null) {

			e.addProblem(new InvalidOptionsException.OptionProblem("Invalid combination of DB, SQL and BATCH – please specify just 2 of this 3 options"));

		} else if (mode == MODE.JUST_SHOW_INFO) {

			if (!namedParameters.isEmpty()) {

				e.addProblem(new InvalidOptionsException.OptionProblem("Do not use named parameters if just showing info."));

			}

			if (!numberedParameters.isEmpty()) {

				e.addProblem(new InvalidOptionsException.OptionProblem("Do not use numbered parameters if just showing info."));

			}

			if (isNotEmpty(sql, false)) {

				e.addProblem(new InvalidOptionsException.OptionProblem("Do not specify SQL if just showing info."));

			}

			if (isNotEmpty(databaseName, false)) {

				e.addProblem(new InvalidOptionsException.OptionProblem("Do not specify database if just showing info."));

			}

			if (batch) {

				e.addProblem(new InvalidOptionsException.OptionProblem("Do not specify batch if just showing info."));

			}

			if (!equalz(namePrefix, DEFAULT_NAME_PREFIX)) {

				e.addProblem(new InvalidOptionsException.OptionProblem("Do not specify name prefix if just showing info."));

			}

			if (!equalz(nameSuffix, DEFAULT_NAME_SUFFIX)) {

				e.addProblem(new InvalidOptionsException.OptionProblem("Do not specify name suffix if just showing info."));

			}

			if (showInfo.contains(InfoType.CONNECTION) && databaseNamesToTest.isEmpty()) {

				e.addProblem(new InvalidOptionsException.OptionProblem("Please specify which database should be tested."));

			}

			if (showInfo.contains(InfoType.JDBC_PROPERTIES) && databaseNamesToListProperties.isEmpty()) {

				e.addProblem(new InvalidOptionsException.OptionProblem("Please specify for which database the properties should be listed."));

			}

		}

		if (!namedParameters.isEmpty() && !numberedParameters.isEmpty()) {

			e.addProblem(new InvalidOptionsException.OptionProblem("Named and numbered parameters can not be used together in one command."));

		}

		try {

			Pattern.compile(namePrefix + "test" + nameSuffix);

		} catch (PatternSyntaxException regexException) {

			e.addProblem(new InvalidOptionsException.OptionProblem("Ivalid regular expression in name prefix or suffix", regexException));

		}

		if (e.hasProblems()) {

			throw e;

		}

	}

	private boolean hasSql() {

		return isNotEmpty(getSql(), true);

	}

	private boolean hasDb() {

		return isNotEmpty(getDatabaseName(), true);

	}

	/**

	 * Depends on options: DB, BATCH, SQL

	 *

	 * @return mode | or null if options are not yet initialized or combination of options is

	 * invalid

	 */

	public MODE getMode() {

		if (hasDb() && !batch && hasSql()) {

			return MODE.QUERY_NOW;

		} else if (!hasDb() && batch && hasSql()) {

			return MODE.PREPARE_BATCH;

		} else if (hasDb() && batch && !hasSql()) {

			return MODE.EXECUTE_BATCH;

		} else {

			return showInfo.isEmpty() ? null : MODE.JUST_SHOW_INFO;

		}

	}

	public String getSql() {

		return sql;

	}

	public void setSql(String sql) {

		this.sql = sql;

	}

	public String getDatabaseName() {

		return databaseName;

	}

	public void setDatabaseName(String databaseName) {

		this.databaseName = databaseName;

	}

	public void setBatch(boolean batch) {

		this.batch = batch;

	}

	public Collection<NamedParameter> getNamedParameters() {

		return namedParameters;

	}

	public List<Parameter> getNumberedParameters() {

		return numberedParameters;

	}

	public void addNumberedParameter(Parameter p) {

		numberedParameters.add(p);

	}

	public void addNamedParameter(NamedParameter p) {

		namedParameters.add(p);

	}

	public Properties getDatabaseProperties() {

		return databaseProperties;

	}

	public Properties getFormatterProperties() {

		return formatterProperties;

	}

	public void addDatabaseProperty(Property p) {

		databaseProperties.add(p);

	}

	public void addFormatterProperty(Property p) {

		formatterProperties.add(p);

	}

	/**

	 * @return regular expression describing the name prefix

	 */

	public String getNamePrefix() {

		return namePrefix;

	}

	/**

	 * @param namePrefix

	 * @see #getNamePrefix()

	 */

	public void setNamePrefix(String namePrefix) {

		this.namePrefix = namePrefix;

	}

	/**

	 * @return regular expression describing the name prefix

	 */

	public String getNameSuffix() {

		return nameSuffix;

	}

	/**

	 * @param nameSuffix

	 * @see #getNameSuffix()

	 */

	public void setNameSuffix(String nameSuffix) {

		this.nameSuffix = nameSuffix;

	}

	public String getFormatterName() {

		return formatterName;

	}

	public void setFormatterName(String formatterName) {

		this.formatterName = formatterName;

	}

	public void addShowInfo(InfoType info) {

		showInfo.add(info);

	}

	public EnumSet<InfoType> getShowInfo() {

		return showInfo;

	}

	public Set<String> getDatabaseNamesToTest() {

		return databaseNamesToTest;

	}

	public void addDatabaseNameToTest(String name) {

		databaseNamesToTest.add(name);

	}

	public Set<String> getDatabaseNamesToListProperties() {

		return databaseNamesToListProperties;

	}

	public void addDatabaseNameToListProperties(String name) {

		databaseNamesToListProperties.add(name);

	}

	public Set<String> getFormatterNamesToListProperties() {

		return formatterNamesToListProperties;

	}

	public void addFormatterNameToListProperties(String name) {

		formatterNamesToListProperties.add(name);

	}

	public SQLCommand getSQLCommand() {

		if (namedParameters.isEmpty()) {

			return new SQLCommandNumbered(sql, numberedParameters);

		} else {

			return new SQLCommandNamed(sql, namedParameters, namePrefix, nameSuffix);

		}

	}

	public OutputStream getOutputStream() {

		return System.out;

	}

	public InputStream getInputStream() {

		return System.in;

	}

}