package tudelft.healthpsychology.traumaontologies.answerstate;

import java.util.Collection;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;

import tudelft.healthpsychology.traumaontologies.questiontypes.TypedQuestion;
import tudelft.healthpsychology.traumaontologies.questiontypes.SelectFromList;
import tudelft.utilities.tree.Tree;

/**
 * This AnswerState searches the ontology class that is the best match to what
 * the user has in mind. It tries to get as close as possible to the leaf nodes
 * in the ontology, offering the user to choose between children nodes
 * repeatedly.
 * 
 * The state transitioning works as follows. The idea is that the initial state
 * is with the most abstract {@link OntologyNode} fitting the expectations
 * (typically "object" or "person").
 * 
 * {@link #getOptions()} returns a set of more accurate ontology nodes that are
 * children of the current node. By calling {@link #with(String)} with one of
 * these nodes, the new state is that selected node. If tnat selected node is a
 * leaf node, the state is final and the process is done.
 * 
 * If with() is called with null it means "anders"/"other", which indicates the
 * answer is not in the node set. If that is selected:
 * <ul>
 * <li>user did not yet select anything else and we are at depth >1. Then we
 * decrease depth by 1.
 * <li>user previously selected a child or we are at depth 1. Then we select the
 * currently current node.
 * </ul>
 * immutable.
 */
public class OntologyAnswerState implements AnswerState {
	/**
	 * Max nr of options given to the user to choose from
	 */
	private static final int MAX_OPTIONS = 15;
	private static final String OTHER = "anders";
	private static final String IT = "het";

	private final String nodelabel;
	private final int depth;
	private final boolean isFocused;
	private final boolean isFinal;
	private final String nameOfObject;

	/**
	 * 
	 * @param qnodelabel the {@link OntologyNode} that needs to be more precise.
	 * @param depth      the depth at which the options are selected. 1 means
	 *                   direct children, 2 means children of the children, etc.
	 *                   This can be shallower than the maximum depth if user
	 *                   selects "other" indicating his choice is not in the
	 *                   exact list.
	 * @param isFocused  true iff the user made a focusing step - he selected
	 *                   something else than "other" at some point.
	 * @param isfinal    true iff this is a final state where the user made his
	 *                   choice. This can be either due to selecting a leaf
	 *                   node, or due to selecting other and then again the same
	 *                   subtype, and therefore has to be recorded separately.
	 * @pram nameOfObject a name of the object, to make the question to the user
	 *       more specific which is especially relevant if this is part of a
	 *       breath-first and the user entered some name or so some time before.
	 *       If null, "het" ("it") is used.
	 */

	@JsonCreator
	public OntologyAnswerState(@JsonProperty("nodelabel") String qnodelabel,
			@JsonProperty("depth") int depth,
			@JsonProperty("isFocused") boolean isFocused,
			@JsonProperty("isFinal") boolean isfinal,
			@JsonProperty("nameOfObject") String nameOfObject) {
		if (qnodelabel == null) {
			throw new IllegalArgumentException("node must be not null");
		}
		this.nodelabel = qnodelabel;
		this.depth = depth;
		this.isFinal = isfinal;
		this.isFocused = isFocused;
		this.nameOfObject = nameOfObject == null ? IT : nameOfObject;
	}

	/**
	 * Convenience constructor that sets depth to maximum for initial state.
	 * 
	 * @param qnode the node to create a new AnswerState for. This is initially
	 *              the most abstract OntologyNode that fits the range of
	 *              possibilities, eg #Persoon. The answer process gradually
	 *              focuses on more detailed children of this node, and qnode
	 *              will then change to this more detailed choice.
	 * 
	 *              The depth is set to the maximum possible depth with
	 *              {@link #MAX_OPTIONS} answers.
	 * @pram nameOfObject a name of the object, to make the question to the user
	 *       more specific which is especially relevant if this is part of a
	 *       breath-first and the user entered some name or so some time before.
	 *       If null, "het" ("it") is used.
	 */
	public OntologyAnswerState(OntologyNode qnode, String nameOfObject) {
		this(qnode.getLabel(), maximumDepth(qnode), false, false, nameOfObject);
	}

	@Override
	public TypedQuestion getOptions(
			Tree<String, Collection<Property>, OntologyNode> tree) {
		if (isFinal)
			return null;
		OntologyNode node = tree.get(nodelabel);
		List<String> optionstrings = node.getChildren(depth).stream()
				.map(child -> child.getLabel()).collect(Collectors.toList());
		optionstrings.add(OTHER);
		String optionstring = optionstrings.toString().replace("[", "{")
				.replace("]", "}");

		return new SelectFromList(
				"Kan U " + (isFocused ? "nog specifieker " : "")
						+ "aangeven: wat voor soort " + nodelabel + " was "
						+ nameOfObject + "? " + optionstring,
				optionstrings, node.getLabel());
	}

	@Override
	public OntologyAnswerState with(String answer,
			Tree<String, Collection<Property>, OntologyNode> tree) {
		if (OTHER.equals(answer)) {
			return with((OntologyNode) null, tree);
		}
		OntologyNode root = tree.get(nodelabel);

		Optional<OntologyNode> selection = root.getChildren(depth).stream()
				.filter(node -> answer.equals(node.getLabel())).findFirst();
		if (!selection.isPresent()) {
			throw new IllegalArgumentException(
					"Antwoord " + answer + " is geen optie");
		}
		return with(selection.get(), tree);

	}

	/**
	 * 
	 * @param choice the {@link OntologyAnswerState} state that advances this to
	 *               the next state. If null, it means the user could not make a
	 *               choice ("other"). <br>
	 *               The returned state is created as follows.
	 *               <ol>
	 *               <li>if choice=null:
	 *               <ol>
	 *               <li>if parent=null: new state = this and is final.
	 *               <li>else new state = parent, depth =1
	 *               </ol>
	 * 
	 *               <li>if choice is a leaf node: new state=choice and is final
	 *               <li>if choice=node we just came from : new state=choice and
	 *               final.
	 *               <li>else new state = choice, depth = maximum with 15-node
	 *               limit
	 *               </ol>
	 * @return new {@link OntologyAnswerState} reflecting that the choice was
	 *         made. The explanation is cleared, assuming that the user has read
	 *         and understood the explanation after he gave an answer.
	 * @throws IllegalStateException if {@link #isFinal()}
	 */
	public OntologyAnswerState with(OntologyNode choice,
			Tree<String, Collection<Property>, OntologyNode> tree) {
		if (isFinal) {
			throw new IllegalStateException("state is final");
		}
		OntologyNode node = tree.get(nodelabel);
		if (choice == null) {
			if (depth <= 1 || isFocused) {
				// take the current node as answer
				return new OntologyAnswerState(nodelabel, depth, isFocused,
						true, nameOfObject);
			}
			// zoom out
			return new OntologyAnswerState(nodelabel, depth - 1, false, false,
					nameOfObject);
		}

		// if choice has no children then this choice is also final.
		return new OntologyAnswerState(choice.getLabel(), depth, true,
				choice.getChildren().isEmpty(), nameOfObject);
	}

	/**
	 * @return the specific node label that was reached at this point.
	 */
	public String getNode() {
		return nodelabel;
	}

	/**
	 * 
	 * @return the depth at which the options are selected. This can be
	 *         shallower than the maximum depth, indicating we are restricting
	 *         the user's answer options to non-leaf (more abstract) nodes.
	 */
	public int getDepth() {
		return depth;
	}

	@Override
	public String toString() {
		return "OntologyAnswerState[" + nodelabel + "," + isFocused + ","
				+ depth + "," + isFinal + "," + nameOfObject + "]";
	}

	/**
	 * @return the maximum depth achievable with at most MAX_ANSWERS. Assumes
	 *         depth 1 and 2 exist and that #children <MAX_ANSWERS at depth 1.
	 */
	private static int maximumDepth(OntologyNode node) {
		List<OntologyNode> nodes = node.getChildren(1);
		// assume at least 1 more child per depth step to put some upper limit
		// invariant: up to given depth, there are less than MAX_OPTIONS
		for (int depth = 1; depth < MAX_OPTIONS; depth++) {
			List<OntologyNode> newnodes = node.getChildren(depth + 1);
			// equals if we are effectively at the bottom of the tree.
			if (newnodes.size() > MAX_OPTIONS || newnodes.equals(nodes))
				return depth;
			nodes = newnodes;
		}
		return MAX_OPTIONS;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + depth;
		result = prime * result + (isFinal ? 1231 : 1237);
		result = prime * result + (isFocused ? 1231 : 1237);
		result = prime * result
				+ ((nameOfObject == null) ? 0 : nameOfObject.hashCode());
		result = prime * result
				+ ((nodelabel == null) ? 0 : nodelabel.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		OntologyAnswerState other = (OntologyAnswerState) obj;
		if (depth != other.depth)
			return false;
		if (isFinal != other.isFinal)
			return false;
		if (isFocused != other.isFocused)
			return false;
		if (nameOfObject == null) {
			if (other.nameOfObject != null)
				return false;
		} else if (!nameOfObject.equals(other.nameOfObject))
			return false;
		if (nodelabel == null) {
			if (other.nodelabel != null)
				return false;
		} else if (!nodelabel.equals(other.nodelabel))
			return false;
		return true;
	}

}