#ifndef PROTO_CLUSTER_H
#define PROTO_CLUSTER_H

#include "lcio.h"
#include "Pandora.h"
#include "EVENT/LCIO.h"
#include "EVENT/CalorimeterHit.h"
#include "IMPL/ClusterImpl.h"
#include "MyTrackExtended.h"
#include "MyMCTree.h"
#include <vector>

class MyCaloHitExtended;
class MyTrackExtended;
class ProtoCluster;

typedef std::vector<MyTrackExtended*> MyTrackExtendedVec;
typedef std::vector<MyMCPFO*> MyMCPFOVec;

typedef enum {
  INITIAL_DIRECTION =0,
  CURRENT_DIRECTION,
  EXTERNAL_DIRECTION
} ProtoClusterDirectionType;



typedef enum {
  PC_UNKNOWN =0,
  PC_UNASSOCIATED_TRACK,
  PC_MIP_SEGMENT,
  PC_PRIMARY_PHOTON,
  PC_SECONDARY_PHOTON,
  PC_SHOWER
} ProtoClusterClassificationType;

typedef struct {
  int  ilayer;
  float x;
  float y;
  float z;
  float padSize;
} vec4;


typedef struct {
  float tanConeAngleECAL;
  float tanConeAngleHCAL;
  float additionalPadsECAL;
  float additionalPadsHCAL;
  float sameLayerPadCutECAL;
  float sameLayerPadCutHCAL;
  float maximumDistanceForConeAssociationECAL;
  float maximumDistanceForConeAssociationHCAL;
  int   trackingWeight;
  int   trackingCutOff;
  float trackingTube;
} protoClusterDesign_t;


typedef struct {
  int contactLayers;
  float contactFraction;
} clusterContact_t;

typedef struct {
  float energy;
  int   du;
  int   dv;
  float dmin;
  int   showerDepth90;
  int   showerDepth25;
  int   showerStartDepth;
  float rms;
} protoClusterPeaks_t;

typedef struct {
  bool  ok;
  float dir[3];   // direction cosines
  float intercept[3]; // point on track (centre)
  float chi2;
  float rms;
  float dirDotR;
} fitResult;

class ProtoCluster{
  
public:
  
  ProtoCluster(MyCaloHitExtended* pHit);
  ProtoCluster(MyTrackExtended*);
  ProtoCluster(); 
  void ConfigureGrowth(protoClusterDesign_t design);
  ~ProtoCluster(); 

  bool IsElectron(){return _electronID;};
  void IsElectron(bool tf){_electronID=tf;};
  bool IsPhoton();
  bool IsHotHadron(){return _hotHadron;};
  void HotHadron(bool tf){_hotHadron = tf;};
  void IsPrimaryPhoton(bool tf);
  void SetTemporaryReclusteringFlag(bool flag){_temporaryReclusteringAttempt=flag;};
  bool GetTemporaryReclusteringFlag(){return _temporaryReclusteringAttempt;};
  bool IsPrimaryPhoton();
  bool IsAttachable();
  bool AssociatedTrack(){return _associatedTrack;};
  void AssociatedTrack(bool tf){ _associatedTrack=tf;};
  void TagFixedPhoton();
  bool TrackSeeded(){return _trackSeeded;};
  void initialise();
  void AddTrack(MyTrackExtended* track);
  void AddMCPFO(MyMCPFO* p);
  void ClearTracks();
  MyTrackExtendedVec& GetTrackVec();
  MyMCPFOVec& GetMCPFOVec();
  void AddHit(MyCaloHitExtended* pHit, float weight=1);
  //void AddHit(MyCaloHitExtended* pHit);
  void AddIsolatedHit(MyCaloHitExtended* pHit);
  void RemoveHit(MyCaloHitExtended* pHit);
  void Assimilate(ProtoCluster* pC);
  void Flush();
  void IsNowDefunct();
  bool IsDefunct(){return _defunct;};
  void Dump();
  void SetID(int id);
  void SetErrorType(int ierr){_errorType=ierr;};
  int  GetErrorType(){return _errorType;};
  void SetZOfEndcap(float z){_zOfEndcap=z;};
  void SetZOfBarrel(float z){_zOfEndcap=z;};
  void SetEarliestRelationID(int id);
  void SetEarliestRelation(ProtoCluster* pC);
  int getID(){return _ID;};
  int getLayer90(){return _layer90;};
  int getLayerMax(){return _layerMax;};
  int getEarliestRelationID(){return _earliestRelationID;};
  ProtoCluster* getEarliestRelation(){return _earliestRelation;};
  unsigned int getDaughters(){return _daughters.size();};
  unsigned int getParents(){return _parents.size();};
  ProtoCluster* getParent(unsigned int n){return _parents[n];};
  ProtoCluster* getDaughter(unsigned int n){return _daughters[n];};
  void AddDaughter(ProtoCluster* p);
  void AddParent(ProtoCluster* p );
  void TransverseProfile(std::vector<protoClusterPeaks_t> &peaks, int maxLayers=30);
  ProtoCluster* TransverseProfile(int ipeak, int maxLayer, int extraLayers);
  int Hits(){return _nHits;};
  int IsolatedHits(){return _isolatedHits.size();};
  MyCaloHitExtended* Hit(int ihit){return _hits[ihit];};
  MyCaloHitExtended* IsolatedHit(int ihit){return _isolatedHits[ihit];};
  bool StillGrowing(){return _stillGrowing;};
  bool Connected(){return _connected;};
  bool RelatedTo(ProtoCluster*);
  float Energy(){return _bestEnergy;};
  float EnergyEM(){return _energyEM;};
  float EnergyInMips(){return _energyInMips;};
  float EnergyHAD(){return _energyHAD;};
  void  setEnergyHAD(float E){_energyHAD=E;};
  int LastLayer(){return _lastLayer;};
  int FirstLayer(){return _firstLayer;};
  int HitLayers(){return _hitLayers;};
  int ShowerLayer(){return _showerLayer;};
  float DCosR(){return _dCosR;};
  float ClusterRMS(){return _clusterRms;};
  float ClusterLength(){return _showerLength;};
  float ShowerMax(){return _showerMax;};
  float* GetCentroid(int ilayer);
  float* GetInitialDir();
  float* GetCurrentDir();
  float CentroidDistanceToTrack(MyTrackExtended* trackAR); 
  float Centroid10DistanceToTrack(MyTrackExtended* trackAR); 
  float Centroid20DistanceToTrack(MyTrackExtended* trackAR); 
  float DistanceToTrack(MyTrackExtended* trackAR, int layers=4, bool endcap=false); 
  float DistanceToAltTrack(MyTrackExtended* trackAR, int layers=4); 
  float DistanceToPoint(float x, float y, float z, int layers);
  float TruePhotonContribution();
  float BarrelEncapEnergySplit();
  float DistanceToLine(float x0, float y0, float z0, float ux, float uy , float uz, int layers);

  float genericDistance(ProtoCluster* cluster, int ilayer);
  float genericDistance(ProtoCluster* cluster, int iFirstLayer, int iLastLayer);
  float genericDistance(ProtoCluster* cluster);
  float genericDistanceToHit(const MyCaloHitExtended* newhit, const int ilayer);
  float genericDistanceToTrackSeed(const MyCaloHitExtended* newhit, const int ilayer);
  float genericDistanceToTrackSeed(const MyCaloHitExtended* hit, const float distance);
  float DistanceToHit(const MyCaloHitExtended* newhit);
  float DistanceToIsolatedHit(const MyCaloHitExtended* newhit);
  float genericDistanceToHit(const MyCaloHitExtended* candHit, const int searchLayer, const ProtoClusterDirectionType directionType);
  float genericDistanceInSameLayer(const MyCaloHitExtended* candHit);
  float coneApproach(const MyCaloHitExtended* candHit, const float dir[3], const float position[3]);  
  float DistanceFromInitialProjection(ProtoCluster*);
  int hitsInLayer(int ilayer);
  int isolatedHitsInLayer(int ilayer);
  void Update(int ilayer);
  MyCaloHitExtended* hitInLayer(int ilayer, int ihit);
  MyCaloHitExtended* isolatedHitInLayer(int ilayer, int ihit);
  float DistanceToClosestHit(ProtoCluster* pC);
  float FractionOfCloseHits(ProtoCluster* pC, float distance);
  float DistanceToClosestHit(fitResult fR, int iS, int IE);
  float DistanceToClosestCentroid(fitResult fR, int iS, int IE);
  clusterContact_t   ContactLayers(ProtoCluster* PC, float distance);
  fitResult FitEnd(int nlayers);
  fitResult FitStart(int nlayers);
  fitResult FitLayers(int istart, int iend);
  fitResult FitPoints(const std::vector<vec4>& points);
  fitResult FitAllHits();
  fitResult MipFit(){return _mipFitResult;};
  fitResult FitPointsEndCap(const std::vector<vec4> & points, int endcap);
  float MipFraction();
  float MipFraction(int startLayer, int endLayer);
  void ClassifyYourself();
  void SoftPhotonID();
  void PhotonProfileID(bool truncate=false);
  float FractionInTrackCone(MyTrackExtended* track, float coneCosineHalfAngle);
  float FractionInCone(ProtoCluster*, float coneCosineHalfAngle);
  float FractionInRadialCone(ProtoCluster*, float coneCosineHalfAngle);
  ProtoCluster* FragmentMip();
  ProtoCluster* FragmentPhoton();
  ProtoCluster* AgressiveFragmentPhoton();
  void SetPurity(float f){_purity=f;};
  void SetCompleteness(float f){_completeness=f;};
  void SetBadness(int i){_badness=i;};

  void MCEMFraction(float f){_fracPhoton=f;};
  void MCNeutralFraction(float f){_fracNeutral=f;};
  void MCChargedFraction(float f){_fracCharged=f;};
  float MCEMFraction(){return _fracPhoton;};
  float MCNeutralFraction(){return _fracNeutral;};
  float MCChargedFraction(){return _fracCharged;};
  float GetPurity(){return _purity;};
  float GetCompleteness(){return _completeness;};
  float GetLongProfileShowerStart(){return _photonLongShowerStart;};
  float GetLongProfileGammaFraction(){return _photonLongProfileFraction;};
  int   GetBadness(){return _badness;};
  void SetClusterClassification(ProtoClusterClassificationType classific){_clusterClassification=classific;};
  void SetCluster(ClusterImpl* cluster){_cluster=cluster;};
  ClusterImpl* GetCluster(){return _cluster;};
  void SetPhotonIDCuts(float c){_photonID_dcoscut=c;};
protected:

private:

  std::vector<MyCaloHitExtended*>_hits;
  std::vector<MyCaloHitExtended*>_isolatedHits;
  std::vector<ProtoCluster*>_daughters;
  std::vector<ProtoCluster*>_parents;
  std::vector<MyCaloHitExtended*>_hitsByPseudoLayer[MAX_NUMBER_OF_LAYERS];
  std::vector<MyCaloHitExtended*>_mipHitsByPseudoLayer[MAX_NUMBER_OF_LAYERS];
  std::vector<MyCaloHitExtended*>_isolatedHitsByPseudoLayer[MAX_NUMBER_OF_LAYERS];
  float _centroidX[MAX_NUMBER_OF_LAYERS];
  float _centroidY[MAX_NUMBER_OF_LAYERS];
  float _centroidZ[MAX_NUMBER_OF_LAYERS];
  float _energy[MAX_NUMBER_OF_LAYERS];
  int   _nOnTrackPath[MAX_NUMBER_OF_LAYERS];
  float _initialDir[3];
  float _currentDir[3];
  float _centroid[3];
  int   _firstLayer;
  int   _lastLayer;
  int   _hitLayers;
  int   _showerLayer;
  int   _nHits;
  int   _nMips;
  float _bestEnergy;
  float _energyBarrel;
  float _energyEndcap;
  float _energyInMips;
  float _energyEM;
  float _energyHAD;
  float _dCosR;
  float _clusterRms;
  float _mipFraction;
  float _showerMax;
  float _showerLength;
  bool  _connected;
  bool  _stillGrowing;
  bool  _trackSeeded;
  bool  _currentDirectionOK;
  bool  _mip;
  int   _badness;
  float _completeness;
  float _purity;  
  float _uR[3];
  int   _ID;
  int   _earliestRelationID;
  ProtoCluster* _earliestRelation;
  fitResult _mipFitResult;
  ProtoClusterClassificationType _clusterClassification;
  bool _defunct;
  bool _associatedTrack;
  bool _fixedPhoton;
  MyTrackExtendedVec _associatedTracks;
  MyMCPFOVec _associatedMCPFOs;
  float _zOfEndcap;
  float _zOfBarrel;
  // running sums
  float _sx; 
  float _sxe; 
  float _sye; 
  float _sze;
  float _se;

  float _sxe10; 
  float _sye10; 
  float _sze10;
  float _se10;

  float _sxe20; 
  float _sye20; 
  float _sze20;
  float _se20;

  float _sy; 
  float _sz; 
  float _sl; 
  float _sxl;
  float _syl;
  float _szl;
  float _sll;
  float _sxx;
  float _sxy;
  float _sxz;
  float _syy;
  float _syz;
  float _szz;
  int   _layer90;
  int   _layerMax;

  float _sumX[MAX_NUMBER_OF_LAYERS];
  float _sumY[MAX_NUMBER_OF_LAYERS];
  float _sumZ[MAX_NUMBER_OF_LAYERS];
  float _dotUrUnorm[MAX_NUMBER_OF_LAYERS];
  float _absThicknessByPhysicalLayer[MAX_NUMBER_OF_LAYERS];
  float _calThicknessByPhysicalLayer[MAX_NUMBER_OF_LAYERS];
  int   _nEcalLayers;

  float _tanConeAngleECAL;
  float _tanConeAngleHCAL;
  float _additionalPadsECAL;
  float _additionalPadsHCAL;
  float _sameLayerPadCutECAL;
  float _sameLayerPadCutHCAL;
  float _maximumDistanceForConeAssociationECAL;
  float _maximumDistanceForConeAssociationHCAL;
  int   _trackingWeight;
  int   _trackingCutOff;
  float _trackingTube;
  float _fracPhoton;
  float _fracNeutral;
  float _fracCharged;
  ClusterImpl* _cluster;
  float _photonID_dcoscut; 
  int   _sectorCount[NUMBER_OF_SECTORS];
  float _photonLongProfileFraction;
  float _photonLongShowerStart;
  bool  _temporaryReclusteringAttempt;
  bool  _hotHadron;
  bool  _electronID;
  int   _errorType;

};

#endif