#ifndef ANALYSIS_IHISTOGRAM_HXX
#define ANALYSIS_IHISTOGRAM_HXX

#include <TNamed.h>
#include <string>
#include <EoaCore.hxx>
#include <iostream>
#include <ICOMETLog.hxx>
#include "IOARuntimeParamBlock.hxx"

OA_EXCEPTION(IHistogram,COMET::EoaCore);
OA_EXCEPTION(AnalysisUnimplemented,IHistogram);
OA_EXCEPTION(OperationBetweenBadTypes,IHistogram);

class IHistogramFactory;
class TH1;

namespace COMET{
    class IVHistogram;
    class IHistogram;
}

class COMET::IVHistogram{

    public:
        friend class ::IHistogramFactory;

        IVHistogram(const std::string& name_space, const std::string& name):
            fParameters(name_space+"."+name),fNamespace(name_space),fName(name),fType("undefined"){}
        virtual ~IVHistogram(){}

        const std::string& GetType()const{return fType;}

        virtual void FillWith(double);
        virtual void FillWith(double,double);
        virtual void FillWith(double,double,double);
        virtual void FillWith(double,double,double,double);
        virtual void FillWith(double,double,double,double,double);
        virtual void FillWith(const double*,double=1);

        virtual void Draw(Option_t* opt);

        virtual void Setup( 
                const std::string & x_title,
                int x_bins, double x_low, double x_high);
        virtual void Setup( const std::string & x_title, 
                int x_bins, double x_low, double x_high,
                const std::string & y_title,
                int y_bins, double y_low, double y_high);
        virtual void Setup( const std::string & x_title,
                int x_bins, double x_low, double x_high,
                const std::string & y_title,
                int y_bins, double y_low, double y_high,
                const std::string & z_title,
                int z_bins, double z_low, double z_high);
        virtual void Setup( 
                int n_axes,
                const std::string *ax_titles,
                const int *bins, const double *low, const double *high);

        /// @{
        /// Ideally this would be protected but it would complicate the design
        /// too much so I'm lazily making the (probably bad) decision to leave
        /// this public
        virtual const TH1* Hist()const=0;
        virtual TH1* Hist()=0;
        /// @}

        virtual void Normalize(double norm);
        virtual void Normalize(COMET::IVHistogram* normalisation_hist, double scale=1);

        std::string GetNamespace()const{return fNamespace;}
        virtual const char* GetName()const{return fName.c_str();}

        virtual void SetDirectory(TDirectory* dir);
        virtual const TDirectory* GetDirectory()const;

        virtual void SetLegendEntry(std::string name)=0;
        virtual std::string GetLegendEntry()const=0;
        virtual void SetDrawStyle(std::string name)=0;
        virtual void SetAppearance(int colour,int style)=0;
        virtual std::string GetDrawStyle()const=0;
        virtual Int_t   Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const{
            return 0;
        }
        virtual void ls(Option_t* option = "") const{
            std::cout<< GetNamespace()<<"."<<GetName()<<std::endl;
        }

        virtual int GetNAxes()const=0;

    protected:
        int GetBins(int def=300,char axis='x')const{
            return fParameters.GetInt(axis+std::string("_bins"),def);
        }
        double GetLow(double def=0,char axis='x')const{
            return fParameters.GetDouble(axis+std::string("_low"),def);
        }
        double GetHigh(double def=1e3,char axis='x')const{
            return fParameters.GetDouble(axis+std::string("_high"),def);
        }
        int GetInt(const std::string& param, int def)const{
            return fParameters.GetInt(param,def);
        }
        double GetDouble(const std::string& param, double def)const{
            return fParameters.GetDouble(param,def);
        }
        std::string GetString(const std::string& param, const std::string& def)const{
            return fParameters.GetString(param,def);
        }


    private:
        void SetType(const std::string& type){fType=type;}

    private:
        COMET::IOARuntimeParamBlock fParameters; //!
        std::string fNamespace, fName;

        // IHistogramFactory::Make will set this
        std::string fType;
};

class COMET::IHistogram: public TNamed,public COMET::IVHistogram{

    public:
        IHistogram(std::string name_space="", std::string name="", std::string title=""):
            TNamed(name.c_str(),title.c_str()),
            COMET::IVHistogram(name_space,name) {}
        virtual ~IHistogram(){}

        using TNamed::GetName;

        virtual void SetDrawStyle(std::string name){
            fDrawStyle=name;
        }
        std::string GetDrawStyle()const{
            return fDrawStyle;
        }
        const TH1* Hist()const{return NULL;}
        TH1* Hist(){return NULL;}

        virtual void SetAppearance(int ,int ){ }

    protected:
        std::string fDrawStyle;

        ClassDef(IHistogram,1);

};

#endif // ANALYSIS_IHISTOGRAM_HXX