//***************************************************
// Event Display implementation: 3D View
// For the GEM-TPC decoding/monitoring software
//
// based on the genfit Display written by Karl Bicker
//
// author: Johannes Rauch
//         E18, Technische Universitaet Muenchen
//
//***************************************************


#ifndef _PNDTPCCLUSTVIS_H
#define _PNDTPCCLUSTVIS_H

//#include "FairTask.h"

#include "TpcEvent.h"

#include<iostream>

#include <assert.h>
#include <cmath>
#include <exception>
#include <iostream>

#include <RecoHits/GFAbsRecoHit.h>
#include <GFAbsTrackRep.h>
#include <GFConstField.h>
#include <GFDetPlane.h>
#include <GFException.h>
#include <GFFieldManager.h>
#include <GFTrack.h>
#include <GFRecoHitFactory.h>

#include "FairRunAna.h"
#include "FairGeanePro.h"

#include <TApplication.h>
#include <TEveBrowser.h>
//#include <TEveBox.h>
#include <TEveManager.h>
#include <TEveEventManager.h>
#include <TEveGeoNode.h>
#include <TEveGeoShape.h>
#include <TEveStraightLineSet.h>
#include <TDecompSVD.h>
#include <TGButton.h>
#include <TGLabel.h>
#include <TGNumberEntry.h>
#include <TGeoEltu.h>
#include <TGeoManager.h>
#include <TGeoMatrix.h>
#include <TGeoNode.h>
#include <TGeoSphere.h>
#include <TGeoTube.h>
#include <TGeoBBox.h>
#include <TTree.h>
#include <TMath.h>
#include <TMatrixT.h>
#include <TMatrixDEigen.h>
#include <TROOT.h>
#include <TVector2.h>
#include <TVector3.h>
#include <TVectorD.h>
#include <TSystem.h>
#include <TH1D.h>
#include <string>
#include <vector>

#include "TpcGas.h"
#include "TpcDigi.h"
#include "TpcDigiMapper.h"
#include "TpcDigiAmplitude.h"
#include "TpcPadShapePool.h"
#include "TpcPadPlane.h"
#include "TpcAbsPadShape.h"
#include "TpcPad.h"
#include "TpcGem.h"

#include "TpcRiemannTrack.h"
#include "TpcRiemannHit.h"
#include "TpcRiemannTrackFinder.h"
#include "TpcProximityHTCorrelator.h"
#include "TpcHelixHTCorrelator.h"
#include "TpcRiemannTTCorrelator.h"
#include "TpcDipTTCorrelator.h"

#include "TpcPoint.h"
#include "TpcDigi.h"
#include "TpcCluster.h"
#include "McId.h"
#include "McIdCollection.h"



class TpcClustVis : public TObject {
private:
  TpcClustVis();

public:
  ~TpcClustVis();
  static TpcClustVis* getInstance();

  /** @brief Drop all events.*/
  void reset();

  void setTree(TTree* treeIn);
  void setMCTree(TTree* treeIn);
  
  void setDigiBranchName(TString name){fDigiBranchName = name;}
  void setClusterBranchName(TString name){fClusterBranchName = name;}

  void init(double gain);

  void setFieldZ(double B){Bz=B;}

  void setRiemannscale(double scale){fRiemannScale=scale;}

  /** @brief Go to the next event or step a certain number of events ahead.*/
  void next(unsigned int stp = 1);

  /** @brief Go to the previous event or step a certain number of events back.*/
  void prev(unsigned int stp = 1);

  /** @brief Go to event with index id.*/
  void gotoEvent(int id);

  /** @brief Get the total number of events stored.*/
  int getNEvents();

  /** @brief Open the event display.*/
  void open();

  void guiGoto();
  void guiSetDrawParams();
  void guiSetClusterfinderParams();
  void guiSetTrackingParams();
  void guiSetFittingParams();

  void writeDebugLogger();


private:
  void buildTracks(TpcRiemannTrackFinder* trackfinder,
                   std::vector<TpcCluster*>* clusterBuffer,
                   std::vector<TpcRiemannTrack*>* TrackletList,
                   int sorting,
                   unsigned int minHits,
                   double maxRMS,
                   bool skipCrossingAreas = true,
                   bool skipAndDelete = true);


  static TpcClustVis* eventDisplay;
  int fEventId;
  std::string fOption;

  std::vector<Color_t> colors;
  
  TString fDigiBranchName;
  TString fClusterBranchName;

  TTree* tree;
  TTree* mctree;
  TClonesArray* MCTrackBranch;
  TClonesArray* tpcPointsBranch;
  TClonesArray* digisBranch;
  TClonesArray* clustersBranch;
  TClonesArray* preFitBranch;
  TClonesArray* postFitBranch;

  double fgain;

  std::map<unsigned int, std::vector<TpcCluster*>*> fbuffermap;
  std::vector<TpcCluster*>* fcluster_buffer;
  TClonesArray* clusterArray;
  std::vector<TpcRiemannTrack*> friemannlist;
  unsigned int fnsectors;

  GFRecoHitFactory* _theRecoHitFactory;
  FairRunAna* fRun;
  FairGeanePro* GeanePro;

  TGCheckButton* guiInstantRedraw;
  bool instantRedraw;
  TGCheckButton* guiDrawTpc;
  bool drawTpc;
  TGNumberEntry* guiTpcTransp;
  int TpcTransp;
  TGCheckButton* guiDrawRawDigis;
  bool drawRawDigis;
  TGCheckButton* guiDrawDigis;
  bool drawDigis;
  TGCheckButton* guiDrawClusters;
  bool drawClusters;
  TGCheckButton* guiDrawClustersErrors;
  bool drawClusterErrors;
  TGCheckButton* guiDrawCovOnPlane;
  bool drawCovOnPlane;

  TGNumberEntry* guiNsectorsToProcess;
  unsigned int NsectorsToProcess;
  TGCheckButton* guiDrawRiemannTracks;
  bool drawRiemannTracks;
  TGCheckButton* guiDrawMCTracks;
  bool drawMCTracks;
  TGNumberEntry* guifpurityLoCut;
  double fpurityLoCut;
  TGNumberEntry* guifpurityCut;
  double fpurityCut;
  TGCheckButton* guiDrawPOCA;
  bool drawPOCA;
  TGCheckButton* guiDrawFitMarkers;
  bool drawFitMarkers;

  TGCheckButton* guiPlotHistos;
  bool plotHistos;

  TGCheckButton* guiDoClustering;
  bool doClustering;
  TGNumberEntry* guiEvent;
  TGNumberEntry* guiNClus;
  int drawNClus;
  TGNumberEntry* guiMode;
  int ClMode;
  TGNumberEntry* giuTimeslice;
  int ClTimeslice;
  TGNumberEntry* giuTimecut;
  int ClTimecut;
  TGNumberEntry* guiSingleDigiClAmpCut;
  int ClSingleDigiClAmpCut;
  TGNumberEntry* guiClAmpCut;
  double ClClAmpCut;
  TGNumberEntry* guiElPerADC;
  double ClElPerADC;
  TGNumberEntry* guiErrorNorm;
  double ClErrorNorm;
  TGCheckButton* guiSimpleCl;
  bool ClSimpleCl;
  TGCheckButton* guiSimpleClMerge;
  bool ClSimpleClMerge;
  TGNumberEntry* giuSimpleTimeslice;
  int ClSimpleTimeslice;
  TGNumberEntry* giuSimpleMaxClusterSlice;
  int ClSimpleMaxClusterSlice;

  bool ClHasChanged;

  TGCheckButton* guiDoPR;
  bool doPR;
  TGNumberEntry* guiPRNHits;
  int PRNHits;
  TGNumberEntry* guiPRStage;
  unsigned int PRStage;
  TGCheckButton* guiClearUnfitted;
  bool clearUnfitted;
  TGCheckButton* guiDoMerge;
  bool doMerge;
  TGCheckButton* guiDoGlobMerge;
  bool doGlobMerge;
  TGCheckButton* guiDoMergeCurlers;
  bool doMergeCurlers;

  TGCheckButton* guiDoClean;
  bool doClean;

  TGNumberEntry* guisorting;
  int _sorting;
  TGNumberEntry* guiinteractionZ;
  double _interactionZ;
  TGCheckButton* guisortingMode;
  bool _sortingMode;
  TGNumberEntry* guiminpoints;
  int _minpoints;
  TGNumberEntry* guiplanecut;
  double _planecut;
  TGNumberEntry* guiriproxcut;
  double _riproxcut;
  TGNumberEntry* guiszcut;
  double _szcut;
  TGNumberEntry* guiproxcut;
  double _proxcut;
  TGNumberEntry* guiproxZstretch;
  double _proxZstretch;
  TGNumberEntry* guihelixcut;
  double _helixcut;
  TGNumberEntry* guiMaxRMS;
  double _maxRMS;

  TGNumberEntry* guiTTproxcut;
  double _TTproxcut;
  TGNumberEntry* guiTTplanecut;
  double _TTplanecut;
  TGNumberEntry* guiTTszcut;
  double _TTszcut;
  TGNumberEntry* guiTTdipcut;
  double _TTdipcut;
  TGNumberEntry* guiTThelixcut;
  double _TThelixcut;
  TGNumberEntry* guiTTscale;
  double fRiemannScale;
  TGNumberEntry* guiInitDip;
  double initDip;

  bool PRHasChanged;

  TGCheckButton* guiDoFit;
  bool doFit;
  TGCheckButton* guiUseDAF;
  bool useDAF;
  TGCheckButton* guiInvertCharge;
  bool invertCharge;
  TGCheckButton* guiUseGeane;
  bool useGeane;
  TGNumberEntry* guiNumIts;
  int numIts;
  TGCheckButton* guiSmooth;
  bool smooth;

  double Bz;

  int fnStage; // PR Stage we're currently at

  // benchmark histograms
  TH1D* PREffAll;
  TH1D* trkPurityAll;
  TH1D* trkCompletenessAll;

  TH1D* PREffPrim;
  TH1D* trkPurityPrim;
  TH1D* trkCompletenessPrim;

  TH1D* PREffSec;
  TH1D* trkPuritySec;
  TH1D* trkCompletenessSec;

  std::map<McId, unsigned int> fClustersPerId;
  unsigned int nTotTrks;
  unsigned int nTotTrksPrim;
  unsigned int nTotTrksSec;

  /** @brief Build the GUI.*/
  void makeGui();

  /** @brief Draw an event.*/
  void drawEvent(unsigned int id, bool resetCam=true);

  void clearBufferMap();
  void drawTpcPoint(const TpcPoint* point);
  void drawDigi(const TpcDigi* digi, bool raw=true, Color_t color=kGray);
  void drawCluster(const TpcCluster* cluster, Color_t color=kGray);

public:
  ClassDef(TpcClustVis,1)
};

#endif