/*******************************************************************************
 * Copyright (c) 2016 CEA LIST.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Created on: 5 févr. 2015
 *
 * Contributors:
 *  Arnault Lapitre (CEA LIST) arnault.lapitre@cea.fr
 *   - Initial API and implementation
 ******************************************************************************/

#ifndef AVMCOVERAGESTATISTICS_H_
#define AVMCOVERAGESTATISTICS_H_

#include <collection/Bitset.h>

#include <util/avm_numeric.h>
#include <util/avm_util.h>


namespace sep
{

class OutStream;


class AvmCoverageStatistics
{

public:
	/*
	 * ATTRIBUTES
	 */
	Bitset     mCoverageBitset;

	avm_size_t mNumberOfElements;
	avm_size_t mNumberOfCovered;

	avm_size_t mCoverageRateGoal;
	avm_size_t mCoverageRestGoal;

	avm_size_t mBackupOfCovered;

	avm_size_t mNumberOfBacktrack;

	avm_size_t mNumberOfFailedStep;
	avm_size_t mNumberOfFailedHeuristic;

	avm_size_t mNumberOfBlackHole;
	avm_size_t mNumberOfBlackHoleTest;


public:

	/**
	 * CONSTRUCTOR
	 * Default
	 */
	AvmCoverageStatistics(avm_size_t objRate = 100, avm_size_t objRest = 0)
	: mCoverageBitset( 0 , false ),
	mNumberOfElements( 0 ),
	mNumberOfCovered( 0 ),

	mCoverageRateGoal( objRate ),
	mCoverageRestGoal( objRest ),

	mBackupOfCovered( 0 ),

	mNumberOfBacktrack( 0 ),

	mNumberOfFailedStep( 0 ),
	mNumberOfFailedHeuristic( 0 ),

	mNumberOfBlackHole( 0 ),
	mNumberOfBlackHoleTest( 0 )
	{
		//!! NOTHING
	}


	/**
	 * CONSTRUCTOR
	 * Copy
	 */
	AvmCoverageStatistics(const AvmCoverageStatistics & aCoverageStatistics)
	: mCoverageBitset( aCoverageStatistics.mCoverageBitset ),
	mNumberOfElements( aCoverageStatistics.mNumberOfElements ),
	mNumberOfCovered( aCoverageStatistics.mNumberOfCovered ),

	mCoverageRateGoal( aCoverageStatistics.mCoverageRateGoal ),
	mCoverageRestGoal( aCoverageStatistics.mCoverageRestGoal ),

	mBackupOfCovered( aCoverageStatistics.mBackupOfCovered ),

	mNumberOfBacktrack( aCoverageStatistics.mNumberOfBacktrack ),

	mNumberOfFailedStep( aCoverageStatistics.mNumberOfFailedStep ),
	mNumberOfFailedHeuristic( aCoverageStatistics.mNumberOfFailedHeuristic ),

	mNumberOfBlackHole( aCoverageStatistics.mNumberOfBlackHole ),
	mNumberOfBlackHoleTest( aCoverageStatistics.mNumberOfBlackHoleTest )
	{
		//!! NOTHING
	}


	/**
	 * DESTRUCTOR
	 */
	virtual ~AvmCoverageStatistics()
	{
		//!! NOTHING
	}

	/**
	 * Copy if coverage rate is best
	 */
	inline double coverageRate() const
	{
		return( (mNumberOfElements == 0) ?  0.0  :
				(static_cast< double >(mNumberOfCovered) / mNumberOfElements) );
	}

	inline void copyIfBestCoverageRate(const AvmCoverageStatistics & aStat)
	{
		if( (aStat.mNumberOfElements > 0) && ((mNumberOfElements == 0) ||
			(this->coverageRate() < aStat.coverageRate()) ||
			(mNumberOfElements < aStat.mNumberOfElements)) )
		{
			mCoverageBitset = aStat.mCoverageBitset;

			mNumberOfElements = aStat.mNumberOfElements;
			mNumberOfCovered  = aStat.mNumberOfCovered;

			mCoverageRateGoal = aStat.mCoverageRateGoal;
			mCoverageRestGoal = aStat.mCoverageRestGoal;

			mBackupOfCovered = aStat.mBackupOfCovered;

			mNumberOfBacktrack = aStat.mNumberOfBacktrack;

			mBackupOfCovered = aStat.mBackupOfCovered;
			mNumberOfFailedStep = aStat.mNumberOfFailedStep;
			mNumberOfFailedHeuristic = aStat.mNumberOfFailedHeuristic;

			mNumberOfBlackHole = aStat.mNumberOfBlackHole;
			mNumberOfBlackHoleTest = aStat.mNumberOfBlackHoleTest;
		}
	}


	/**
	 * RESETTER
	 */
	inline void resetCounter()
	{
		mCoverageBitset.clear();

		mNumberOfElements  = 0;
		mNumberOfCovered   = 0;
		mBackupOfCovered   = 0;
		mNumberOfBacktrack = 0;

		mNumberOfFailedStep = 0;
		mNumberOfFailedHeuristic = 0;
	}

	inline void resetCoverageCounter()
	{
		mCoverageBitset.reset();

		mNumberOfCovered = 0;
		mBackupOfCovered = 0;

		mNumberOfFailedStep = 0;
		mNumberOfFailedHeuristic = 0;
	}

	inline void resetFailedStep()
	{
		mNumberOfFailedStep = 0;
		mNumberOfFailedHeuristic = 0;
	}

	inline void setFailedHeuristic()
	{
		mNumberOfFailedHeuristic = 1;
	}


	/**
	 * mNumberOfElements
	 */
	inline void addUncoveredElement()
	{
		++mNumberOfElements;
	}

	inline void addUncoveredElement(avm_size_t count)
	{
		mNumberOfElements += count;
	}


	inline avm_size_t getNumberOfElements() const
	{
		return mNumberOfElements;
	}

	inline void setNumberOfElements(avm_size_t count)
	{
		mNumberOfElements = count;
	}


	/**
	 * mNumberOfCovered
	 */
	inline void addCoveredElement()
	{
		++mNumberOfCovered;
	}

	inline void addCoveredElement(avm_size_t count)
	{
		mNumberOfCovered += count;
	}


	inline avm_size_t getNumberOfCovered() const
	{
		return mNumberOfCovered;
	}

	inline void setNumberOfCovered(avm_size_t count)
	{
		mNumberOfCovered = count;
	}


	/**
	 * objectiveRate
	 * objectiveRest
	 */
	inline void setObjectives(avm_size_t objRate = 100, avm_size_t objRest = 0)
	{
		mCoverageRateGoal = objRate;
		mCoverageRestGoal = objRest;
	}


	/**
	 * mBackupOfCovered
	 * mNumberOfCovered
	 */
	inline void backupCovered()
	{
		mBackupOfCovered = mNumberOfCovered;
	}

	inline bool hasNewlyCovered()
	{
		return( mBackupOfCovered < mNumberOfCovered );
	}

	inline bool isNewlyFailedStep()
	{
		return( mBackupOfCovered == mNumberOfCovered );
	}


	/**
	 * mNumberOfElements
	 * mNumberOfCovered
	 */
	inline avm_size_t getNumberOfUncovered() const
	{
		return( mNumberOfElements - mNumberOfCovered );
	}


	/**
	 * mNumberOfElements
	 * mNumberOfFailedStep
	 */
	inline bool hasFailedStep() const
	{
		return( mNumberOfFailedStep > 0 );
	}

	inline bool isSeriouslyFailedStep() const
	{
		return( (mNumberOfFailedStep % mNumberOfElements) == 0 );
	}

	inline bool isSuccessfulStep() const
	{
		return( mNumberOfFailedStep == 0 );
	}

	/**
	 * mNumberOfFailedStep
	 * mBackupOfCovered
	 * mNumberOfCovered
	 */
	inline bool updateFailedStep()
	{
		if( mBackupOfCovered == mNumberOfCovered )
		{
			++mNumberOfFailedStep;

			return( true );
		}

		return( false );
	}


	/**
	 * mNumberOfFailedHeuristic
	 * mNumberOfFailedStep
	 * mBackupOfCovered
	 * mNumberOfCovered
	 */
	inline bool updateFailedHeuristic()
	{
		if( mNumberOfFailedHeuristic > 0 )
		{
			++mNumberOfFailedHeuristic;

			return( isSeriouslyFailedStep() );
		}

		return( true );
	}


	/**
	 * mNumberOfBlackHole
	 * mNumberOfBlackHoleTest
	 */
	inline std::string strBlackHoleRate() const
	{
		return( OSS() << mNumberOfBlackHole << "/" << mNumberOfBlackHoleTest );
	}


	/**
	 * Coverage Test
	 */
	inline bool goalAchieved() const
	{
		// AssertTrue( mCoverageBitset.allTrue() ) ?
		return( mNumberOfCovered == mNumberOfElements );
	}

	inline bool goalAchievedRate() const
	{
		return( ((100 * mNumberOfCovered) / mNumberOfElements)
				>= mCoverageRateGoal );
	}

	inline bool goalAchievedRest() const
	{
		return( (mNumberOfElements - mNumberOfCovered) <= mCoverageRestGoal );
	}

	inline bool hasCovered() const
	{
		return( mNumberOfCovered > 0 );
	}

	inline bool hasUncovered() const
	{
		// AssertTrue( mCoverageBitset.anyFalse() )
		return( mNumberOfCovered < mNumberOfElements );
	}

	/**
	 * set EXIT CODE
	 */
	inline void setExitCode() const
	{
		if( goalAchieved() )
		{
			avm_set_exit_code( AVM_EXIT_COVERAGE_GOAL_ACHIEVED_CODE);
		}
		else if( (mNumberOfElements > 0) &&
				(90 <= ((100 * mNumberOfCovered) / mNumberOfElements)) )
		{
			avm_set_exit_code( AVM_EXIT_COVERAGE_GOAL_ALMOST_ACHIEVED_CODE);
		}
		else
		{
			avm_set_exit_code( AVM_EXIT_COVERAGE_GOAL_UNACHIEVED_CODE);
		}
	}


	/**
	 * to string
	 */
	inline std::string strCoverageRate(const std::string & sep = " / ") const
	{
		return( OSS() << mNumberOfCovered << sep << mNumberOfElements );
	}

	inline std::string strCoverageRate(
			bool isGoalAchieved, const std::string & sep = " / ") const
	{
		return( OSS()
				<< (isGoalAchieved ? mNumberOfElements : mNumberOfCovered)
				<< sep << mNumberOfElements );
	}


	/**
	 * Serialization
	 */
	inline void toStreamCoverageRate(OutStream & os,
			const std::string & prompt = "", const std::string & sep = " / ",
			const std::string & eol = "\n") const
	{
		os << prompt << mNumberOfCovered << sep << mNumberOfElements
				<< eol << std::flush;
	}

	inline void toStreamFailedStep(OutStream & os,
			const std::string & prompt = "", const std::string & name = " / ",
			const std::string & eol = "\n") const
	{
		os << prompt << mNumberOfFailedStep << name
				<< ( (mNumberOfFailedStep > 0) ? "s" : "" )
				<< eol << std::flush;
	}

};


} /* namespace sep */

#endif /* AVMCOVERAGESTATISTICS_H_ */