package eu.dnetlib.pace.tree.support;

import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;

public class TreeNodeStats implements Serializable {

	private Map<String, FieldStats> results; // this is an accumulator for the results of the node

	public TreeNodeStats() {
		this.results = new HashMap<>();
	}

	public Map<String, FieldStats> getResults() {
		return results;
	}

	public void addFieldStats(String id, FieldStats fieldStats) {
		this.results.put(id, fieldStats);
	}

	public int fieldsCount() {
		return this.results.size();
	}

	public int undefinedCount() {
		int undefinedCount = 0;
		for (FieldStats fs : this.results.values()) {
			if (fs.getResult() == -1)
				undefinedCount++;
		}
		return undefinedCount;
	}

	public double scoreSum() {
		double scoreSum = 0.0;
		for (FieldStats fs : this.results.values()) {
			if (fs.getResult() >= 0.0) {
				scoreSum += fs.getResult();
			}
		}
		return scoreSum;
	}

	// return the sum of the weights without considering the fields with countIfMissing=false && result=-1
	public double weightSum() {
		double weightSum = 0.0;
		for (FieldStats fs : this.results.values()) {
			if (fs.getResult() >= 0.0 || (fs.getResult() < 0.0 && fs.isCountIfUndefined())) {
				weightSum += fs.getWeight();
			}
		}
		return weightSum;
	}

	public double weightedScoreSum() {
		double weightedScoreSum = 0.0;
		for (FieldStats fs : this.results.values()) {
			if (fs.getResult() >= 0.0) {
				weightedScoreSum += fs.getResult() * fs.getWeight();
			}
		}
		return weightedScoreSum;
	}

	public double max() {
		double max = -1.0;
		for (FieldStats fs : this.results.values()) {
			if (fs.getResult() > max)
				max = fs.getResult();
		}
		return max;
	}

	public double min() {
		double min = 100.0; // random high value
		for (FieldStats fs : this.results.values()) {
			if (fs.getResult() < min) {
				if (fs.getResult() >= 0.0 || (fs.getResult() == -1 && fs.isCountIfUndefined()))
					min = fs.getResult();
			}
		}
		return min;
	}

	// if at least one is true, return 1.0
	public double or() {
		for (FieldStats fieldStats : this.results.values()) {
			if (fieldStats.getResult() >= fieldStats.getThreshold())
				return 1.0;
		}
		return 0.0;
	}

	// if at least one is false, return 0.0
	public double and() {
		for (FieldStats fieldStats : this.results.values()) {

			if (fieldStats.getResult() == -1) {
				if (fieldStats.isCountIfUndefined())
					return 0.0;
			} else {
				if (fieldStats.getResult() < fieldStats.getThreshold())
					return 0.0;
			}

		}
		return 1.0;
	}

	public double getFinalScore(AggType aggregation) {

		switch (aggregation) {
			case AVG:
				return scoreSum() / fieldsCount();
			case SUM:
				return scoreSum();
			case MAX:
				return max();
			case MIN:
				return min();
			case W_MEAN:
				return weightedScoreSum() / weightSum();
			case OR:
				return or();
			case AND:
				return and();
			default:
				return 0.0;
		}
	}
}