/*
 * PndAhTools.h
 *
 *  Created on: May 22, 2013
 *      Author: Andreas Herten
 */

#ifndef PNDAHTOOLS_H_
#define PNDAHTOOLS_H_

#include <algorithm>
#include <iostream>
#include <fstream>
#include <vector>
#include <utility>

#include "TH1D.h"
#include "TH2D.h"

namespace PndAhTools {

	template<typename _InputType>
	double findMinOfVector(_InputType __vector) {
		return *min_element(__vector.begin(), __vector.end());
	}
	template<typename _InputType>
	double findMaxOfVector(_InputType __vector) {
		return *max_element(__vector.begin(), __vector.end());
	}

	static inline double firstElementOfPair(const std::pair<double, double> &p) {
		return p.first;
	}
	static inline double secondElementOfPair(const std::pair<double, double> &p) {
		return p.second;
	}

	static inline void convertVectorOfPairsToTwoVectors(std::vector<std::pair<double, double> > inputVectors, std::vector<double> & dataX, std::vector<double> & dataY) {
		// dataX.resize(inputVectors.size());
		// dataY.resize(inputVectors.size());
		std::transform(inputVectors.begin(), inputVectors.end(), std::back_inserter(dataX), firstElementOfPair );
		std::transform(inputVectors.begin(), inputVectors.end(), std::back_inserter(dataY), secondElementOfPair );

	}

// public:
	template<typename _InputType>
	void printVector(_InputType __vector) {
		for (int i = 0; i < __vector.size(); ++i) {
			std::cout << __vector[i] << std::endl;
		}
	}

	template<typename _InputType>
	void readPoints(std::string filename, _InputType &x, _InputType &y, _InputType &r, int upToLineNumber = 2) {
		std::ifstream file(filename.c_str());
		float tempX, tempY, tempZ, tempR, tempI;
		char tempChar[10];
		int i = 1;
		if (!file.good() || file.fail()) std::cout << "Failed opening file!" << std::endl;
		while(i <= upToLineNumber && file >> tempX >> tempY >> tempZ >> tempR >> tempI >> tempChar) {
			std::cout << "x = " << tempX << ", y = " << tempY << ", r = " << tempR << std::endl;
			x.push_back(tempX);
			y.push_back(tempY);
			r.push_back(tempR);
			i++;
		}
		file.close();
	}

	static inline TH1D * vectorToHistogram(std::vector<double> data, int nBins = 100, bool autoRange = true, double leftBorder = -1, double rightBorder = -1) {
		double dataMin = leftBorder;
		double dataMax = rightBorder;
		if (autoRange) {
			dataMin = findMinOfVector(data) * 0.9;
			dataMax = findMaxOfVector(data) * 1.1;
		}
		TH1D * h1 = new TH1D("h1", "h1", nBins, dataMin, dataMax);
		for (int i = 0; i < data.size(); ++i) {
			h1->Fill(data[i]);
		}
		return h1;
	}

	static inline TH2D * vectorToHistogram(std::vector<std::pair<double, double> > data, int nBinsX = 100, int nBinsY = 100, bool autoRange = true, double leftBorderX = -1, double rightBorderX = -1, double leftBorderY = -1, double rightBorderY = -1) {
		double dataMinX = rightBorderX;
		double dataMaxX = leftBorderX;
		double dataMinY = rightBorderY;
		double dataMaxY = leftBorderY;
		std::vector<double> dataX, dataY;
		convertVectorOfPairsToTwoVectors(data, dataX, dataY);
		if (autoRange) {
			dataMinX = findMinOfVector(dataX) * 0.9;
			dataMaxX = findMaxOfVector(dataX) * 1.1;
			dataMinY = findMinOfVector(dataY) * 0.9;
			dataMaxY = findMinOfVector(dataY) * 1.1;
		}
		TH2D * h2 = new TH2D("h2", "h2", nBinsX, dataMinX, dataMaxX, nBinsY, dataMinY, dataMaxY);
		for (int i = 0; i < data.size(); ++i) {
			h2->Fill(data[i].first, data[i].second);
		}
		return h2;
	}

	template<typename _InputIterator, typename _basicType, typename _incrementType>
	void generate(_InputIterator __first, _InputIterator __last, _basicType __init, _incrementType __incrementBy) {
		for (int incrementor = 0; __first != __last; ++__first, ++incrementor) {
			*__first = __init + incrementor * __incrementBy;
		}
	}

	template<typename _InputVector>
	double findMinOfVectorOfVectors(_InputVector __vectors) {
		std::vector<double> vectorOfMinimums;
		for (int i = 0; i < __vectors.size(); ++i) {
			vectorOfMinimums.push_back( *min_element(__vectors[i].begin(), __vectors[i].end()));
		}
		return *min_element(vectorOfMinimums.begin(), vectorOfMinimums.end());
	}
	template<typename _InputVector>
	double findMaxOfVectorOfVectors(_InputVector __vectors) {
		std::vector<double> vectorOfMaximums;
		for (int i = 0; i < __vectors.size(); ++i) {
			vectorOfMaximums.push_back( *max_element(__vectors[i].begin(), __vectors[i].end()));
		}
		return *max_element(vectorOfMaximums.begin(), vectorOfMaximums.end());
	}

	template<class T>
	T scalarProduct(T a[], T b[], int length) {
		T returnValue = 0;
		for (int i = 0; i < length; ++i) {
			// std::cout << "returnvalue = " << returnValue << std::endl;
			returnValue += a[i] * b[i];
		}
		return returnValue;
	}
};


#endif /* PNDAHTOOLS_H_ */