//ROOT includes
#include <TFile.h>
#include <TLorentzVector.h>
#include <TStopwatch.h>
#include <TGeoShape.h>
#include <TGeoMatrix.h>
#include <TGeoTube.h>
#include <TEveGeoShape.h>
#include <TEveStraightLineSet.h>
//std-lib
#include <iostream>

//collaborating classes
#include "MatchingTuple.h"
#include "TpcdEdx.h"
#include "FopiPidHub.h"
#include "FopiPidInfo.h"

//FOPI2ROOT
#include "CdcTrack.h"
#include "RpcTrack.h"
#include "BarrelTrack.h"
//Genfit
//#include <GFRaveConverters.h>
//#include <GFRaveTrackParameters.h>
//#include <GFRaveVertex.h>
//#include <GFRaveVertexFactory.h>
//#include <GFException.h>
#include <GFTrack.h>
#include <GFAbsTrackRep.h>

#include <GFTrack.h>
#include <GFAbsTrackRep.h>
#include <RKTrackRep.h>
#include "TpcSPHit.h"
#include "CdcSpacepoint.h"
//header
#include "SimpleEvDisplay.h"

SimpleEvDisplay::SimpleEvDisplay(TChain *chain_):
    fTpcTrackBranchName("TpcTrackPostFit"),
    fTpcSPHitBranchName("TpcSPHit"),
    fCdcTrackBranchName("CdcTrack"),
    fCdcGFTrackBranchName("CdcTrackPostFit"),
    fCdcHitBranchName("CdcSpacepoint"),
    fFopiTrackBranchName("FopiTrackPostFit"),
    fTrackTupleBranchName("FopiTrackTuples"),
    fVerbose(1),
    fOptions("")
    
{
    chain=chain_;

}


void SimpleEvDisplay::Init(){
    std::cout<<"SimpleEvDisplay::Init()"<<std::endl;
    
    fTpcTrackArray=new TClonesArray("GFTrack");
    fTpcSPHitArray=new TClonesArray("TpcSPHit");
    fCdcGFTrackArray=new TClonesArray("GFTrack");
    fCdcHitArray=new TClonesArray("CdcSpacepoint");
    fCdcTrackArray=new TClonesArray("CdcTrack");
    fFopiTrackArray=new TClonesArray("GFTrack");
    fTrackTupleArray=new TClonesArray("MatchingTuple");
    
    chain->SetBranchAddress(fTpcTrackBranchName,&fTpcTrackArray);
    chain->SetBranchAddress(fTpcSPHitBranchName,&fTpcSPHitArray);
    chain->SetBranchAddress(fCdcGFTrackBranchName,&fCdcGFTrackArray);
    chain->SetBranchAddress(fCdcHitBranchName,&fCdcHitArray);
    chain->SetBranchAddress(fCdcTrackBranchName,&fCdcTrackArray);
    chain->SetBranchAddress(fFopiTrackBranchName,&fFopiTrackArray);
    chain->SetBranchAddress(fTrackTupleBranchName, &fTrackTupleArray);
    
    fDisplay = GenfitDisplay::getInstance();
    fDisplay->setOptions(fOptions.Data());
}


void SimpleEvDisplay::Exec(){
   
    
    int nEntries= chain->GetEntries();
    
    for(int iEv=0;iEv<nEntries;++iEv){
        std::vector<GFTrack*> tracklist;
        std::vector<GFTrack*> tracklistComb;
        std::set<int> matchedTpcTracks;
        std::set<int> matchedCdcTracks;
        bool storeEvent=false;
        fTpcTrackArray->Delete();
        fCdcGFTrackArray->Delete();
        fFopiTrackArray->Delete();
        chain->GetEvent(iEv);
        //fTpcSPHitArray->Print();
        
        int nMatchingTuples=fTrackTupleArray->GetEntriesFast();
        for(int iTuple=0;iTuple<nMatchingTuples;++iTuple){
            GFTrack* theTrack=(GFTrack*)fFopiTrackArray->At(iTuple);
            
            //theTrack->getCardinalRep()->getMom().Print();
            MatchingTuple* theTuple=(MatchingTuple*) fTrackTupleArray->At(iTuple);
            if((!storeEvent) and
                    theTuple->isMatched() and 
                    theTrack->getCardinalRep()->getStatusFlag()==0 and
                    theTrack->getCardinalRep()->getMom().Perp()>0.7 and
                    theTrack->getCardinalRep()->getMom().Theta()*TMath::RadToDeg()>120 
                    ){
                storeEvent=true;
            }
            if(theTuple->isMatched()){
                if(theTuple->hasBranch(fCdcTrackBranchName)){
                    matchedCdcTracks.insert(theTuple->getIdFromBranch(fCdcTrackBranchName));
                }
                if(theTuple->hasBranch(fTpcTrackBranchName)){
                    matchedTpcTracks.insert(theTuple->getIdFromBranch(fTpcTrackBranchName));
                }
            }
                    
            
        }//end loop over matching tuples
        if(!storeEvent){
            continue;
        }
        
        int nTpcTracks= fTpcTrackArray->GetEntriesFast();
        for(unsigned iTr=0;iTr<nTpcTracks;++iTr){
            //need to add hits to the track again
            GFTrack* theTrack=(GFTrack*)fTpcTrackArray->At(iTr);
            GFTrackCand cand=theTrack->getCand();
            int nHits= cand.getNHits();
            std::vector<GFAbsRecoHit*> hits;
            for(int iHit=0;iHit<nHits;++iHit){
                GFTrackCandHit *hit=cand.getHit(iHit);
                //std::cout<<"hitId "<<hit->getHitId()<<"\n";
                GFAbsRecoHit* ahit=((GFAbsRecoHit*)fTpcSPHitArray->At(hit->getHitId()));
                if(ahit==NULL){
                    std::cout<<"nooooooooooooooooooooooo\n";
                }
                TVectorD a=ahit->getRawHitCoord();
              //  std::cout<<a[0]<<a[1]<<a[2]<<std::endl;
                hits.push_back(((TpcSPHit*)fTpcSPHitArray->At(hit->getHitId()))->clone());
            }
            //std::cout<<fTpcSPHitArray->GetEntries()<<", "<<hits.size()<<std::endl;
            theTrack->addHitVector(hits);
            if(matchedTpcTracks.count(iTr)!=0){
                tracklistComb.push_back(theTrack);
            }
            tracklist.push_back(theTrack);
        }
        
        int nCdcTracks= fCdcGFTrackArray->GetEntriesFast();
       // std::cout<<"nTpcTracks, "<<nTpcTracks<<", nCdcTracks, "<<nCdcTracks<<"\n";
        for(unsigned iTr=0;iTr<nCdcTracks;++iTr){
            //need to add hits to the track again
            GFTrack* theTrack=(GFTrack*)fCdcGFTrackArray->At(iTr);
            GFTrackCand cand=theTrack->getCand();
            int nHits= cand.getNHits();
            std::vector<GFAbsRecoHit*> hits;
            for(int iHit=0;iHit<nHits;++iHit){
                GFTrackCandHit *hit=cand.getHit(iHit);
                CdcSpacepoint* hita=(CdcSpacepoint*)fCdcHitArray->At(hit->getHitId());
                //hita->getRawHitCoord().Print();
                if(hita==0)
                    continue;
                hits.push_back(hita->clone());
            }
            //std::cout<<hits.size()<<std::endl;
            theTrack->addHitVector(hits);
            tracklist.push_back(theTrack);
            if(matchedCdcTracks.count(iTr)!=0){
                tracklistComb.push_back(theTrack);
            }
        }
        
        std::vector<TEveGeoShape*> shapes;
        std::vector<TEveStraightLineSet*> lines;
        int nCircles=0;
        if(fCdcTrackArray!=0){
            nCircles=fCdcTrackArray->GetEntriesFast();
        }
        for(unsigned int is=0; is<nCircles; is++) {
            CdcTrack* track = (CdcTrack*)fCdcTrackArray->At(is);
            double charge = track->GetCharge();
            double rad = std::fabs(track->GetRadius());
            double mx = track->GetMx();
            double my = track->GetMy();
            
            double theta = 0.5*TMath::Pi()-track->GetTheta();  //radians
            
            TString name("cdc_track");
            
            TEveStraightLineSet* lineset = new TEveStraightLineSet(name.Data());
            lineset->SetLineColor(kTeal+3);
            lineset->SetLineWidth(2.);
            //vector from circle center to origin:
            TVector3 start(mx,my,0.);
            double steplength = 0.4;  //
            double d_alpha = steplength/rad;
            
            double totrot = 0.;
            //pointing to the track points: 
            TVector3 target = -1.*start;
            target.SetMag(rad);
            target.SetZ(track->GetZ0());
            TVector3 target0 = target;    
            TVector3 pos = target+start; //real position on the track
            while(pos.Perp() < 100 && totrot < TMath::Pi()) {
                //todo: check for charge -> determine rotation sense
                TEveVector lastPoint(pos.X(),pos.Y(),pos.Z());
                //move to the next point:
                if(charge<0.)
                    target.RotateZ(d_alpha);
                else 
                    target.RotateZ(-d_alpha);
                
                double dz = steplength * TMath::Tan(theta);
                target.SetZ(target.Z() + dz);
                pos = target + start;
                totrot += d_alpha;
                
                TEveVector newPoint(pos.X(),pos.Y(),pos.Z());
                lineset->AddLine(lastPoint,newPoint);
            }
    //        std::cout<<"   adding CDC track around ("<<mx<<","<<my
    //                <<") with radius "<<rad<<"\n";
            lines.push_back(lineset);
            
            
            
        }//end loop over circles
        
        std::vector<TEveGeoShape*> shapes2;
        std::vector<TEveStraightLineSet*> lines2;
        if(storeEvent){
            std::cout<<"#########################################################################";
            std::cout<<"\nFopiDisplayTask: adding event "<<iEv<<"\n";
            std::cout<<"#########################################################################\n";
            fDisplay->addEvent(tracklist);
            fDisplay->addShapes(shapes);
            fDisplay->addLines(lines);
            fDisplay->addEvent(tracklistComb);
            fDisplay->addShapes(shapes2);
            fDisplay->addLines(lines2);    
        }
    }//end loop over events
}
ClassImp(SimpleEvDisplay)