//===-- rosa/agent/Reliability.h --------------------------------*- C++ -*-===//
//
//                                 The RoSA Framework
//
//===----------------------------------------------------------------------===//
///
/// \file rosa/agent/Reliability.h
///
/// \author Daniel Schnoell (danielschnoell@tuwien.ac.at)
///
/// \date 2019
///
/// \brief  Definition of *reliability* *functionality*.
///
//===----------------------------------------------------------------------===//

#ifndef ROSA_AGENT_RELIABILITY_H
#define ROSA_AGENT_RELIABILITY_H

#include "rosa/agent/FunctionAbstractions.hpp"
#include "rosa/agent/Functionality.h"
#include "rosa/agent/RangeConfidence.hpp"
#include "rosa/agent/CrossReliability.h"

#include <vector>

namespace rosa {
	namespace agent {

		/// This is the Reliability Functionality for a low level Agent
		/// \tparam SensorValueType Datatype of the Sensor value	( Typically double	or float)
		/// \tparam StateType		Datatype of the State			( Typically long	or int)
		///	\tparam ReliabilityType Datatype of the Reliability		( Typically double	or float)
		///
		/// use the () operator to get the reliability and feed the information from the master back to this
		/// \note all pointer for the functionalities will be deleted when this is object ist destroyed
		template <typename SensorValueType, typename StateType, typename ReliabilityType>
		class LowLevel {
			struct ConfOrRel {
				StateType score;
				ReliabilityType Reliability;
			};
		public:

			/// Calculates the Conf/ Reliability
			/// \param SensorValue The current Values of the Sensor
			/// 
			/// \return Reliability of the current Value
			ConfOrRel operator()(SensorValueType SensorValue) {
				std::map<StateType, ReliabilityType> ActuallPosibleScores_tmp = Confidence(SensorValue);

				std::vector<ConfOrRel> ActuallPossibleScores;
				for (auto state : States)
					ActuallPossibleScores.push_back({ state, ActuallPosibleScores_tmp.find(state) });

				ReliabilityType inputReliability;

				if (PreviousSensorValueExists)
					inputReliability = getRelibility(SensorValue, previousSensorValue, valueSetCounter);
				else
					inputReliability = Reliability(SensorValue);

				for (std::size_t at = 0; at < ActuallPossibleScores.size(); at++)
					ActuallPossibleScores.at(at) = std::min(ActuallPossibleScores.at(at), inputReliability);

				for (std::size_t APS_at = 0; APS_at < ActuallPossibleScores.size(); APS_at++)
					for (std::size_t VFM_at = 0; VFM_at < ValuesFromMaster.size(); VFM_at++) {
						if (ActuallPossibleScores.at(APS_at).score == ValuesFromMaster.at(VFM_at).score) {
							ActuallPossibleScores.at(APS_at).Reliability = ActuallPossibleScores.at(APS_at).Reliability + ValuesFromMaster.at(VFM_at).Reliability;
						}
					}

				saveInHistory(ActuallPossibleScores);

				std::vector<ConfOrRel> possibleScores;

				getAllPossibleScoresBasedOnHistory(&possibleScores);


				std::sort(possibleScores.begin(), possibleScores.end(), [](ReliabilityType A, ReliabilityType B)-> bool {return A > B; });


				previousSensorValue = SensorValue;
				PreviousSensorValueExists = true;
				return possibleScores.at(0);

			}

			/// Needed feedback from the Master
			/// \param ValuesFromMaster The Scores + Reliability from the Master for this Agent
			void feedback(std::vector<ConfOrRel> ValuesFromMaster)
			{
				this->ValuesFromMaster = ValuesFromMaster;
			}


			/// This is the setter for Confidence Function
			/// \param Confidence A pointer to the Functional for the Confidence
			void setConfidenceFunction(RangeConfidence<ReliabilityType, StateType, SensorValueType>* Confidence)
			{
				this->Confidence = Confidence;
			}

			/// This is the setter for Reliability Function
			/// \param Reliability A pointer to the Functional for the Reliability
			void setReliabilityFunction(Abstraction<SensorValueType, ReliabilityType>* Reliability)
			{
				this->Reliability = Reliability;
			}

			/// This is the setter for ReliabilitySlope Function
			/// \param ReliabilitySlope A pointer to the Functional for the ReliabilitySlope 
			void setReliabilitySlopeFunction(Abstraction<SensorValueType, ReliabilityType>* ReliabilitySlope)
			{
				this->ReliabilitySlope = ReliabilitySlope;
			}

			/// This is the setter for TimeConfidence Function
			/// \param TimeConfidence A pointer to the Functional for the TimeConfidence
			void setTimeConfidenceFunction(Abstraction<std::size_t, ReliabilityType>* TimeConfidence)
			{
				this->TimeConfidence = TimeConfidence;
			}

			/// deletes all given pointers
			void  ~LowLevel()
			{
				delete Confidence;
				Confidence = nullptr;

				delete Reliability;
				Reliability = nullptr;

				delete ReliabilitySlop;
				ReliabilitySlope = nullptr;

				delete TimeConfidence;
				TimeConfidence = nullptr;
			}

		private:
			std::vector<std::vector<ConfOrRel>> History;
			std::size_t HistoryMaxSize;
			std::vector<ConfOrRel> ValuesFromMaster;

			SensorValueType previousSensorValue;
			unsigned int valueSetCounter;
			std::vector<StateType> States;
			bool PreviousSensorValueExists = false;

			RangeConfidence<ReliabilityType, StateType, SensorValueType>* Confidence = nullptr;
			Abstraction<SensorValueType, ReliabilityType>* Reliability = nullptr;
			Abstraction<SensorValueType, ReliabilityType>* ReliabilitySlope = nullptr;
			Abstraction<std::size_t, ReliabilityType>* TimeConfidence = nullptr;

			/*--------------------------------- needed Funktions -----------------------------------------------------*/

			/// returns the Reliability 
			/// \param actualValue The Value of the Sensor
			/// \param lastValue of the Sensor this is stored in the class
			/// \param valueSetCounter 
			ReliabilityType getRelibility(SensorValueType actualValue, SensorValueType lastValue, unsigned int valueSetCounter) {

				ReliabilityType relAbs = Reliability->operator()(actualValue);
				if (PreviousSensorValueExists)
				{
					ReliabilityType relSlo = ReliabilitySlope->operator()((lastValue - actualValue) / (SensorValueType)valueSetCounter);

					// calculate signal input reliability
					// NOTE: options would be multiply, average, AND (best to worst:
					// average = AND > multiply) rel = relAbs * relSlo; rel = (relAbs +
					// relSlo)/2;

					return std::min(relAbs, relSlo);
				}
				else
					return relAbs;
			}

			/// adabts the possible Scores by checking the History and combines those values currently with max
			/// \param possibleScores This is returned from the Master
			std::vector<ConfOrRel> getAllPossibleScoresBasedOnHistory(std::vector<ConfOrRel> possibleScores) {
				//iterate through all history entries
				std::size_t posInHistory = 0;
				typedef typename std::vector<std::vector<ConfOrRel>>::iterator iter;
				for (iter pShE = History.begin(); pShE < History.end(); pShE++, posInHistory++) {


					//iterate through all possible scores of each history entry
					for (typename std::vector<ConfOrRel>::iterator pSh : *pShE) {

						//printf("a3\n");

						int historyScore = pSh->score;
						float historyConf = pSh->Reliability;

						//combine each history score with the confidence of time
						//NOTE: multiplication, AND, or average would be alternatives (best to worst: multiplication = AND = average)
						historyConf = historyConf * TimeConfidence(posInHistory);
						//historyConf = (historyConf + TimeConfidence(posInHistory)) / 2;
						//historyConf = std::min(historyConf, TimeConfidence(posInHistory));

						//printf("a4\n");

						bool foundScore = false;
						for (ConfOrRel& pS : possibleScores) {

							if (pS->score == historyScore) {

								//calculate confidence for score
								//NOTE: multiplication, AND, or average would be alternatives (best to worst: AND >> average = multiplication )
								//pS->confOrRel = pS->confOrRel * historyConf;
								//pS->confOrRel = (pS->confOrRel + historyConf) / 2;
								pS->confOrRel = std::max(pS->confOrRel, historyConf);

								foundScore = true;
							}
						}

						if (foundScore == false) {

							ConfOrRel possibleScore;
							possibleScore.score = historyScore;
							possibleScore.Reliability = historyConf;

							possibleScores->push_back(possibleScore);

						}
					}
				}

				return possibleScores;
			}

			/// saves the Scores in the History 
			/// \param actualPossibleScores The Scores which should be saved
			void saveInHistory(std::vector<ConfOrRel> actualPossibleScores) {

				//check if the reliability of at least one possible score is high enough
				bool atLeastOneRelIsHigh = false;
				for (ConfOrRel pS : actualPossibleScores) {
					if (pS.Reliability > 0.5) {
						atLeastOneRelIsHigh = true;
					}
				}
				//save possible scores if at least one possible score is high enough (or if the history is empty)
				if (History.size() < 1 || atLeastOneRelIsHigh == true) {

					History.push_front(actualPossibleScores);

					//if history size is higher than allowed, savo oldest element
					while (History.size() > HistoryMaxSize) {
						//delete possibleScoreHistory.back();
						History.pop_back();
					}
				}
			}

		};



		/// This is the Reliability Functionality for the Highlevel Agent
		/// \tparam StateType		Datatype of the State			( Typically	double	or float)
		/// \tparam ReliabilityType	Datatype of the	Reliability		( Typically	long	or int)
		/// 
		/// use the () operator to calculate the Reliability and all cross confidences for all slaves
		/// \note all pouinter to Funcionalities get deleted upon termitation of the object
		template<typename StateType, typename ReliabilityType>
		class HighLevel
		{
		public:

			struct ConfOrRel {
				StateType score;
				ReliabilityType Reliability;
			};

			struct returnType {
				ReliabilityType CrossReliability;
				std::vector<std::pair<id_t, std::vector<ConfOrRel>>> CrossConfidence;
			};

			returnType operator()(std::vector<std::tuple<id_t, StateType, ReliabilityType>> Values)
			{

				StateType EWS = 0;
				ReliabilityType combinedInputRel = 1;
				ReliabilityType combinedCrossRel = 1;
				ReliabilityType outputReliability;

				std::vector<std::pair<id_t, StateType>> Agents;
				std::vector<std::pair<id_t, std::vector<ConfOrRel>>> output;
				std::vector<ConfOrRel> 					output_temporary;

				for (auto tmp : Values)
				{
					std::pair<id_t, StateType> tmp2;
					tmp.first = std::get<0>(tmp);
					tmp.second = std::get<1>(tmp);
					Agents.push_back(tmp);
				}


				for (auto Value : Values) {
					StateType sc = std::get<1>(Value);
					ReliabilityType rel = std::get<2>(Value);

					EWS = EWS + sc;

					combinedInputRel = std::min(combinedInputRel, rel);


					//calculate the cross reliability for this slave agent
					ReliabilityType realCrossReliabilityOfSlaveAgent = CrossReliability({ std::get<0>(Value),std::get<1>(Value) }, Agents); //AVERAGE, MULTIPLICATION, CONJUNCTION (best to worst: AVERAGE = CONJUNCTION > MULTIPLICATION >> )

					output_temporary.clear();
					for (int theoreticalScore = 0; theoreticalScore <= 3; theoreticalScore++) {
						//calculate the cross reliability for this slave agent
						ConfOrRel data;
						data.score = theoreticalScore;
						data.Reliability = CrossConfidence(std::get<0>(Value), theoreticalScore, Agents);
						output_temporary.push_back(data);
					}

					output.push_back({ std::get<0>(Value),output_temporary });
					combinedCrossRel = std::min(combinedCrossRel, realCrossReliabilityOfSlaveAgent);

				}

				//combine cross reliabilites and input reliabilites of all slave agents
				//NOTE: options would be multiply, average, AND (best to worst: )
				//outputReliability = combinedInputRel * combinedCrossRel;
				//outputReliability = (combinedInputRel + combinedCrossRel) / 2;
				outputReliability = std::min(combinedInputRel, combinedCrossRel);
				return { outputReliability,output };
			}

			/// This is the setter for CrossReliability Function
			/// param  A pointer to the Functional for the CrossReliability
			void setFunction(CrossReliability<StateType, ReliabilityType>* CrossReliability)
			{
				this->CrossReliability = CrossReliability;
			}
			
			/// This is the setter for CrossConfidence Function
			/// param  A pointer to the Functional for the CrossConfidence
			void setFunction(CrossConfidence <StateType, ReliabilityType>* CrossConfidence)
			{
				this->CrossConfidence = CrossConfidence;
			}

			/// deletes all given pointers
			void ~HighLevel()
			{
				delete CrossReliability;
				CrossConfidence = nullptr;
				delete CrossConfidence;
				CrossConfidence = nullptr;
			}

		private:

			CrossReliability<StateType, ReliabilityType>* CrossReliability = nullptr;
			CrossConfidence <StateType, ReliabilityType>* CrossConfidence = nullptr;
		};
	} // namespace agent
}// namespace rosa
#endif // !ROSA_AGENT_RELIABILITY_H