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

package it.univr.di.labeledvalue;

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 managing conjoined upper-case values that are also associated with propositional labels.
 * <p>
 * Labeled values are grouped by alphabetic labels {@link ALabel}. Each group of labeled values is represented as {@link LabeledIntTreeMap}.
 * <p>
 * Therefore, such a class realizes the map {@link ALabel}-->{@link LabeledIntTreeMap}.
 * <p>
 * Be careful!
 * <p>
 * Since lower-case values are singular for each edge, it is not convenient to represent them as LabeledALabelIntTreeMap.
 * <p>
 * A specialized class has been developed to represent such values: {@link LabeledLowerCaseValue}.
 * <p>
 * At the start of this implementation, I did some experiments to evaluate whether it is better to use an Object2ObjectRBTreeMap or an ObjectArrayMap to represent the internal map.
 * <p>
 * In October 2017, I verified that even with the medium-sized 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 publicly 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;

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

	/**
	 * Parse a string representing a LabeledValueTreeMap and return an object containing the labeled values represented by the string.
	 * <p>
	 * The format of the string is given by the method {@link #toString()}. For historical reasons, the method is capable to parse two different map formats:{@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;
	}

	/**
	 * Data structure.
	 * <ol>
	 * <li>An Upper/Lower Case value is a pair (nodeName, value) where nodeName is the name of a node and can be written either in all UPPER case or in all lower case. Morris &amp; Muscettola 2005 have introduced such a constraint.
	 * <li>A labeled Upper/Lower Case value is a pair (nodeName, (proposition_label, value)), where proposition_label represents a scenario where the value holds. Such a constraint was 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 represented as a map of (nodeName, LabeledIntMap).<br>
	 * See {@link LabeledIntMap}.
	 * <li>In 2017-10, `nodeName` was substituted by ALabel. ALabel represents the name of a node or a conjunction of node names.<br>
	 * Such a modification has been introduced because the CSTNU DC checking algorithm requires such values.
	 * </ol>
	 */
	// ObjectArrayMap is not suitable when the map has more than 1000 values!
	Object2ObjectRBTreeMap<ALabel, LabeledIntMap> map;//It is important to maintain the ALabel ordered.
	/**
	 * Number of elements
	 */
	private int count;
	/**
	 * Labeled value class used in the class.
	 */
	private Class<? extends LabeledIntMap> labeledValueMapImpl;

	/**
	 * Constructor to clone the structure. All internal maps will be independent of the '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() {
	}

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

	/**
	 * @param newLabel  it must not be null
	 * @param newAlabel it must not be null
	 * @param newValue  the new value
	 *
	 * @return true if the current map can represent the value. In a positive case, the addition of the element does not change the map. If it returns false, then adding 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 a 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;
	}

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

	/**
	 * The returned set is a view of 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 ALabel of the wanted labeled value map.
	 *
	 * @return a set of entries present in the map associated with `alpha` ALabel; an empty set if there is no such 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 of 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 in the map associated; an empty set if there is no such 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;
	}

	@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!
	}

	/**
	 * @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));
	}

	/**
	 * Returns a copy of the entry containing the min value associated with ALabel {@code p}.
	 *
	 * @param p a non-null ALabel
	 *
	 * @return a copy of the entry containing the min value associated with ALabel  {@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();
	}

	/**
	 * Returns the value associated with {@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 with the {@code (l, p)} if it exists or the minimal value among values associated with labels consistent with {@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);
	}

	/**
	 * @param l a {@link Label} object.
	 * @param p a {@link ALabel} representing the upper/lower case label (node label).
	 *
	 * @return the value associated with the key (label, p) if it exists, {@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();
	}

	/**
	 * @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 in 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 ALabel of the wanted labeled value map.
	 *
	 * @return a set of labels present in the map associated with `alpha` ALabel; an empty set if there is no such 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;
	}

	/**
	 * Merges a label case value {@code (p,l,i)}.
	 * <p>
	 * The value is inserted if there is no labeled value in the set with label {@code (l,p)} or if it is present with a value higher than {@code i}.
	 * <p>
	 * The method can remove or modify other labeled values of the set 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 ALabel values that will become redundant after the insertion of the input ALabel value.
		 * The removed ALabel strictly contains the `newALabel`.
		 * I verified that the 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 ALabels 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) {//the 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 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 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 value has been added.
	 */
	public boolean putTriple(final Label l, final ALabel p, final int i) {
		return mergeTriple(l, p, i, false);
	}

	/**
	 * @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;
	}

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

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

//	/**
//	 * Put a map associate to key alabel. The possible previous map will be replaced.
//	 *
//	 * @param alabel          the input label
//	 * @param labeledValueMap its map
//	 *
//	 * @return the old map if one was associated with 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);
//	}

	/**
	 * {@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();
	}

	/**
	 * @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 exists; otherwise, it is an empty map.
	 */
	@SuppressWarnings("ClassReferencesSubclass")
	public LabeledIntMap unmodifiable(@Nonnull ALabel aleph) {
		final LabeledIntMap subMap = this.get(aleph);
		if (subMap != null) {
			return subMap.unmodifiable();
		}
		return new LabeledIntTreeMap().unmodifiable();
	}

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

}