//#define USE_ROOT_HTTP 1

#include "hades.h"
#include "hruntimedb.h"
#include "honlineclientservercom.h"
#include "honlinemonhist.h"
#include "honlinemonstack.h"

#include "TApplication.h"
#include "TString.h"
#include "TList.h"

#ifdef USE_ROOT_HTTP
#include "THttpServer.h"
#endif

#include "helpers.h"
#include "createHades.C"
#include "Mdc.C"
#include "Rich.C"
#include "Tof.C"
#include "Emc.C"
#include "Wall.C"
//#include "Sts.C"
//#include "FRpc.C"
//#include "PionTracker.C"
#include "Hodo.C"
//#include "InnerTof.C"
#include "Rpc.C"
#include "Start.C"
#include "Physics.C"
//#include "ForwardPhysics.C"


#include <map>
#include <vector>
#include <iostream> 
#include <iomanip>
#include <cstdlib>
#include <unistd.h>
using namespace std;

map < TString , HOnlineMonHistAddon* > currentMap;


void usage()
{
    cout << "usage: OnlineServer servername serverhostname connectorport parameterfile"<<endl;
    cout << "EXAMPLE ./hadesonlineserver.exe  SUPER lxg0453  9876  analysisParams.txt"<<endl;
    exit(1);
}

int main(int argc, char **argv)
{
    TString name;
    TString hostname;
    TString connector;
    UInt_t  con;
    TString param;

    if(argc < 4)
    {
	usage();
	return 1;
    }
    else{
	name      = argv[1];
	hostname  = argv[2];
	connector = argv[3];
	con       = atoi(connector);
	param     = argv[4];
	cout << "Server:"<<name.Data()<<",\tHost:"<<hostname.Data()<<",\tConnector:"<<con<<",\n Parameter:"<<param.Data()<<endl;

	TApplication theApp("App", &argc, argv);

        //--------------------------------------------------------------------
        // setup Hades

    Int_t   datasource   = 99; // 99 = hldstreamsource(dabc), everything else as in HDst (0 = hld, 1 = hldgrep 2 = hldremote, 3 root 4 geantmerge  5 hldstack(Processor task)) !!
	Int_t  refId             = 444571079; //first in root par
	//Int_t   refId        = 1;
	TString eventbuilder = "dabc://lxhadeb08:8101";         // needed by dataosoure = 3
	TString inputDir     = "/store/08/01/data/";
	TString inputFile    = "";      // needed by dataosoure = 1
	TString paramSource  ="ASCII,ROOT";  // ASCII, ROOT, ORACLE (ASCII always first input, ORACLE sencond if ASCII or ROOT is used)
    TString asciiParFile ="/home/hades-qa/online/5.34.38/feb24/online/server/params/feb24_dst_params.txt";  // same as feb21_dst_params.txt for new dets.
	TString rootParFile  ="/home/hades-qa/online/5.34.38/feb24/online/server/params/allParam_Feb22_gen2_27022023.root";

    Int_t evtCtInterval  = 100;

	Bool_t ok = createHades(datasource,
				inputDir,
				inputFile,
				refId,
				eventbuilder,
				paramSource,
				asciiParFile,
				rootParFile
			       );
	if(!ok){
             cout<<"Error: Hades could not be created!"<<endl;
             exit(1);
	}
	//--------------------------------------------------------------------

	//--------------------------------------------------------------------
        // create connection class
	HOnlineClientServerCom* clientservercom = new HOnlineClientServerCom(name, hostname, con);
	clientservercom -> setDebug(kFALSE);
	clientservercom ->setEvtCounterInterval(-1); // do not print from HOnlineClientServerCom, use print from gHades
    gHades->makeCounter(evtCtInterval);
    gHades->setQuietMode(4); // 0:all prints, 1: Eventwise, 2: Summary at end, 3: Event+Summary, 4: Online eventwise (eventLoop called with one event only)
	
	if (!clientservercom->init()) {
	    cout<<"Error: Hades Monitoring Server could not be initialised."<<endl;;
	    exit(1);
	}

	cout << "Hades Monitoring Server initialised"<<endl;
	cout << "Created Online Hades Server Client Instance: " << name.Data() << endl;
        //--------------------------------------------------------------------

	gHades->eventLoop(2);
        //gHades->getRuntimeDb()->saveOutput();

	cout<<"Hades Monitoring Server: ADD Histograms"<<endl;


	//####################### USER CODE ##############################################
	// CREATE Histograms
	// Names must be unique !! NAMING CONVENTIONS :  h{det}somename

	mapHolder::getMapHolder();     // create mapHolder object (helpers.h)

	TList histpool;                // list of all histograms

	createHistMdc        (histpool);
	createHistRich       (histpool);
	createHistEmc        (histpool);
	createHistRpc        (histpool);
	createHistTof        (histpool);
	createHistWall       (histpool);
//    createHistPionTracker(histpool);
//    createHistSts        (histpool);
//    createHistFRpc       (histpool);
//    createHistFPhysics   (histpool);
    createHistHodo       (histpool);
//    createHistInnerTof   (histpool);
    createHistStart      (histpool);
    createHistPhysics    (histpool);


	printList(histpool);           // (helpers.h)


	//###############################################################################

	vector < fillptrHOnlineClientServerCom > fillfunctions;


	fillfunctions.push_back(&fillHistMdc);
    fillfunctions.push_back(&fillHistRich);
	fillfunctions.push_back(&fillHistEmc);
	fillfunctions.push_back(&fillHistRpc);
	fillfunctions.push_back(&fillHistTof);
	fillfunctions.push_back(&fillHistWall);
//    fillfunctions.push_back(&fillHistPionTracker);
//    fillfunctions.push_back(&fillHistSts);
//    fillfunctions.push_back(&fillHistFRpc);
//    fillfunctions.push_back(&fillHistFPhysics);

    fillfunctions.push_back(&fillHistHodo);
//    fillfunctions.push_back(&fillHistInnerTof);
    fillfunctions.push_back(&fillHistStart);
    fillfunctions.push_back(&fillHistPhysics);



#ifdef USE_ROOT_HTTP
        // JAM2020 - export all  histograms to webserver - may disable this to test lock?
        cout<<"Hades Monitoring Server: create HTTP server"<<endl;
        THttpServer* httpserv = new THttpServer("http:8888?top=onlineFeb21");
        //httpserv->Unregister(gROOT); //suppress showing open calib file ? does not work
        TIterator* it  = histpool.MakeIterator();
        HOnlineMonHistAddon* addon;
        while( ((addon = (HOnlineMonHistAddon*) it->Next()) != 0) ) {
          // JAM20202- poor mans solution to divide into subsystems. the addon has no property for that.
          TString component="general";
          TString path;
          if(strstr(addon->GetName(),"Mdc"))
            {
              component="MDC";
            }
          else if(strstr(addon->GetName(),"Rich"))
            {
              component="RICH";
            }
           else if(strstr(addon->GetName(),"Emc"))
            {
              component="EMC";
            }
          else if(strstr(addon->GetName(),"Start"))
            {
              component="START";
            }
           else if(strstr(addon->GetName(),"Rpc"))
            {
              component="RPC";
            }
           else if(strstr(addon->GetName(),"InnerTof"))
            {
              component="INNERTOF";
            }
          else if(strstr(addon->GetName(),"Tof"))
            {
              component="TOF";
            }
          else if(strstr(addon->GetName(),"Hodo"))
            {
              component="HODO";
            }
           else if(strstr(addon->GetName(),"Wall"))
            {
              component="WALL";
            }
         else if(strstr(addon->GetName(),"Sts"))
            {
              component="STS";
            }
          else if(strstr(addon->GetName(),"FRpc"))
            {
              component="FRPC";
            }
          else if(strstr(addon->GetName(),"Forward"))
            {
              component="FPHY";
            }


/////////// JAM2021 todo: handle all these variants of the addon
//          if(type.Contains("1") ) { addon = new HOnlineHistArray (*this); }
// 	else                    { addon = new HOnlineHistArray2(*this); }
//     }
//     else if(format == "trend")      { addon = new HOnlineTrendHist (*this); }
//     else if(format == "trendarray") { addon = new HOnlineTrendArray(*this); }
//     else if(format == "mon")    {
// 	if(type.Contains("1") ) {  addon = new HOnlineMonHist (*this); }
// 	else                    {  addon = new HOnlineMonHist2(*this); }
//

          HOnlineMonStack* stack=dynamic_cast<HOnlineMonStack*>(addon);
          HOnlineHistArray* array=dynamic_cast<HOnlineHistArray*>(addon);
          HOnlineHistArray2* array2=dynamic_cast<HOnlineHistArray2*>(addon);
          HOnlineTrendHist* trend=dynamic_cast<HOnlineTrendHist*>(addon);
          HOnlineTrendArray* trendarray=dynamic_cast<HOnlineTrendArray*>(addon);

          TObject* ob=0;
          if(stack)
            {
              TObjArray* stackarray=stack->getStack();
              // TODO iterate over all members of stack
               TIterator* stit  = stackarray->MakeIterator();
               TH1* shis;
               while( ((shis = (TH1*) stit->Next()) != 0) ) {
                 TH1* his= dynamic_cast<TH1*>(shis);
                 if(his)
                   {
                   cout <<"Register stack to http server:"<<his->GetName() << endl;
                   path.Form("/HadesQA/%s/stacks/%s",component.Data(), addon->GetName());
                   httpserv->Register(path.Data(), his);
                   }
                 }
            }
          else if(array)
          {
            Int_t mx=0, my=0;
            array->getDim(&mx, &my);
            for(Int_t x=0; x<mx;++x){
                for(Int_t y=0;y<my;++y){
                     TH1* his= dynamic_cast<TH1*>(array->getP(x,y));
                     path.Form("/HadesQA/%s/%s",component.Data(), array->GetName());
                     cout <<"Register to http server for array:"<<array->GetName()<<" - "<<his->GetName() << endl;
                    httpserv->Register(path.Data(), his);
                }
            }
          }
          else if (array2)
          {
           Int_t mx=0, my=0;
            array2->getDim(&mx, &my);
            for(Int_t x=0; x<mx;++x){
                for(Int_t y=0;y<my;++y){
                     TH1* his= dynamic_cast<TH1*>(array2->getP(x,y));
                     path.Form("/HadesQA/%s/%s",component.Data(), array2->GetName());
                     cout <<"Register to http server for array 2:"<<array2->GetName()<<" - "<<his->GetName() << endl;
                    httpserv->Register(path.Data(), his);
                }
            }
          }
          else if(trend)
          {
              TH1* his= dynamic_cast<TH1*>(trend->getP());
              path.Form("/HadesQA/%s/trending",component.Data());
              cout <<"Register to http server - trending:"<<his->GetName() << endl;
              httpserv->Register(path.Data(), his);
          }
          else if (trendarray)
          {
           Int_t mx=0, my=0;
            trendarray->getDim(&mx, &my);
            for(Int_t x=0; x<mx;++x){
                for(Int_t y=0;y<my;++y){
                     TH1* his= dynamic_cast<TH1*>(trendarray->getP(x,y));
                     path.Form("/HadesQA/%s/trending/%s",component.Data(), trendarray->GetName());
                     cout <<"Register to http server for array:"<<trendarray->GetName()<<" - "<<his->GetName() << endl;
                    httpserv->Register(path.Data(), his);
                }
            }
          }

          else
            {
              TH1* his= dynamic_cast<TH1*>(addon->getP());
              path.Form("/HadesQA/%s",component.Data());
              cout <<"Register to http server:"<<his->GetName() << endl;
              httpserv->Register(path.Data(), his);
              }
            }



        httpserv->SetTimer(100,kFALSE);
#endif // ROOT_HTTP_SERVER
	cout<<"Hades Monitoring Server: START eventloop"<<endl;
 	clientservercom->eventLoop(&fillfunctions); // start eventLoop thread
    clientservercom->processClients(histpool);  // start communication loop


    cout<<"DELETING HADES!"<<endl;
    delete clientservercom;
 	delete gHades;

	return 0;
    }
}