/**
 * Copyright (C) 2022 Adrien Hopkins
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
package sevenUnitsGUI;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;

import sevenUnits.unit.UnitType;
import sevenUnits.utils.NameSymbol;

/**
 * A class that simulates a View (supports both unit and expression conversion)
 * for testing. Getters and setters work as expected.
 * 
 * @author Adrien Hopkins
 * @since 2022-01-29
 */
final class ViewBot implements UnitConversionView, ExpressionConversionView {
	/** The presenter that works with this ViewBot */
	private final Presenter presenter;
	
	/** The dimensions available to select from */
	private Set<String> dimensionNames;
	/** The expression in the From field */
	private String fromExpression;
	/** The expression in the To field */
	private String toExpression;
	/**
	 * The user-provided string representing the value in {@code fromSelection}
	 */
	private String inputValue;
	/** The unit selected in the From selection */
	private Optional<String> fromSelection;
	/** The unit selected in the To selection */
	private Optional<String> toSelection;
	/** The currently selected dimension */
	private Optional<String> selectedDimensionName;
	/** The units available in the From selection */
	private Set<String> fromUnits;
	/** The units available in the To selection */
	private Set<String> toUnits;
	
	/** Saved outputs of all unit conversions */
	private final List<UnitConversionRecord> unitConversions;
	/** Saved outputs of all unit expressions */
	private final List<UnitConversionRecord> expressionConversions;
	
	/**
	 * Creates a new {@code ViewBot} with a new presenter.
	 *
	 * @since 2022-01-29
	 */
	public ViewBot() {
		this.presenter = new Presenter(this);
		
		this.unitConversions = new ArrayList<>();
		this.expressionConversions = new ArrayList<>();
	}
	
	/**
	 * @return list of records of expression conversions done by this bot
	 * @since 2022-04-09
	 */
	public List<UnitConversionRecord> expressionConversionList() {
		return this.expressionConversions;
	}
	
	/**
	 * @return the available dimensions
	 * @since 2022-01-29
	 */
	@Override
	public Set<String> getDimensionNames() {
		return this.dimensionNames;
	}
	
	@Override
	public String getFromExpression() {
		return this.fromExpression;
	}
	
	@Override
	public Optional<String> getFromSelection() {
		return this.fromSelection;
	}
	
	/**
	 * @return the units available for selection in From
	 * @since 2022-01-29
	 */
	@Override
	public Set<String> getFromUnitNames() {
		return Collections.unmodifiableSet(this.fromUnits);
	}
	
	@Override
	public String getInputValue() {
		return this.inputValue;
	}
	
	/**
	 * @return the presenter associated with tihs view
	 * @since 2022-01-29
	 */
	public Presenter getPresenter() {
		return this.presenter;
	}
	
	@Override
	public Optional<String> getSelectedDimensionName() {
		return this.selectedDimensionName;
	}
	
	@Override
	public String getToExpression() {
		return this.toExpression;
	}
	
	@Override
	public Optional<String> getToSelection() {
		return this.toSelection;
	}
	
	/**
	 * @return the units available for selection in To
	 * @since 2022-01-29
	 */
	@Override
	public Set<String> getToUnitNames() {
		return Collections.unmodifiableSet(this.toUnits);
	}
	
	@Override
	public Optional<String> getViewedPrefixName() {
		throw new UnsupportedOperationException("Not implemented yet");
	}
	
	@Override
	public Optional<String> getViewedUnitName() {
		throw new UnsupportedOperationException("Not implemented yet");
	}
	
	@Override
	public void setDimensionNames(Set<String> dimensionNames) {
		this.dimensionNames = Objects.requireNonNull(dimensionNames,
				"dimensions may not be null");
	}
	
	/**
	 * Sets the From expression (as in {@link #getFromExpression}).
	 *
	 * @param fromExpression the expression to convert from
	 * @throws NullPointerException if {@code fromExpression} is null
	 * @since 2022-01-29
	 */
	public void setFromExpression(String fromExpression) {
		this.fromExpression = Objects.requireNonNull(fromExpression,
				"fromExpression cannot be null.");
	}
	
	/**
	 * @param fromSelection the fromSelection to set
	 * @since 2022-01-29
	 */
	public void setFromSelection(Optional<String> fromSelection) {
		this.fromSelection = Objects.requireNonNull(fromSelection,
				"fromSelection cannot be null");
	}
	
	/**
	 * @param fromSelection the fromSelection to set
	 * @since 2022-02-10
	 */
	public void setFromSelection(String fromSelection) {
		this.setFromSelection(Optional.of(fromSelection));
	}
	
	@Override
	public void setFromUnitNames(Set<String> units) {
		this.fromUnits = Objects.requireNonNull(units, "units may not be null");
	}
	
	/**
	 * @param inputValue the inputValue to set
	 * @since 2022-01-29
	 */
	public void setInputValue(String inputValue) {
		this.inputValue = inputValue;
	}
	
	/**
	 * @param selectedDimension the selectedDimension to set
	 * @since 2022-01-29
	 */
	public void setSelectedDimensionName(
			Optional<String> selectedDimensionName) {
		this.selectedDimensionName = selectedDimensionName;
	}
	
	public void setSelectedDimensionName(String selectedDimensionName) {
		this.setSelectedDimensionName(Optional.of(selectedDimensionName));
	}
	
	/**
	 * Sets the To expression (as in {@link #getToExpression}).
	 *
	 * @param toExpression the expression to convert to
	 * @throws NullPointerException if {@code toExpression} is null
	 * @since 2022-01-29
	 */
	public void setToExpression(String toExpression) {
		this.toExpression = Objects.requireNonNull(toExpression,
				"toExpression cannot be null.");
	}
	
	/**
	 * @param toSelection the toSelection to set
	 * @since 2022-01-29
	 */
	public void setToSelection(Optional<String> toSelection) {
		this.toSelection = Objects.requireNonNull(toSelection,
				"toSelection cannot be null.");
	}
	
	public void setToSelection(String toSelection) {
		this.setToSelection(Optional.of(toSelection));
	}
	
	@Override
	public void setToUnitNames(Set<String> units) {
		this.toUnits = Objects.requireNonNull(units, "units may not be null");
	}
	
	@Override
	public void setViewablePrefixNames(Set<String> prefixNames) {
		throw new UnsupportedOperationException("Not implemented yet");
	}
	
	@Override
	public void setViewableUnitNames(Set<String> unitNames) {
		throw new UnsupportedOperationException("Not implemented yet");
	}
	
	@Override
	public void showErrorMessage(String title, String message) {
		System.err.printf("%s: %s%n", title, message);
	}
	
	@Override
	public void showExpressionConversionOutput(UnitConversionRecord uc) {
		this.expressionConversions.add(uc);
		System.out.println("Expression Conversion: " + uc);
	}
	
	@Override
	public void showPrefix(NameSymbol name, String multiplierString) {
		throw new UnsupportedOperationException("Not implemented yet");
	}
	
	@Override
	public void showUnit(NameSymbol name, String definition,
			String dimensionName, UnitType type) {
		throw new UnsupportedOperationException("Not implemented yet");
	}
	
	@Override
	public void showUnitConversionOutput(UnitConversionRecord uc) {
		this.unitConversions.add(uc);
		System.out.println("Unit Conversion: " + uc);
	}
	
	@Override
	public String toString() {
		return super.toString() + String.format("[presenter=%s]", this.presenter);
	}
	
	/**
	 * @return list of records of every unit conversion made by this bot
	 * @since 2022-04-09
	 */
	public List<UnitConversionRecord> unitConversionList() {
		return Collections.unmodifiableList(this.unitConversions);
	}
}