/*
 * Parametrisation.h
 *
 *  Created on: 13.05.2011
 *      Author: sven
 */

#ifndef PARAMETRISATION_H_
#define PARAMETRISATION_H_

#include <vector>
#include <map>
#include <string>

enum enCompany
{
	nenDaimler = 0,
	nenDeuBa,
	nenFMC,
	nenRWE,
	nenSolarWorld,

	// must be last entry
	nenEndOfCompanies
};

enum enHoldingTime
{
	nenOneDay = 1,
	nenTenDays = 10
};

struct Stock
{
	double mValue;
	double mValueRelChangeOne;
	double mValueRelChangeTen;
	Stock()
	:mValue(-99999999.9),mValueRelChangeOne(-99999999.9),mValueRelChangeTen(-99999999.9)
	{}
	void calcRelChange(const Stock& prev, const enHoldingTime& holdingTime)
	{
		switch (holdingTime)
		{
		case nenOneDay:
			mValueRelChangeOne = ((mValue - prev.mValue) / prev.mValue) * 100.0;
			break;
		case nenTenDays:
			mValueRelChangeTen = ((mValue - prev.mValue) / prev.mValue) * 100.0;
			break;
		default:
			break;
		}

	}
};

struct StockPrices
{
	StockPrices()
	:mStock(nenEndOfCompanies) {}
	std::string mDate;
	unsigned mDayIdx;
	std::vector<Stock> mStock;
	void calcRelChanges(const StockPrices& prevDay, const enHoldingTime& holdingTime)
	{
		for (unsigned c = static_cast<unsigned>(nenDaimler) ; c < static_cast<unsigned>(nenEndOfCompanies); c++) {
			mStock.at(c).calcRelChange(prevDay.mStock.at(c), holdingTime);
		}
	}
};


struct ArithAverages{
	double mArithAverOneDay;
	double mArithAverTenDays;
	ArithAverages()
	:mArithAverOneDay(0.0),mArithAverTenDays(0.0) {}
};


typedef std::vector< std::vector<double> > CovarianceMatrix;
typedef CovarianceMatrix CorrelationMatrix;


class Parametrisation {
public:
	Parametrisation();
	virtual ~Parametrisation();
	void readCsvFile();
	void calcRelChanges(const enHoldingTime& holdingTime);
	void calcArithAverageVectors();
	void calcCovarianceMatrices();
	void calcCorrelationMatrices();

	double getLastValue(const enCompany& comp) const
	{
		return mLastYearData.back().mStock.at(comp).mValue;
	}

	const CovarianceMatrix& getCovarianceMatrix(const enHoldingTime& holdingTime) const
	{
		switch (holdingTime)
		{
		case nenOneDay:
			//return mCorrelationMatrixOneDay;
			return mCovarinaceMatrixOneDay;
		case nenTenDays:
			//return mCorrelationMatrixTenDays;
			return mCovarinaceMatrixTenDays;
		default:
			throw 17 ;
		}
	}
	void getArithAverages(std::vector<double>& mu, const enHoldingTime holdingTime) const
	{
		unsigned c;
		switch(holdingTime)
		{
		case nenOneDay:
			for (c = nenDaimler; c < nenEndOfCompanies; c++)
			{
				mu.at(c) = mArithAverageVectors.at(c).mArithAverOneDay;
			}
			return;
		case nenTenDays:
			for (c = nenDaimler; c < nenEndOfCompanies; c++)
			{
				mu.at(c) = mArithAverageVectors.at(c).mArithAverTenDays;
			}
			return;
		default:
			throw 17;
		}
	}
	const std::vector<StockPrices>& getStockPrices() const
		{
		return mLastYearData;
		}
private:
	const static char* msInputFilename;
	std::vector< StockPrices > mLastYearData;
	std::vector<ArithAverages> mArithAverageVectors;
	std::vector<double> mStandardDeviationsOneDay;
	std::vector<double> mStandardDeviationsTenDays;
	CovarianceMatrix mCovarinaceMatrixOneDay;
	CovarianceMatrix mCovarinaceMatrixTenDays;
	CorrelationMatrix mCorrelationMatrixOneDay;
	CorrelationMatrix mCorrelationMatrixTenDays;

	void tokenize(const std::string& str, std::vector<std::string>& tokens, const std::string& delimiters = ";");
	double toDouble(const std::string& str);
	void dumpValues();
	void dumpRelChanges(const enHoldingTime& holdingTime);
	void dumpArithAverageVectors();
	void dumpCovarianceMatrices();
	void dumpCorrelationMatrices();
};

#endif /* PARAMETRISATION_H_ */