// SPDX-FileCopyrightText: 2020 Roberto Posenato <roberto.posenato@univr.it>
//
// SPDX-License-Identifier: LGPL-3.0-or-later

package it.univr.di.labeledvalue;

import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import it.unimi.dsi.fastutil.objects.AbstractObject2IntMap.BasicEntry;
import it.unimi.dsi.fastutil.objects.*;
import it.unimi.dsi.fastutil.objects.Object2IntMap.Entry;
import it.univr.di.Debug;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.io.Serial;
import java.io.Serializable;
import java.util.Arrays;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Pattern;

/**
 * Allows to manage conjoin-upper-case values that are also associated to propositional labels.<br> Labeled values are grouped by alphabetic labels
 * {@link ALabel}. Each group of labeled values is represented as {@link LabeledIntTreeMap}.<br> Therefore, such a class realizes the map
 * {@link ALabel}-->{@link LabeledIntTreeMap}.<br>
 * <p>
 * Be careful!<br> Since lower-case value are singular for each edge, it not convenient to represent it as LabeledALabelIntTreeMap.<br> A specialized class has
 * been developed to represent such values: {@link LabeledLowerCaseValue}.
 * <p>
 * At the start of this implementation, I made some experiments for evaluating if it is better to use a Object2ObjectRBTreeMap or a ObjectArrayMap for
 * representing the internal map. In October 2017, I verified that even with medium-size network, some edges can contain around 5000 labeled UC values. So, I
 * tested the two implementations again considering up to 10000 labeled UC values. It resulted that up to 1000 values, the two implementations show still almost
 * equivalent performance, BUT when the keys are &ge;5000, to retrieve the keys from ObjectArrayMap requires more than ONE hour, while it requires almost ~96 ms
 * using Object2ObjectRBTreeMap! Details using Object2ObjectRBTreeMap:
 *
 * <pre>
 * Time to retrieve 50 elements using entrySet(): ---
 * Time to retrieve 50 elements using aLabelSet(): 0.012000000000000004ms
 *
 * Time to retrieve 100 elements using entrySet(): ---
 * Time to retrieve 100 elements using aLabelSet(): 0.006000000000000003ms
 *
 * Time to retrieve 1000 elements using entrySet(): 0.045ms
 * Time to retrieve 1000 elements using aLabelSet(): 0.034ms
 * The difference is 0.025000000000000015 ms. It is better to use: aLabelSet() approach.
 *
 * Time to retrieve 5000 elements using entrySet(): 0.9623700000000001ms
 * Time to retrieve 5000 elements using aLabelSet(): 0.352ms
 * The difference is 0.6139400000000002 ms. It is better to use: aLabelSet() approach.
 *
 * Time to retrieve 10000 elements using entrySet(): --
 * Time to retrieve 10000 elements using aLabelSet(): 1.292ms
 * </pre>
 * Considering then, RB Tree instead of RB Tree:
 *
 * <pre>
 * Time to retrieve 50 elements using aLabelSet(): 0.012000000000000002ms
 *
 * Time to retrieve 100 elements using aLabelSet(): 0.007ms
 *
 * Time to retrieve 1000 elements using entrySet(): ---
 * Time to retrieve 1000 elements using aLabelSet(): 0.038ms
 * The difference is 0.025000000000000015 ms. It is better to use: aLabelSet() approach.
 *
 * Time to retrieve 5000 elements using entrySet(): ---
 * Time to retrieve 5000 elements using aLabelSet(): 0.388ms
 * The difference is 0.6139400000000002 ms. It is better to use: aLabelSet() approach.
 *
 * Time to retrieve 10000 elements using entrySet(): --
 * Time to retrieve 10000 elements using aLabelSet(): 1.314ms
 * </pre>
 *
 * <b>All code for testing is in LabeledALabelIntTreeMapTest class (not public available).</b>
 *
 * @author Roberto Posenato
 * @version $Rev$
 */
@SuppressWarnings("UnusedReturnValue")
public class LabeledALabelIntTreeMap implements Serializable {

	/**
	 * A read-only view of a LabeledALabelIntTreeMap object.
	 *
	 * @author posenato
	 */
	public static class LabeledALabelIntTreeMapView extends LabeledALabelIntTreeMap {
		/**
		 *
		 */
		@Serial
		private static final long serialVersionUID = 1L;

		/**
		 * @param inputMap the input map
		 */
		public LabeledALabelIntTreeMapView(LabeledALabelIntTreeMap inputMap) {
			this.map = inputMap.map;
		}


		/**
		 * Object Read-only. It does nothing.
		 */
		@Override
		public boolean mergeTriple(Label newLabel, ALabel newAlabel, int newValue, boolean force) {
			return false;
		}

		/**
		 * Object Read-only. It does nothing.
		 */
		@Override
		public boolean mergeTriple(Label l, ALabel p, int i) {
			return false;
		}

		/**
		 * Object Read-only. It does nothing.
		 */
		@Override
		public boolean mergeTriple(String label, ALabel p, int i) {
			return false;
		}

		/**
		 * Object Read-only. It does nothing.
		 */
		@Override
		public boolean mergeTriple(String label, ALabel p, int i, boolean force) {
			return false;
		}

//		/**
//		 * Object Read-only. It does nothing.
//		 */
//		@Nullable
//		@Override
//		public LabeledIntTreeMap put(ALabel upperCaseLabel, LabeledIntMap labeledValueMap) {
//			return null;
//		}

		/**
		 * Object Read-only. It does nothing.
		 */
		@Override
		public boolean putTriple(Label l, ALabel p, int i) {
			return false;
		}

		/**
		 * Object Read-only. It does nothing.
		 */
		@Override
		public int remove(Label l, ALabel p) {
			return Constants.INT_NULL;
		}
	}

	/**
	 * Keyword \w because it is necessary to accept also node names!
	 */
	@SuppressWarnings("RegExpRedundantEscape")
	static final String labelCharsRE =
		ALabelAlphabet.ALETTER + ALabel.ALABEL_SEPARATORstring + ",\\-" + Constants.NOTstring +
		Constants.EMPTY_LABELstring + Constants.INFINITY_SYMBOLstring + Constants.UNKNOWNstring +
		Constants.EMPTY_UPPER_CASE_LABELstring + Literal.PROPOSITIONS;
	/**
	 * Matcher for RE
	 */
	@SuppressWarnings("RegExpRedundantEscape")
	static final Pattern patternLabelCharsRE = Pattern.compile("\\{[\\(" + labelCharsRE + "\\) ]*\\}");
	/**
	 * Matcher for RE
	 */
	private static final Pattern PARENTESIS_PATTERN = Pattern.compile("[{}]");

	/**
	 * logger
	 */
	private static final Logger LOG = Logger.getLogger(LabeledALabelIntTreeMap.class.getName());

	/**
	 * Serial number
	 */
	@Serial
	private static final long serialVersionUID = 3L;

	/**
	 * Parse a string representing a LabeledValueTreeMap and return an object containing the labeled values represented by the string.<br> The format of the
	 * string is given by the method {@link #toString()}. For historical reasons, the method is capable to parse two different map
	 * format:{@code "{[(&lang;label&rang;, &lang;Alabel&rang;, &lang;value&rang;) ]*}} or
	 * {@code "{[(&lang;Alabel&rang;, &lang;value&rang;, &lang;label&rang;) ]*}"}, where [a]* is a meta constructor for saying zero o more 'a'.
	 *
	 * @param arg                  a {@link String} object.
	 * @param alphabet             the alphabet to use to code the labels
	 * @param labeledValueMapImple the class used for storing labeled values. If null, it is {@link LabeledIntMapSupplier#DEFAULT_LABELEDINTMAP_CLASS}.
	 *
	 * @return a LabeledPairMap object if args represents a valid map, null otherwise.
	 */
	@Nullable
	public static LabeledALabelIntTreeMap parse(String arg, ALabelAlphabet alphabet, final Class<? extends LabeledIntMap> labeledValueMapImple) {
		// final Pattern splitterNode = Pattern.compile("〈|; ");
		if (Debug.ON) {
			if (LOG.isLoggable(Level.FINEST)) {
				LOG.finest("Begin parse: " + arg);
			}
		}
		if ((arg == null) || (arg.length() < 3)) {
			return null;
		}

		if (!patternLabelCharsRE.matcher(arg).matches()) {
			return null;
		}
		final LabeledALabelIntTreeMap newMap = new LabeledALabelIntTreeMap(labeledValueMapImple);

		arg = PARENTESIS_PATTERN.matcher(arg).replaceAll("");
		// arg = arg.substring(1, arg.length() - 2);
		if (Debug.ON) {
			if (LOG.isLoggable(Level.FINEST)) {
				LOG.finest("Before split: '" + arg + "'");
			}
		}
		@SuppressWarnings("RegExpSingleCharAlternation") final Pattern splitterEntry = Pattern.compile("\\)|\\(");
		final String[] entryThreesome = splitterEntry.split(arg);
		if (Debug.ON) {
			if (LOG.isLoggable(Level.FINEST)) {
				LOG.finest("EntryThreesome: " + Arrays.toString(entryThreesome));
			}
		}

		final Pattern splitterTriple = Pattern.compile(", ");
		if (alphabet == null) {
			alphabet = new ALabelAlphabet();
		}
		int j;
		String labelStr, aLabelStr, valueStr;
		for (final String s : entryThreesome) {
			if (Debug.ON) {
				if (LOG.isLoggable(Level.FINEST)) {
					LOG.finest("s: '" + s + "'");
				}
			}
			if (s.length() > 1) {// s can be empty or a space.
				final String[] triple = splitterTriple.split(s);
				if (Debug.ON) {
					if (LOG.isLoggable(Level.FINEST)) {
						LOG.finest("triple: " + Arrays.toString(triple));
					}
				}
				Label l = Label.parse(triple[2]);
				if (l == null) {
					// probably it is the old format
					labelStr = triple[0];
					aLabelStr = triple[1];
					valueStr = triple[2];
				} else {
					// new format
					aLabelStr = triple[0];
					valueStr = triple[1];
					labelStr = triple[2];
				}
				if (l == null) {
					l = Label.parse(labelStr);
				}
				if (Debug.ON) {
					if (LOG.isLoggable(Level.FINEST)) {
						LOG.finest("Label: " + l);
					}
				}
				if (valueStr.equals("-" + Constants.INFINITY_SYMBOLstring)) {
					j = Constants.INT_NEG_INFINITE;
				} else {
					j = Integer.parseInt(valueStr);
				}
				if (Debug.ON) {
					if (LOG.isLoggable(Level.FINEST)) {
						LOG.finest("Value: " + j);
					}
				}
				// LabeledNode is represented as " 〈<id>; {}; Obs: null〉 "
				// final String nodePart = labLitInt[1];//splitterNode.split(labLitInt[1]);
				// System.out.println(aLabelStr);
				final ALabel node = ALabel.parse(aLabelStr, alphabet);
				if (Debug.ON) {
					if (LOG.isLoggable(Level.FINEST)) {
						LOG.finest("LabeledNode: " + node);
					}
				}

				newMap.mergeTriple(l, node, j, false);
			}
		}
		return newMap;
	}

	/**
	 * Merges a label case value {@code (p,l,i)}.
	 * <p>
	 * The value is insert if there is not a labeled value in the set with label {@code (l,p)} or it is present with a value higher than {@code i}.
	 * <p>
	 * The method can remove or modify other labeled values of the set in order to minimize the labeled values present guaranteeing that no info is lost.
	 *
	 * @param newLabel  a {@link Label} object.
	 * @param newAlabel a case name.
	 * @param newValue  the new value.
	 * @param force     true if the value has to be stored without label optimization.
	 *
	 * @return true if the triple is stored, false otherwise.
	 */
	public boolean mergeTriple(final Label newLabel, final ALabel newAlabel, final int newValue, final boolean force) {
		if (!force && alreadyRepresents(newLabel, newAlabel, newValue)) {
			return false;
		}
		final int prioriNewAlabelMapSize;
		final int newAlabelSize = newAlabel.size();
		LabeledIntMap newAlabelMap = map.get(newAlabel);
		if (newAlabelMap == null) {
			newAlabelMap = (new LabeledIntMapSupplier<>(this.labeledValueMapImpl)).get();
			map.put(ALabel.clone(newAlabel), newAlabelMap);
			prioriNewAlabelMapSize = 0;
		} else {
			prioriNewAlabelMapSize = newAlabelMap.size();
		}

		final boolean added;
		if (force) {
			newAlabelMap.putForcibly(newLabel, newValue);
			added = true;
		} else {
			added = newAlabelMap.put(newLabel, newValue);
		}

		// update the count
		count += newAlabelMap.size() - prioriNewAlabelMapSize;
		if (force) {
			return true;
		}

		/*
		 * 2017-10-31
		 * Algorithm removes all a-labeled values that will become redundant after the insertion of the input a-labeled value.
		 * The a-label removed contain newALabel strictly.
		 * I verified that following optimization reduces global computation time.
		 */
		final boolean isNewAlabelMapModified = prioriNewAlabelMapSize == newAlabelMap.size();
		final ObjectSet<Entry<Label>> newAlabelEntrySet = newAlabelMap.entrySet();//read-only
		LabeledIntMap otherALabelValueMap;
		for (final ALabel otherALabel : aLabelSet()) {//scan the other labeledValueMaps
			// Check only a-labels that contain newALabel strictly.
			if (otherALabel.equals(newAlabel) || otherALabel.size() < newAlabelSize || !otherALabel.contains(newAlabel)) {
				continue;
			}
			otherALabelValueMap = get(otherALabel);

			for (final Label otherLabel : otherALabelValueMap.keySet()) { // otherALabelValueMap could be modified
				final int otherValue = otherALabelValueMap.get(otherLabel);

				if (isNewAlabelMapModified) {
					// it is necessary to check all values in the newAlabelMap
					for (final Entry<Label> inputEntry : newAlabelEntrySet) {//newAlabelEntrySet will be not modified
						final Label inputLabel = inputEntry.getKey();
						final int inputValue = inputEntry.getIntValue();
						if (otherLabel.subsumes(inputLabel) && otherValue >= inputValue) {
							remove(otherLabel, otherALabel);
						}
					}
				} else {
					if (otherLabel.subsumes(newLabel) && otherValue >= newValue) {
						remove(otherLabel, otherALabel);
					}
				}
			}
		}
		return added;
	}

	/**
	 * @param newLabel  it must be not null
	 * @param newAlabel it must be not null
	 * @param newValue  the new value
	 *
	 * @return true if the current map can represent the value. In positive case, an add of the element does not change the map. If returns false, then the
	 * 	adding of the value to the map would modify the map.
	 */
	public boolean alreadyRepresents(final Label newLabel, final ALabel newAlabel, final int newValue) {
		final LabeledIntMap map1 = map.get(newAlabel);
		if (map1 != null && map1.alreadyRepresents(newLabel, newValue)) {
			return true;
		}
		/*
		 * Check if there is already a value in the map having shorter ALabel that can represent the new value.
		 */
		final int newALabelSize = newAlabel.size();
		for (final ALabel otherALabel : aLabelSet()) {
			if (newALabelSize <= otherALabel.size() || !newAlabel.contains(otherALabel)) {
				continue;
			}
			final LabeledIntMap labeledValuesOfOtherALabel = get(otherALabel);
			if (labeledValuesOfOtherALabel.alreadyRepresents(newLabel, newValue)) {
				// a smaller conjuncted upper case value map already contains the input value
				return true;
			}
		}
		return false;
	}

	/**
	 * @return a set of all a-labels present into this map. The set is not modified if the map is modified after set creation.
	 */
	public ObjectSet<ALabel> aLabelSet() {
		return map.keySet();
	}

	/**
	 * @param aLabel the input a-label
	 *
	 * @return the labeled value map associated to the given aLabel, null if there is no map associated.
	 */
	private LabeledIntMap get(final ALabel aLabel) {
		return map.get(aLabel);
	}

	/**
	 * @param l a {@link Label} object.
	 * @param p a {@link ALabel} object.
	 *
	 * @return the old value if it exists, {@link Constants#INT_NULL} otherwise.
	 */
	public int remove(final Label l, final ALabel p) {
		if ((l == null) || (p == null)) {
			return Constants.INT_NULL;
		}
		final LabeledIntMap map1 = map.get(p);
		if (map1 == null) {
			return Constants.INT_NULL;
		}
		final int old = map1.remove(l); //ok
		if (old != Constants.INT_NULL) {
			count--;
		}
		if (map1.isEmpty()) {
			map.remove(p);// it is necessary for making equals working.
		}
		return old;
	}

	/**
	 * Number of elements
	 */
	private int count;
	/**
	 * Labeled value class used in the class.
	 */
	private Class<? extends LabeledIntMap> labeledValueMapImpl;
	/**
	 * Data structure.
	 * <ol>
	 * <li>A Upper/Lower Case value is a pair (nodeName, value) where nodeName is a name of a node
	 * and can be written either in all UPPER case or in all lower case.
	 * Such kind of constraint has been introduced by Morris Muscettola 2005.
	 * <li>A labeled Upper/Lower Case value is a pair (nodeName, (proposition_label, value)), where proposition_label
	 * represents scenario where value holds.
	 * Such kind of constraint has been introduced by Hunsberger, Combi, and Posenato in 2012.
	 * <li>Each proposition_label is a conjunction of literals, i.e., of type {@link Label}.</li>
	 * <li>Since there may be more pairs with the same 'nodeName', a labeled Upper/Lower Case value is as a map of (nodeName, LabeledIntMap).<br>
	 * See {@link LabeledIntMap}.
	 * <li>In 2017-10, nodeName has been substituted by Alabel. ALabel represent the name of a node or a conjunction of node names.<br>
	 * Such modification has been introduced because CSTNU DC checking algorithm requires such kind of values.
	 * </ol>
	 */
	// ObjectArrayMap is not suitable when the map is greater than 1000 values!
	Object2ObjectRBTreeMap<ALabel, LabeledIntMap> map;//it is important to maintain the a-label ordered.

	/**
	 * Constructor to clone the structure. All internal maps will be independent of 'lvm' ones.
	 *
	 * @param lvm                  the map to clone. If null, 'this' will be an empty map.
	 * @param labeledValueMapImple the class used for storing labeled values. If null, it is {@link LabeledIntMapSupplier#DEFAULT_LABELEDINTMAP_CLASS}.
	 */
	public LabeledALabelIntTreeMap(final LabeledALabelIntTreeMap lvm, final Class<? extends LabeledIntMap> labeledValueMapImple) {
		this(labeledValueMapImple);
		if (lvm == null) {
			return;
		}
		final LabeledIntMapSupplier<? extends LabeledIntMap> labeledIntMapSupplier = new LabeledIntMapSupplier<>(this.labeledValueMapImpl);
		for (final ALabel alabel : lvm.aLabelSet()) {
			final LabeledIntMap map1 = labeledIntMapSupplier.get(lvm.get(alabel));
			map.put(alabel, map1);
			count += map1.size();
		}
	}

	/**
	 * Simple constructor. The internal structure is built and empty.
	 *
	 * @param labeledValueMapImple the class used for storing labeled values. If null, it is {@link LabeledIntMapSupplier#DEFAULT_LABELEDINTMAP_CLASS}.
	 */
	public LabeledALabelIntTreeMap(final Class<? extends LabeledIntMap> labeledValueMapImple) {
		map = new Object2ObjectRBTreeMap<>();
		count = 0;
		this.labeledValueMapImpl = (labeledValueMapImple == null) ? LabeledIntMapSupplier.DEFAULT_LABELEDINTMAP_CLASS
		                                                          : labeledValueMapImple;
	}

	/**
	 * Simple constructor. The internal structure is built and empty.
	 */
	private LabeledALabelIntTreeMap() {
	}

	/**
	 *
	 */
	public void clear() {
		map.clear();
		count = 0;
	}

	/**
	 * @return the minimal value of this map in the format ({@link Label}, ({@link ALabel}, int)).<br> If the map is null, returns the entry
	 * 	({@link Label#emptyLabel}, ({@link ALabel#emptyLabel}, {@link Constants#INT_NULL})).
	 */
	@SuppressFBWarnings(value = "DLS_DEAD_LOCAL_STORE", justification = "v is used.")
	public Object2ObjectMap.Entry<Label, Entry<ALabel>> getMinValue() {
		if (size() == 0) {
			return new AbstractObject2ObjectMap.BasicEntry<>(Label.emptyLabel, new BasicEntry<>(ALabel.emptyLabel, Constants.INT_NULL));
		}
		int min = Integer.MAX_VALUE;
		int v;
		Entry<Label> vEntry;
		ALabel aMin = ALabel.emptyLabel;
		Label lMin = Label.emptyLabel;
		for (final ALabel alabel : aLabelSet()) {
			final LabeledIntMap map1 = get(alabel);
			if (map1 != null) {
				vEntry = map1.getMinLabeledValue();
				v = vEntry.getIntValue();
				if (v != Constants.INT_NULL && v < min) {
					min = v;
					aMin = alabel;
					lMin = vEntry.getKey();
				}
			}
		}
		return new AbstractObject2ObjectMap.BasicEntry<>(lMin, new BasicEntry<>(aMin, min));
	}

	/**
	 * @return the number of elements of the map.
	 */
	public final int size() {
		return count;
		// int n = 0;
		// for (final LabeledIntTreeMap map1 : this.map.values()) {
		// n += map1.size();
		// }
		// return n;
	}

	/**
	 * Returns the value associated to {@code (l, p)} if it exists, otherwise the minimal value among all labels consistent with {@code (l, p)}.
	 *
	 * @param l if it is null, {@link Constants#INT_NULL} is returned.
	 * @param p if it is null, {@link Constants#INT_NULL} is returned.
	 *
	 * @return the value associated to the {@code (l, p)} if it exists or the minimal value among values associated to labels consistent by {@code l}. If no
	 * 	labels are subsumed by {@code l}, {@link Constants#INT_NULL} is returned.
	 */
	public int getMinValueConsistentWith(final Label l, final ALabel p) {
		if ((l == null) || (p == null)) {// || p.isEmpty())
			return Constants.INT_NULL;
		}
		final LabeledIntMap map1 = map.get(p);
		if (map1 == null) {
			return Constants.INT_NULL;
		}
		return map1.getMinValueConsistentWith(l);
	}

	/**
	 * Returns a copy of the entry containing the min value associated to a-label {@code p}.
	 *
	 * @param p a non-null ALabel
	 *
	 * @return a copy of the entry containing the min value associated to a-label  {@code p} if it exists, null otherwise.
	 */
	public Entry<Label> getMinValue(@Nonnull final ALabel p) {
		final LabeledIntMap map1 = map.get(p);
		if (map1 == null) {
			return null;
		}
		return map1.getMinLabeledValue();
	}


	/**
	 * @param l a {@link Label} object.
	 * @param p a {@link ALabel} representing the upper/lower case label (node label).
	 *
	 * @return the value associate to the key (label, p) if it exits, {@link Constants#INT_NULL} otherwise.
	 */
	public int getValue(final Label l, final ALabel p) {
		if ((l == null) || (p == null)) {
			return Constants.INT_NULL;
		}
		final LabeledIntMap map1 = map.get(p);
		if (map1 == null) {
			return Constants.INT_NULL;
		}
		return map1.get(l);
	}

	@Override
	public int hashCode() {
		return map.hashCode();
	}

	@Override
	public boolean equals(final Object o) {
		if (o == this) {
			return true;
		}
		if (!(o instanceof final LabeledALabelIntTreeMap lvm)) {
			return false;
		}
		return map.equals(lvm.map);// this equals checks the size... so NO empty pair (key, {}) cannot be stored!
	}

	/**
	 * {@inheritDoc} Returns a string representing the content of the map, i.e., "{[&langle;entry&rangle; ]*}", where each &langle;entry&rangle; is written by
	 * {@link #entryAsString(Label, int, ALabel)}.
	 */
	@Override
	public String toString() {
		final StringBuilder s = new StringBuilder("{");
		for (final ALabel entryE : aLabelSet()) {
			final LabeledIntMap entry = get(entryE);
			if (entry.isEmpty()) {
				continue;
			}
			final ObjectList<Entry<Label>> sorted = new ObjectArrayList<>(entry.entrySet());
			sorted.sort(LabeledIntMap.entryComparator);

			for (final Entry<Label> entry1 : sorted) {
				s.append(entryAsString(entry1.getKey(), entry1.getIntValue(), entryE));
				s.append(' ');
			}
		}
		s.append("}");
		return s.toString();
	}

	/**
	 * Utility.
	 *
	 * @param label    the input label
	 * @param value    the input value
	 * @param nodeName this name is printed as it is. This method is necessary for saving the values of the map in a file.
	 *
	 * @return the canonical representation of the triple (as stated in ICAPS/ICAART papers), i.e. {@link Constants#OPEN_PAIR}Alabel, value,
	 * 	label{@link Constants#CLOSE_PAIR}
	 */
	static public String entryAsString(Label label, int value, ALabel nodeName) {
		return Constants.OPEN_PAIR + nodeName + ", " + Constants.formatInt(value) + ", " + label + Constants.CLOSE_PAIR;
	}

	/**
	 * @return true if the map does not contain any labeled value.
	 */
	public final boolean isEmpty() {
		return size() == 0;
	}

	/**
	 * @return a set of all labels present into this map. The set is not modified if the map is modified after set creation.
	 */
	public ObjectSet<Label> labelSet() {
		final ObjectSet<Label> labelSet = new ObjectArraySet<>();
		for (final LabeledIntMap localMap : map.values()) {
			labelSet.addAll(localMap.keySet());
		}
		return labelSet;
	}


	/**
	 * @param alpha A-label of the wanted labeled value map.
	 *
	 * @return a set of labels present into the map associated to alpha A-label; empty set if there is no such a map.
	 */
	public ObjectSet<Label> labelSet(final ALabel alpha) {
		ObjectSet<Label> labelSet = new ObjectArraySet<>();
		final LabeledIntMap localMap = map.get(alpha);
		if (localMap == null || localMap.isEmpty()) {
			return labelSet;
		}
		labelSet = localMap.keySet();
		return labelSet;
	}

	/**
	 * <b>Important</b>
	 * The returned set is a view on the map. Don't modify the entries on this set and don't modify the map using methods like
	 * {@link #putTriple(Label, ALabel, int)} (with 2nd parameter = alpha) during the scan of this set, otherwise the correctness of this set is not
	 * guaranteed.
	 *
	 * @param alpha A-label of the wanted labeled value map.
	 *
	 * @return a set of entries present into the map associated to alpha A-label; empty set if there is no such a map.
	 */
	public ObjectSet<Entry<Label>> entrySet(final ALabel alpha) {
		ObjectSet<Entry<Label>> entrySet = new ObjectArraySet<>();
		final LabeledIntMap localMap = map.get(alpha);
		if (localMap == null || localMap.isEmpty()) {
			return entrySet;
		}
		entrySet = localMap.entrySet();
		return entrySet;
	}


	/**
	 * <b>Important</b>
	 * The returned set is a view on the map. Don't modify the entries on this set and don't modify the map using methods like
	 * {@link #putTriple(Label, ALabel, int)} (with 2nd parameter = alpha) during the scan of this set, otherwise the correctness of this set is not
	 * guaranteed.
	 *
	 * @return a set of all entries present into the map associated; empty set if there is no such a map.
	 */
	public ObjectSet<Object2ObjectMap.Entry<ALabel, Entry<Label>>> entrySet() {
		final ObjectSet<Object2ObjectMap.Entry<ALabel, Entry<Label>>> result = new ObjectArraySet<>();
		for (final ALabel aleph : aLabelSet()) {
			final LabeledIntMap localMap = map.get(aleph);
			for (final Entry<Label> entry : localMap.entrySet()) {
				final AbstractObject2ObjectMap.Entry<ALabel, Entry<Label>> e =
					new Object2ObjectArrayMap.BasicEntry<>(aleph, new BasicEntry<>(entry.getKey(), entry.getIntValue()));
				result.add(e);
			}
		}
		return result;
	}


	/**
	 * @param l the {@link Label} object.
	 * @param p the {@link String} object.
	 * @param i the value to merge.
	 *
	 * @return see {@link #mergeTriple(Label, ALabel, int, boolean)}
	 *
	 * @see #mergeTriple(Label, ALabel, int, boolean)
	 */
	public boolean mergeTriple(final Label l, final ALabel p, final int i) {
		return mergeTriple(l, p, i, false);
	}

	/**
	 * Wrapper method. It calls mergeTriple(label, p, i, false);
	 *
	 * @param label a {@link String} object.
	 * @param p     a {@link String} object.
	 * @param i     the new value.
	 *
	 * @return see {@link #mergeTriple(String, ALabel, int, boolean)}
	 *
	 * @see #mergeTriple(String, ALabel, int, boolean)
	 */
	public boolean mergeTriple(final String label, final ALabel p, final int i) {
		return mergeTriple(label, p, i, false);
	}

	/**
	 * Wrapper method of {@link #mergeTriple(Label, ALabel, int, boolean)}.
	 * <br>
	 * 'label' parameter is converted to a Label before calling {@link #mergeTriple(Label, ALabel, int, boolean)}.
	 *
	 * @param label a {@link String} object.
	 * @param p     a {@link String} object.
	 * @param i     the new value.
	 * @param force true if the value has to be stored without label optimization.
	 *
	 * @return true if the triple is stored, false otherwise.
	 */
	public boolean mergeTriple(final String label, final ALabel p, final int i, final boolean force) {
		if ((label == null) || (p == null) || (i == Constants.INT_NULL)) {// p.isEmpty() ||
			return false;
		}
		final Label l = Label.parse(label);
		return mergeTriple(l, p, i, force);
	}

//	/**
//	 * Put a map associate to key alabel. Possible previous map will be replaced.
//	 *
//	 * @param alabel          the input label
//	 * @param labeledValueMap its map
//	 *
//	 * @return the old map if one was associated to alabel, null otherwise
//	 */
//	LabeledIntMap put(ALabel upperCaseLabel, LabeledIntMap labeledValueMap) {
//
//		final LabeledIntMap oldMap = map.get(alabel);
//		if (oldMap != null) {
//			count -= oldMap.size();
//		}
//		count += labeledValueMap.size();
//		return map.put(alabel, labeledValueMap);
//	}

	/**
	 * Put the triple {@code (p,l,i)} into the map. If the triple is already present, it is overwritten.
	 *
	 * @param l a {@link Label} object.
	 * @param p a {@link String} object.
	 * @param i the new value to add.
	 *
	 * @return true if the valued has been added.
	 */
	public boolean putTriple(final Label l, final ALabel p, final int i) {
		return mergeTriple(l, p, i, false);
	}

	/**
	 * @param aleph aleph the id of the wanted labeled values map.
	 *
	 * @return true if the map associated to aleph is removed, false otherwise.
	 */
	public boolean remove(final ALabel aleph) {
		if (aleph == null) {
			return false;
		}
		return map.remove(aleph) != null;
	}

	/**
	 * @return a read-only view of this object.
	 */
	@SuppressWarnings("ClassReferencesSubclass")
	public LabeledALabelIntTreeMapView unmodifiable() {
		return new LabeledALabelIntTreeMapView(this);
	}

	/**
	 * @param aleph the id of the wanted labeled values map.
	 *
	 * @return a read-only view of the sub map if it exits, an empty map otherwise.
	 */
	@SuppressWarnings("ClassReferencesSubclass")
	public LabeledIntMap unmodifiable(@Nonnull ALabel aleph) {
		final LabeledIntMap subMap = this.get(aleph);
		if (subMap != null) {
			return subMap.unmodifiable();
		}
		return new LabeledIntTreeMap().unmodifiable();
	}

}