#ifndef RXDataPlayer_HPP
#define RXDataPlayer_HPP

#include "IsoHelper.hpp"
#include "TString.h"
#include <tuple>
#include <map>
#include "RXDataPlayer.hpp"

class TTreeFormula;
class TH1D;
class TChain;
constexpr int MAXSLOTS = 100;

/**
 * @brief      Class for order in the std::tuple< Var,Sel,Weight> when wrapping the containers
 */
enum class Order : int{
	Selection =0,
	Weight    =1,
	Variable  =2 
};
/**
 * @brief      Class housing infos for the rx weight processing/plotting
 */
class RXWeight{
public:
	/**
	 * @brief      Constructs the object.
	 */
	RXWeight(){};
	/**
	 * The WeightExpression to use in TTreeFormula when loading the value
	 */
	TString weightExpr;
	/**
	 * The WeightLabel associated to this Weight, it will populate the final Histogram
	 */
	TString weightLabel;
	/**
	 * The unique IDX identifying this object, the idx is used such that Weight1 == Weight2 if idx == idx, useful to store map and retrieve object associated to a given objec
	 */
	int     w_idx; 
	/**
	 * @brief      Constructs the object with an IDX, an Expression, The Actual Label
	 *
	 * @param[in]  idx           The index
	 * @param[in]  _weightExpr   The weight expression
	 * @param[in]  _weightLabel  The weight label
	 */
	RXWeight( int idx, TString _weightExpr, TString _weightLabel){
		w_idx= idx;//idx*MAXSLOTS*MAXSLOTS;
		weightExpr  = _weightExpr;
		weightLabel = _weightLabel;
	};
	/**
	 * @brief      Returnm this oject Weight Expression
	 *
	 * @return     { description_of_the_return_value }
	 */
	TString Expression()const{ return weightExpr;}	
	/**
	 * @brief      Return the label of This Object
	 *
	 * @return     { description_of_the_return_value }
	 */
	TString Label()const{ return weightLabel;}	
	/**
	 * @brief      Print for Debugging
	 */
	void Print()const{
		std::cout<<"*WIDX "<<weight_idx()<<" Weight Expr : "<< weightExpr << std::endl;
		std::cout<<"*WIDX "<<weight_idx()<<" weightLabel : "<< std::endl;
	};
	/**
	 * @brief      The Weeight Index
	 *
	 * @return    the Weight INdex
	 */
	int weight_idx()const{ return w_idx;}	
	// int idx_linked()const{
	// 	return w_idx*MAXSLOTS;
	// }	
	bool operator<(const RXWeight& rhs) const{
        return w_idx < rhs.weight_idx();
  };
	friend bool operator==( const RXWeight & a, const RXWeight & b){ 
		return a.weight_idx() == b.weight_idx();
	};
};

class RXSelection{
public:
	RXSelection(){};
	TCut    RXCutExpression;
	TString RXSelectionLabel;
	int c_idx; 
	/**
	 * @brief      Constructs the object. with IDX, the actual selection and the SelectionLabel
	 *
	 * @param[in]  idx                The index
	 * @param[in]  _RXSelection       The rx selection
	 * @param[in]  _RXSelectionLabel  The rx selection label
	 */
	RXSelection( int idx, TCut _RXSelection, TString _RXSelectionLabel){	
		c_idx = idx;//idx*MAXSLOTS;
		RXCutExpression  = _RXSelection;
		RXSelectionLabel = _RXSelectionLabel;
	};
	// friend bool operator>( const RXSelection & a, const RXSelection & b){ 
	// 	return a.cut_idx() > b.cut_idx();
	// }	
	friend bool operator==( const RXSelection & a, const RXSelection & b){ 
		return a.cut_idx() == b.cut_idx();
	}

	bool operator<(const RXSelection& rhs) const{
        return c_idx < rhs.cut_idx();
  };
	int cut_idx()const{
		return c_idx; 
	};
	// int idx_linked()const{
	// 	return c_idx*MAXSLOTS*MAXSLOTS;
	// }
	void Print()const{
		std::cout<<"*CIDX"<<cut_idx()<<"  Cut Expr : "<< RXCutExpression << std::endl;
		std::cout<<"*CIDX"<<cut_idx()<<"  CutLabel : "<< RXSelectionLabel << std::endl;
	}
	TString Expression()const{ return (TString)RXCutExpression;}
	TString Label() const { return RXSelectionLabel;}
	// const TString Expression()const{ return (TString)RXCutExpression;}	

};
class RXVarPlot{
public:
	RXVarPlot(){};
	TString m_VarExpr;
	TString m_VarLabel;
	TString m_Units; 
	int     m_v_idx;
	bool    m_useYLog; 
	bool    m_doIsobinned;
	double  m_min; 
	double  m_max; 
	int     m_nBins;
	RXVarPlot( int _idx, TString _VarExpr, TString _VarLabel, int nBins, double _min, double _max, TString Units = "", bool _doIsoBinned = false, bool _useYLog = false){
		m_v_idx    = _idx;
		m_VarExpr  = _VarExpr;
		m_VarLabel = _VarLabel;
		m_nBins = nBins;
		m_min      = _min;
		m_max      = _max;
		m_Units = "";
		m_useYLog  = _useYLog;
		m_doIsobinned = _doIsoBinned;
	};
	TString Units(){ return m_Units;}
	int nBins(){ return m_nBins;}
	int min(){ return m_min;}
	int max(){ return m_max;}
	TString VExpression(){ return m_VarExpr;}
	TString VLabel(){ return m_VarLabel;}
	bool LogY(){ return m_useYLog; }
	bool IsoBin(){ return m_doIsobinned; }
	friend bool operator==( const RXVarPlot & a, const RXVarPlot & b){ 
		return a.var_idx() == b.var_idx();
	};
	bool operator<(const RXVarPlot& rhs) const{
        return m_v_idx < rhs.var_idx();
  };
	int var_idx()const{
		return m_v_idx;
	};

	// int idx_linked()const{
	// 	return m_v_idx;
	// }	
	TString Expression()const{ return m_VarExpr;}
	TString Label()const{ return m_VarLabel;}
	// const TString Expression()const{ return m_VarExpr;}	

	void Print()const {
		std::cout<<"*VIDX "<< var_idx()<< " VarExpr : "<< m_VarExpr << " , VarLabel "<< m_VarLabel<<m_Units<< std::endl;
		std::cout<<"*VIDX "<< var_idx()<< " nBins[min,max] " << m_nBins<<"["<<m_min<<","<<m_max<<"]"<<std::endl;
		std::cout<<"*VIDX "<< var_idx()<< " iso "<< m_doIsobinned << " | logY "<< m_useYLog<<  std::endl;
	}
};

// typedef map< int,  std::tuple<RXSelection, RXWeight , RXVarPlot  >  > RXWSelVars ; 
extern int GetVarIdx( int idx);
extern int GetCutIdx( int idx);
extern int GetWeightIdx( int idx);
//mapped int from weight, var, cut 


class RXDataPlayer{
public: 
	 RXDataPlayer(){};
	 RXDataPlayer(TString _name){m_name = _name;}; 
	 /**
	  * @brief      
	  *
	  * @param[in]  _varExpression  The variable expression to use in Drawing
	  * @param[in]  _VarLabel       The variable label to attach to the X-Axis
	  * @param[in]  nBins           The bins on which to plot
	  * @param[in]  min             The minimum on which to plot
	  * @param[in]  max             The maximum on which to plot
	  * @param[in]  Units           The units to use on this variable
	  * @param[in]  isoBin          The iso bin flag [not used yet]
	  * @param[in]  useLogy         The use logy [not used yet, no "full-plot report available at the moment"]
	  */
	 void Book1DHist( TString _varExpression, TString _VarLabel, int nBins, double min, double max  ,TString Units ="", bool isoBin = false,  bool useLogy  =false	);
	 /**
	  * @brief      Book1D histo passing a RooRealVar, we will use the name, title, nBins, units to book the histogram
	  *
	  * @param[in]  var   The variable
	  */
   void Book1DHist( const RooRealVar & var	);

	 // void Book1DHist( TString _varExpression, int nBins, double min, double max  ,TString Units, bool isoBin = false,  bool useLogy = false );
	/**
	 * @brief      Add a Selection Switcher for all the variables in the pool 
	 *
	 * @param[in]  idx         The index "fetching" this selection
	 * @param[in]  _selection  The selection expression (TCut)
	 * @param[in]  Label       The label of the selection 
	 */


	void BookRXSelection( TCut _selection , TString Label);
	/**
	 * @brief      BookRXWeight
	 *
	 * @param[in]  _weight        The weight
	 * @param[in]  RXWeightLabel  The rx weight label
	 */
	void BookRXWeight( TString _weight , TString RXWeightLabel);
	

	int GetNSelections() const { return m_nRXSelections; };
	int GetNWeightExp() const { return m_nRXWeights; };
	int GetNVarPlot() const { return m_nVars;};

	vector<double> GetValues(int _idx_var);

	vector<bool> GetSelectionValues(int _idx_sel);

	vector<double> GetWeightValues( int _idx_weight);

	void Print(){
		std::cout<<"N Booked Vars.   "<< GetNVarPlot() << std::endl;
		for(const auto & vv : m_bookedVariable){
			vv.second.Print(); 
		}
		std::cout<<"N Booked Cuts    "<< GetNSelections() << std::endl;
		for(const auto & vv : m_bookedRXSelections){
			vv.second.Print(); 
		}		
		std::cout<<"N Booked Weights "<< GetNWeightExp() << std::endl;
		for(const auto & vv : m_bookedRXWeights){
			vv.second.Print(); 
		}

	}

	//0,1,2 for Order in the tuple 
	std::vector< std::tuple<RXSelection, RXWeight , RXVarPlot  >  > BuildCombination( ); //const map<int, RXSelection> & _RXSelections, const map<int, RXWeight>    & _RXWeights,  const map<int, RXVarPlot> & _Variables);


	void Process( TChain & _inputChain, double frac = -1 ) noexcept;


	TH1D * GetHistogram( int _idx_var, int _idx_cut, int _idx_weight);

	void Reset(); 
	private : 
		// TString m_name = ""; 
		std::map<int, RXWeight>        m_bookedRXWeights = {};

		std::map<int, RXSelection>     m_bookedRXSelections = {}; 
		std::map<int, RXVarPlot>       m_bookedVariable = {}; 


		std::map<RXWeight , vector<double> >  m_bookedWeightsResults = {}; 
		std::map<RXSelection , vector<bool> > m_bookedSelectionResults = {};  
		std::map<RXVarPlot , vector<double> > m_bookedVariableValues = {};  

		std::map<int, pair<RXSelection, RXWeight> > m_bookedWCut = {} ; //range |XXYY| = XX = RXSelection idx, YY = RXWeight IDX 

		int m_nRXSelections =0;//0-99 
		int m_nRXWeights    =0;//0-99 
		int m_nVars         =0;//0-99 

		TString m_name;
};

#endif