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

import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import it.unimi.dsi.fastutil.objects.*;
import it.unimi.dsi.fastutil.objects.Object2ObjectMap.Entry;
import it.univr.di.Debug;
import it.univr.di.labeledvalue.*;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.io.Serial;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * An implementation of CSTNPSUEdge.
 * <br>
 * This edge differs from the CSTNU edge because it also admits that lower-case values are propagated and that it is possible to have lower-case values with conjoined lower-case labels.
 *
 * @author posenato
 * @version $Rev$
 */
@SuppressFBWarnings(value = "SE_BAD_FIELD", justification = "I know what I'm doing")
public class CSTNPSUEdgePluggable extends BasicCSTNUEdgePluggable implements CSTNPSUEdge {

	@Serial
	private static final long serialVersionUID = 1L;

	/*
	 * class initializer
	 */
	static {
		/*
		 * logger
		 */
		LOG = Logger.getLogger(CSTNPSUEdgePluggable.class.getName());
	}

	/**
	 * The CSTNU controllability check algorithm needs to know if a labeled value has already been considered in the past to avoid adding it a second time.
	 */
	Object2IntMap<Entry<Label, ALabel>> consideredLowerCaseValue;

	/**
	 * Morris Lower case value augmented by a propositional label.
	 * <p>
	 * The name of the node has to be equal to the original name. No case modifications are necessary!
	 */
	LabeledALabelIntTreeMap lowerCaseValues;

	/**
	 * Default constructor. Empty edge.
	 */
	CSTNPSUEdgePluggable() {
		this((String) null);
	}

	/**
	 * @param n name of edge
	 */
	CSTNPSUEdgePluggable(String n) {
		super(n);
		lowerCaseValues = new LabeledALabelIntTreeMap(this.getLabeledIntMapImplClass());
		consideredLowerCaseValue = new Object2IntArrayMap<>();
		consideredLowerCaseValue.defaultReturnValue(Constants.INT_NULL);
	}

	/**
	 * Constructor to clone the component.
	 *
	 * @param e the edge to clone.
	 */
	CSTNPSUEdgePluggable(Edge e) {
		super(e);
		lowerCaseValues = new LabeledALabelIntTreeMap(this.getLabeledIntMapImplClass());
		if (e != null && CSTNPSUEdge.class.isAssignableFrom(e.getClass())) {
			final CSTNPSUEdge e1 = (CSTNPSUEdge) e;
			for (final Object2ObjectMap.Entry<ALabel, Object2IntMap.Entry<Label>> entry : e1.getLowerCaseValues()) {
				lowerCaseValues.mergeTriple(entry.getValue().getKey(), entry.getKey(), entry.getValue().getIntValue());
			}
		} else {
			if (e != null && CSTNUEdge.class.isAssignableFrom(e.getClass())) {
				final CSTNUEdge e1 = (CSTNUEdge) e;
				final LabeledLowerCaseValue lcv = e1.getLowerCaseValue();
				if (!lcv.isEmpty()) {
					lowerCaseValues.mergeTriple(lcv.getLabel(), lcv.getNodeName(), lcv.getValue());
				}
			}
		}
		consideredLowerCaseValue = new Object2IntArrayMap<>();
		consideredLowerCaseValue.defaultReturnValue(Constants.INT_NULL);
	}

	@Override
	public void clear() {
		super.clear();
		lowerCaseValues.clear();
		consideredLowerCaseValue.clear();
	}

	@Override
	public void clearLowerCaseValue() {
		clearLowerCaseValues();
	}

	@Override
	public void clearLowerCaseValues() {
		lowerCaseValues.clear();
	}

	@Override
	public ObjectSet<Entry<ALabel, Object2IntMap.Entry<Label>>> getAllLowerCaseAndLabeledValues() {
		final ObjectSet<Object2ObjectMap.Entry<ALabel, Object2IntMap.Entry<Label>>> result = getLowerCaseValues();
		for (final Object2IntMap.Entry<Label> entry : this.getLabeledValues()) {
			result.add(new AbstractObject2ObjectMap.BasicEntry<>(ALabel.emptyLabel, entry));
		}
		return result;
	}

	@Override
	public ObjectSet<Label> getLabelsOfLowerCaseValues(@Nonnull ALabel aLabel) {
		return this.lowerCaseValues.labelSet(aLabel);

	}

	@Override
	public ObjectSet<Label> getLabelsOfLowerCaseValues() {
		return this.lowerCaseValues.labelSet();
	}

	@Override
	public ObjectSet<ALabel> getLowerCaseLabels() {
		return lowerCaseValues.aLabelSet();
	}

	@Override
	public int getLowerCaseValue(Label l, ALabel name1) {
		return lowerCaseValues.getValue(l, name1);
	}

	@Override
	public ObjectSet<Object2ObjectMap.Entry<ALabel, Object2IntMap.Entry<Label>>> getLowerCaseValues() {
		return lowerCaseValues.entrySet();
	}

	@Nullable
	@Override
	public Object2ObjectMap.Entry<Label, Object2IntMap.Entry<ALabel>> getMinLowerCaseValue() {
		final Object2ObjectMap.Entry<Label, Object2IntMap.Entry<ALabel>> entry = lowerCaseValues.getMinValue();
		if (entry.getValue().getKey().isEmpty()) {
			return null;
		}
		return entry;
	}

	//	@SuppressFBWarnings(value = "NP_NONNULL_RETURN_VIOLATION", justification = "lowerCaseValues.entrySet returns an empty set if there is no value!")
//	@Nonnull
	@Override
	public ObjectSet<Object2IntMap.Entry<Label>> getLowerCaseValues(@Nonnull ALabel lowerCaseLabel) {
		return lowerCaseValues.entrySet(lowerCaseLabel);
	}

	@Override
	public final boolean hasSameValues(Edge e) {
		if (!(e instanceof CSTNPSUEdge e1)) {
			return false;
		}
		if (e == this) {
			return true;
		}
		if (!super.hasSameValues(e)) {
			return false;
		}
		return (lowerCaseValues.entrySet().equals(e1.getLowerCaseValues()));
	}

	@Override
	public boolean isCSTNPSUEdge() {
		return true;
	}

	@Override
	public boolean isEmpty() {
		return super.isEmpty() && lowerCaseValues.isEmpty();
	}

	@Override
	public String lowerCaseValueAsString() {
		return lowerCaseValues.toString();
	}

	@Override
	public final int lowerCaseValueSize() {
		return lowerCaseValues.size();
	}

	@Override
	public boolean mergeLabeledValue(Label l, int i) {
		final boolean added = super.mergeLabeledValue(l, i);
		// If a value is positive, and there are more lower-case values, some of them may be simplified.
		if (added && i >= 0 && !lowerCaseValues.isEmpty()) {
			for (final ALabel LCALabel : lowerCaseValues.aLabelSet()) {
				final ObjectSet<Label> labels = lowerCaseValues.labelSet(LCALabel);
				for (final Label LCLabel : labels) {
					final int LCValue = lowerCaseValues.getValue(LCLabel, LCALabel);
					if (i <= LCValue && LCLabel.subsumes(l)) {
						if (Debug.ON) {
							if (CSTNEdgePluggable.LOG.isLoggable(Level.FINEST)) {
								CSTNEdgePluggable.LOG.log(Level.FINEST, "The value (%s, %d) makes redundant lower case value (%s, %s:%d).  Last one is removed.".formatted(l, i, LCLabel, LCALabel, LCValue));
							}
						}
						setLowerCaseValueAsConsidered(LCLabel, LCALabel, LCValue);
						removeLowerCaseValue(LCLabel, LCALabel);
					}
				}
			}
		}
		return added;
	}

	@Override
	public final boolean mergeLowerCaseValue(@Nonnull Label l, @Nonnull ALabel nodeName, int i) {
		if (i == Constants.INT_NULL) {
			return false;
		}
		final InternalEntry se = new InternalEntry(l, nodeName);
		final int oldValue = consideredLowerCaseValue.getInt(se);
		if ((oldValue != Constants.INT_NULL) && (i >= oldValue)) {
			//The labeled value (l, i) was already removed by the label modification rule.
			// A labeled value with a value equal to or smaller than will be modified again.
			if (Debug.ON) {
				if (CSTNEdgePluggable.LOG.isLoggable(Level.FINEST)) {
					CSTNEdgePluggable.LOG.finest("The labeled value (%s, %s, %d) has not been stored because the previous (%s, %s, %d) is in the removed list".formatted(l, nodeName, i, l, nodeName, oldValue));
				}
			}
			return false;
		}
		setLowerCaseValueAsConsidered(l, nodeName, i);// once it has been added, it is useless to add it again!

		// Check if a standard labeled value is more restrictive than the one to put.
		final int minNormalValueSubsummedByL = getMinValueSubsumedBy(l);
		if ((minNormalValueSubsummedByL != Constants.INT_NULL) && (minNormalValueSubsummedByL <= i)) {
			if (Debug.ON) {
				if (CSTNEdgePluggable.LOG.isLoggable(Level.FINEST)) {
					CSTNEdgePluggable.LOG.finest("The labeled value (%s, %s, %d) has not been stored because the value is greater than the labeled minimal value subsumed by %s.".formatted(l, nodeName, i, l));
				}
			}
			return false;
		}
		return lowerCaseValues.mergeTriple(l, nodeName, i, false);
		// if (added && !this.lowerCaseValue.isEmpty()) {
		// this.setConstraintType(ConstraintType.contingent);
		// this.setChanged();
		// notifyObservers("LowerLabel:add");
		// }
	}

	/**
	 *
	 */
	@Override
	public final void putLowerCaseValue(@Nonnull Label l, @Nonnull ALabel nodeName, int i) {
		if (i == Constants.INT_NULL) {
			return;
		}
		//When I put it, I don't consider if I put it in the past
//		InternalEntry se = new InternalEntry(l, nodeName);
//		int oldValue = consideredLowerCaseValue.getInt(se);
//		if ((oldValue != Constants.INT_NULL) && (i >= oldValue)) {
//			//The labeled value (l, i) was already removed by the label modification rule.
//			// A labeled value with a value equal to or smaller will be modified again.
//			if (Debug.ON) {
//				if (CSTNEdgePluggable.LOG.isLoggable(Level.FINEST)) {
//					CSTNEdgePluggable.LOG.finest("The labeled value (" + l + ", " + nodeName + ", " + i + ") has not been stored because the previous (" + l + ", " + nodeName + ", " + oldValue + ") is in the removed list");
//				}
//			}
//			return false;
//		}
//		setLowerCaseValueAsConsidered(l, nodeName, i);// once it has been added, it is useless to add it again!
		lowerCaseValues.mergeTriple(l, nodeName, i, true);
	}

	@Override
	public CSTNPSUEdgePluggable newInstance() {
		return new CSTNPSUEdgePluggable();
	}

	@Override
	public CSTNPSUEdgePluggable newInstance(Edge edge) {
		return new CSTNPSUEdgePluggable(edge);
	}

	@Override
	public CSTNPSUEdgePluggable newInstance(String name1) {
		return new CSTNPSUEdgePluggable(name1);
	}

	@Override
	public final void removeLowerCaseValue(Label l, ALabel n) {
		// this.consideredLowerCaseValue.removeInt(new InternalEntry(l, n));
		lowerCaseValues.remove(l, n);
	}

	@Override
	public void setLowerCaseValues(LabeledALabelIntTreeMap lowerCaseValue1) {
		lowerCaseValues = (lowerCaseValue1 == null) ? new LabeledALabelIntTreeMap(this.getLabeledIntMapImplClass()) : lowerCaseValue1;
	}

	@Override
	public void takeIn(Edge e) {
		if (e == null) {
			return;
		}
		super.takeIn(e);
		if (e instanceof CSTNPSUEdgePluggable e1) {
			lowerCaseValues = e1.lowerCaseValues;
			consideredLowerCaseValue = e1.consideredLowerCaseValue;
		}
	}

	/**
	 * Set the triple as already considered to avoid considering it again in the future.
	 *
	 * @param l label
	 * @param n name of node as a-label
	 * @param i edge weight
	 */
	void setLowerCaseValueAsConsidered(Label l, ALabel n, int i) {
		consideredLowerCaseValue.put(new InternalEntry(l, n), i);
	}

}