// Author: I. Froehlich
// Written: 11.04.2007
// Revised: 
// PDataBase
// Replacement for the particle data base in PData

#ifndef _PDATABASE_H_
#define _PDATABASE_H_

#include "TROOT.h"
#include <iostream>
#include "PDefines.h"

#define PDATABASE_MAX_DOUBLE_PARAM 20
#define PDATABASE_MAX_STRING_PARAM 20
#define PDATABASE_MAX_INT_PARAM 150
#define PDATABASE_MAX_TOBJ_PARAM 10

#define PDATABASE_MAX_LINES 5000

using namespace std;

class PDataBase;
PDataBase* makeDataBase();
PDataBase& fDataBase();

class PDataBase : public TObject {

 private:

    //Entries properties
    const char *param_double_name[PDATABASE_MAX_DOUBLE_PARAM]; //the parameter name matching the ID
    const char *param_string_name[PDATABASE_MAX_STRING_PARAM]; 
    const char *param_int_name[PDATABASE_MAX_INT_PARAM];       
    const char *param_tobj_name[PDATABASE_MAX_INT_PARAM]; 
    const char *param_double_descr[PDATABASE_MAX_DOUBLE_PARAM]; //the parameter long description
    const char *param_string_descr[PDATABASE_MAX_STRING_PARAM]; 
    const char *param_int_descr[PDATABASE_MAX_INT_PARAM];       
    const char *param_tobj_descr[PDATABASE_MAX_INT_PARAM]; 
    Int_t   param_double_pointer;
    Int_t   param_string_pointer;
    Int_t   param_int_pointer;
    Int_t   param_tobj_pointer;

    //TODO: Params need description

    Int_t  *param_int_key[PDATABASE_MAX_INT_PARAM];
    Int_t   param_int_key_max[PDATABASE_MAX_INT_PARAM];

    //The entries array itself
    //for each entry, we add the pointer array to our params
    const char *strings[PDATABASE_MAX_LINES][PDATABASE_MAX_STRING_PARAM];
    Double_t   *doubles[PDATABASE_MAX_LINES][PDATABASE_MAX_DOUBLE_PARAM];
    Int_t      *ints[PDATABASE_MAX_LINES][PDATABASE_MAX_INT_PARAM];
    TObject    *tobjs[PDATABASE_MAX_LINES][PDATABASE_MAX_TOBJ_PARAM];

    Int_t  lastkey;

    Bool_t CheckEntry(Int_t key);  //check if key with unique name already existing
    Int_t  ConvertParamKey(const char * &newparamname, Int_t key);

 public:

    //constructor
    PDataBase();

    void    Performance(void);

    void    SetFastKey(Int_t pkey, Int_t maxkey);
    //return value of the makeParam's: the param_id of -1 on failure
    Int_t   MakeParamDouble(const char *paramname, 
			    const char *descr);//add "paramname" to double database
    Int_t   MakeParamString(const char *paramname, 
			    const char *descr); //add "paramname" to string database
    Int_t   MakeParamInt(const char *paramname, 
			 const char *descr);    //add "paramname" to int database
    Int_t   MakeParamTObj(const char *paramname, 
			  const char *descr);   //add "paramname" to object database

    Int_t   GetParamDouble(const char *paramname); //get "paramname" from double database
    Int_t   GetParamString(const char *paramname); //get "paramname" from string database
    Int_t   GetParamInt   (const char *paramname, Int_t length=-1);  //get "paramname" from string database
    Int_t   GetParamTObj  (const char *paramname);

    char   *GetDescription(const char* paramname);

    void    GetFastParamInt(const char* paramname, Int_t *pkey) {
	    if ((*pkey)<0) *pkey = GetParamInt(paramname);
	};  
    void    GetFastParamString(const char* paramname, Int_t *pkey) {
	    if ((*pkey)<0) *pkey = GetParamString(paramname);
	}; 
    void    GetFastParamDouble(const char* paramname, Int_t *pkey) {
	    if ((*pkey)<0) *pkey = GetParamDouble(paramname);
	}; 
    void    GetFastParamTObj(const char* paramname, Int_t *pkey) {
	    if ((*pkey)<0) *pkey = GetParamTObj(paramname);
	}; 
    
    using TObject::GetName;
    const char *GetName(Int_t key);
    //getting particle/decay properties from data base 
    //return kFALSE if 1.) key not existing or 2.) Param not existing or 3.) Param not used for entry
    Bool_t  GetParamDouble (Int_t key, const char *paramname, Double_t **result);
    Bool_t  GetParamString (Int_t key, const char *paramname, const char **result);
    Bool_t  GetParamInt  (Int_t key, const char *paramname, Int_t **result, Int_t length=-1);
    Bool_t  GetParamTObj (Int_t key, const char *paramname, TObject **result);

    //same as above but with the pkey as obtained by the getFastParam's
    Bool_t GetParamInt (Int_t key, Int_t pkey, Int_t **result);
    Bool_t GetParamString (Int_t key, Int_t pkey, const char **result);
    Bool_t GetParamDouble (Int_t key, Int_t pkey, Double_t **result);
    Bool_t GetParamTObj   (Int_t key, Int_t pkey, TObject **result);

    //setting value instead of pointer
    Bool_t GetParamInt (Int_t key, Int_t pkey, Int_t *result) {
	Int_t *p;
	Bool_t b = GetParamInt (key, pkey, &p);
	if (b && p)
	    *result = *p;
	else 
	    *result = 0;
	return b;
    };

    //getting param by primary name
    Bool_t GetParamInt(const char *name, const char *paramname, Int_t **result) {
	return GetParamInt(GetEntry(name), paramname, result);
	};
    Bool_t GetParamDouble(const char *name, const char *paramname, Double_t **result) {
	return GetParamDouble(GetEntry(name), paramname, result);
	};
    Bool_t GetParamString(const char *name, const char *paramname, const char **result) {
	return GetParamString(GetEntry(name), paramname, result);
	};
    Bool_t GetParamTObj(const char *name, const char *paramname, TObject **result) {
	return GetParamTObj(GetEntry(name), paramname, result);
	};

    //Getting param by matching integer value
    Bool_t GetParamInt(const char *paramname1, Int_t value1, const char *paramname2, Int_t **result) {	
	return GetParamInt(GetEntryInt(paramname1,value1), paramname2, result);
    };
    Bool_t GetParamDouble(const char *paramname1, Int_t value1, const char *paramname2, Double_t **result) {	
	return GetParamDouble(GetEntryInt(paramname1,value1), paramname2, result);
    };
    Bool_t GetParamString(const char *paramname1, Int_t value1, const char *paramname2, const char **result) {	
	return GetParamString (GetEntryInt(paramname1,value1), paramname2, result);
    };
    Bool_t GetParamTObj(const char *paramname1, Int_t value1, const char *paramname2, TObject **result) {	
	return GetParamTObj(GetEntryInt(paramname1,value1), paramname2, result);
    };

    //same as above when the pkey are known...
    Bool_t GetParamInt (Int_t pkey1, Int_t value1, Int_t pkey2, Int_t **result) {
	return GetParamInt(GetEntryInt(pkey1,value1), pkey2, result);
    };
    Bool_t GetParamDouble(Int_t pkey1, Int_t value1, Int_t pkey2, Double_t **result) {	
	return GetParamDouble(GetEntryInt(pkey1,value1), pkey2, result);
    };
    Bool_t GetParamString(Int_t pkey1, Int_t value1, Int_t pkey2, const char **result) {	
	return GetParamString(GetEntryInt(pkey1,value1), pkey2, result);
    };
    Bool_t GetParamTObj(Int_t pkey1, Int_t value1, Int_t pkey2, TObject **result) {	
	return GetParamTObj(GetEntryInt(pkey1,value1), pkey2, result);
    };


    Bool_t SetParamDouble (Int_t key, const char *paramname, Double_t *result);
    Bool_t SetParamString (Int_t key, const char *paramname, char *result);   
    Bool_t SetParamInt    (Int_t key, const char *paramname, Int_t *result);   
    Bool_t SetParamTObj   (Int_t key, const char *paramname, TObject *result);   

    //faster:
    Bool_t SetParamTObj(Int_t key, Int_t pp, TObject *result);

    Bool_t SetParamDouble(const char *name, const char *paramname, Double_t result) {
	Int_t key = GetEntry(name);
	if (key<0) return kFALSE;
	return SetParamDouble(key, paramname, new Double_t(result));
    }
    Bool_t SetParamInt(const char *name, const char *paramname, Int_t result) {
	Int_t key = GetEntry(name);
	if (key<0) return kFALSE;
	return SetParamInt(key, paramname, new Int_t(result));
    }
    Bool_t SetParamString(const char *name, const char *paramname, char *result) {
	Int_t key = GetEntry(name);
	if (key<0) return kFALSE;
	return SetParamString(key, paramname, result);
    };   
    Bool_t SetParamTObj(const char *name, const char *paramname, TObject *result) {
	Int_t key = GetEntry(name);
	if (key<0) return kFALSE;
	return SetParamTObj(key, paramname, result);
    }; 

    //Dealing with the entries
    Bool_t  AddEntry(Int_t key, const char *name);
    Int_t   AddEntry(const char *name);
    Int_t   GetEntry(const char *name); 
    Int_t   GetEntryInt(const char *paramname, Int_t value); 
    Int_t   GetEntryInt(Int_t pkey, Int_t value); 

    //listings
    Int_t   AddListEntry(const char *name, const char *count, const char *link, const char *newname);
    Bool_t  MakeListIterator(Int_t key, const char *count, const char *link, Int_t *listkey);
    Bool_t  MakeListIterator(Int_t key, Int_t count, Int_t link, Int_t *listkey);

    Bool_t  ListEntries(Int_t key=-1, Int_t option=0, const char *pattern=NULL);

    void Print(const Option_t* delme=NULL) const ;


    ClassDef(PDataBase, 0)  //Relational data base for pluto
};

#endif