//////////////////////////////////////////////////////////////////////////
//                                                                      //
// ATLFDisplay                                                          //
//                                                                      //
// Utility class to display ATLAS outline, tracks, clusters, jets,..    //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include <TROOT.h>
#include <TButton.h>
#include <TCanvas.h>
#include <TView.h>
#include <TArc.h>
#include <TText.h>
#include <TPaveLabel.h>
#include <TPaveText.h>
#include <TList.h>
#include <TDiamond.h>
#include <TNode.h>
#include <TTUBE.h>
#include <TMath.h>
#include <X3DBuffer.h>

#include "ATLFDisplay.h"
#include "ATLFFruit.h"
#include "ATLFParticle.h"
#include "ATLFast.h"
#include "ATLFMCMaker.h"
#include "ATLFClusterMaker.h"
#include "ATLFTriggerMaker.h"
#include "ATLFTrigger.h"

ClassImp(ATLFDisplay)


//_____________________________________________________________________________
 ATLFDisplay::ATLFDisplay() : ATLFVirtualDisplay()
{
   m_Particle  = 0;
   m_Fruits    = 0;
}

//_____________________________________________________________________________
 ATLFDisplay::ATLFDisplay(const char *title) : ATLFVirtualDisplay()
{

   gATLFast->SetDisplay(this);


   // Set front view by default
   m_Theta = 0;
   m_Phi   = -90;
   m_DrawAllViews  = kFALSE;
   m_DrawClusters  = kTRUE;
   m_DrawParticles = kTRUE;

   // Initialize display default parameters
   SetPTcut();
   SetPTcutEGMUNU();
   SetGeometry();

   // Create display canvas
   m_Canvas = new TCanvas("Canvas", (char*)title,14,47,740,650);
   m_Canvas->SetEditable(kIsNotEditable);

   // Create main display pad
   m_Pad = new TPad("viewpad", "ATLFast display",0.15,0,1,1);
   m_Pad->Draw();
   m_Pad->Modified();
   m_Pad->SetFillColor(1);
   m_Pad->SetBorderSize(2);

   // Create user interface control pad
   DisplayButtons();
   m_Canvas->cd();

   // Create trigger view pad
   Float_t dxtr = 0.15;
   Float_t dytr = 0.45;
   Float_t xt   = 0.3*dxtr;
   Float_t yt   = 0.8*dytr;
   Float_t dyt  = 0.07*dytr;
   Float_t xarc = 0.7*dxtr;
   Float_t rarc = 0.3*dyt;
   m_TrigPad = new TPad("TrigPad", "trigger pad",0,0,dxtr,dytr);
   m_TrigPad->Range(0,0,dxtr,dytr);
   m_TrigPad->Draw();
   m_TrigPad->cd();
   m_TrigPad->SetFillColor(22);
   m_TrigPad->SetBorderSize(2);

   TText *t = new TText();
   t->SetTextFont(61);
   t->SetTextSize(0.2);
   t->SetTextAlign(22);
   t->DrawText(0.5*dxtr, 0.93*dytr,"Trigger");
   t->SetTextSize(0.14);
   t->SetTextAlign(22);
   t->DrawText(xt,yt,      "EM1");
   t->DrawText(xt,yt-dyt,  "PH1");
   t->DrawText(xt,yt-2*dyt,"EM2");
   t->DrawText(xt,yt-3*dyt,"MU1");
   t->DrawText(xt,yt-4*dyt,"MU2");
   t->DrawText(xt,yt-5*dyt,"EMU");
   t->DrawText(xt,yt-6*dyt,"JT1");
   t->DrawText(xt,yt-7*dyt,"JT2");
   t->DrawText(xt,yt-8*dyt,"JT3");
   t->DrawText(xt,yt-9*dyt,"ALL");
   m_EM1 = new TArc(xarc,yt,      rarc); m_EM1->Draw();
   m_PH1 = new TArc(xarc,yt-dyt,  rarc); m_PH1->Draw();
   m_EM2 = new TArc(xarc,yt-2*dyt,rarc); m_EM2->Draw();
   m_MU1 = new TArc(xarc,yt-3*dyt,rarc); m_MU1->Draw();
   m_MU2 = new TArc(xarc,yt-4*dyt,rarc); m_MU2->Draw();
   m_EMU = new TArc(xarc,yt-5*dyt,rarc); m_EMU->Draw();
   m_JT1 = new TArc(xarc,yt-6*dyt,rarc); m_JT1->Draw();
   m_JT3 = new TArc(xarc,yt-7*dyt,rarc); m_JT3->Draw();
   m_JT4 = new TArc(xarc,yt-8*dyt,rarc); m_JT4->Draw();
   m_ALL = new TArc(xarc,yt-9*dyt,rarc); m_ALL->Draw();
   AppendPad(); // append display object as last object to force selection

   m_Tubin = new TTUBE("tubin","inner tube"," ", m_Rin, m_Rin+5, m_Zin);
   m_Nodin = new TNode("nodin","ATLAS outline","tubin",0,0,0," ");
   m_Nodin->SetLineColor(7);
         

   // Create list to support list of fruits
   m_Fruits = new TList();

   // Create particle manager
   m_Particle = new ATLFParticle("particle_manager");

   m_Canvas->cd();
   m_Canvas->Update();

}


//_____________________________________________________________________________
 ATLFDisplay::~ATLFDisplay()
{
   delete m_Particle;
   if (m_Fruits) m_Fruits->Delete();
   delete m_Fruits;
}

//_____________________________________________________________________________
 void ATLFDisplay::Clear(Option_t *)
{
//    Delete graphics temporary objects

   m_Fruits->Delete();

}

//_____________________________________________________________________________
 void ATLFDisplay::DisplayButtons()
{
//    Create the user interface buttons

   m_Buttons = new TPad("buttons", "newpad",0,0.45,0.15,1);
   m_Buttons->Draw();
   m_Buttons->SetFillColor(38);
   m_Buttons->SetBorderSize(2);
   m_Buttons->cd();

   Int_t butcolor = 33;
   Float_t dbutton = 0.08;
   Float_t y  = 0.96;
   Float_t dy = 0.014;
   Float_t x0 = 0.05;
   Float_t x1 = 0.95;

   TButton *button;
   char *but1 = "gATLFast->Display()->ShowNextEvent(1)";
   button = new TButton("Next",but1,x0,y-dbutton,x1,y);
   button->SetFillColor(38);
   button->Draw();

   y -= dbutton +dy;
   char *but2 = "gATLFast->Display()->ShowNextEvent(-1)";
   button = new TButton("Previous",but2,x0,y-dbutton,x1,y);
   button->SetFillColor(38);
   button->Draw();

   y -= dbutton +dy;
   char *but3 = "gATLFast->Display()->SetView(90,-90)";
   button = new TButton("Top View",but3,x0,y-dbutton,x1,y);
   button->SetFillColor(butcolor);
   button->Draw();

   y -= dbutton +dy;
   char *but4 = "gATLFast->Display()->SetView(90,0)";
   button = new TButton("Side View",but4,x0,y-dbutton,x1,y);
   button->SetFillColor(butcolor);
   button->Draw();

   y -= dbutton +dy;
   char *but5 = "gATLFast->Display()->SetView(0,-90)";
   button = new TButton("Front View",but5,x0,y-dbutton,x1,y);
   button->SetFillColor(butcolor);
   button->Draw();

   y -= dbutton +dy;
   char *but6 = "gATLFast->Display()->DrawAllViews()";
   button = new TButton("All Views",but6,x0,y-dbutton,x1,y);
   button->SetFillColor(butcolor);
   button->Draw();

   y -= dbutton +dy;
   char *but7 = "gATLFast->Display()->DrawViewGL()";
   button = new TButton("OpenGL",but7,x0,y-dbutton,x1,y);
   button->SetFillColor(38);
   button->Draw();

   y -= dbutton +dy;
   char *but8 = "gATLFast->Display()->DrawViewX3D()";
   button = new TButton("X3D",but8,x0,y-dbutton,x1,y);
   button->SetFillColor(38);
   button->Draw();

   // display logo
   TDiamond *diamond = new TDiamond(0.05,0.015,0.95,0.22);
   diamond->SetFillColor(50);
   diamond->SetTextAlign(22);
   diamond->SetTextColor(5);
   diamond->SetTextSize(0.11);
   diamond->Draw();
   diamond->AddText(".. ");
   diamond->AddText("ROOT");
   diamond->AddText("ATLFAST");
   diamond->AddText("... ");
   diamond->AddText(" ");
}

//_____________________________________________________________________________
 void ATLFDisplay::DisplayTrigger(ATLFTrigger *trig)
{
//    Display trigger parameters for current event

   if (trig->EM1()) m_EM1->SetFillColor(kGreen); else m_EM1->SetFillColor(kRed);
   if (trig->PH1()) m_PH1->SetFillColor(kGreen); else m_PH1->SetFillColor(kRed);
   if (trig->EM2()) m_EM2->SetFillColor(kGreen); else m_EM2->SetFillColor(kRed);
   if (trig->MU1()) m_MU1->SetFillColor(kGreen); else m_MU1->SetFillColor(kRed);
   if (trig->MU2()) m_MU2->SetFillColor(kGreen); else m_MU2->SetFillColor(kRed);
   if (trig->EMU()) m_EMU->SetFillColor(kGreen); else m_EMU->SetFillColor(kRed);
   if (trig->JT1()) m_JT1->SetFillColor(kGreen); else m_JT1->SetFillColor(kRed);
   if (trig->JT3()) m_JT3->SetFillColor(kGreen); else m_JT3->SetFillColor(kRed);
   if (trig->JT4()) m_JT4->SetFillColor(kGreen); else m_JT4->SetFillColor(kRed);
   if (trig->ALL()) m_ALL->SetFillColor(kGreen); else m_ALL->SetFillColor(kRed);
   m_TrigPad->Modified();
}

//______________________________________________________________________________
 Int_t ATLFDisplay::DistancetoPrimitive(Int_t px, Int_t py)
{
// Compute distance from point px,py to objects in event

   if (gPad == m_TrigPad) {gPad->SetCursor(kCross); return 0;}

   const Int_t big = 9999;
   Int_t dist = big;
   Float_t xmin = gPad->GetX1();
   Float_t xmax = gPad->GetX2();
   Float_t dx   = 0.05*(xmax - xmin);
   Float_t x    = gPad->AbsPixeltoX(px);
   if (x < xmin+dx || x > xmax-dx) return dist;

    // scan list of particles
   dist = m_Particle->DistancetoPrimitive(px, py);
   if (dist <= 0) return 0;

    // scan list of fruits
   TIter nextf(m_Fruits);
   ATLFFruit *fruit;
   while((fruit=(ATLFFruit*)nextf())) {
      dist = fruit->DistancetoPrimitive(px, py);
      if (dist < 5) {
         gPad->SetSelected(fruit->Fruit());
         gPad->SetCursor(kCross);
         return 0;
      }
   }

    // scan list of detectors (currently only one tube)
   dist = m_Nodin->DistancetoPrimitive(px, py);
   if (gPad->GetCanvas()->GetSelected() == gPad->GetView()) {
      gPad->SetSelected(this);
   }
   return 0;
}

//_____________________________________________________________________________
 void ATLFDisplay::Draw(Option_t *)
{
//    Insert current event in graphics pad list

   if (m_DrawAllViews) {
      DrawAllViews();
      return;
   }

   m_Pad->cd();

   DrawView(m_Theta, m_Phi);

   // Display the event number and title
   m_Pad->cd();
   DrawTitle();
}

//_____________________________________________________________________________
 void ATLFDisplay::DrawAllViews()
{
//    Draw front,top,side and 30 deg views

   m_DrawAllViews = kTRUE;
   m_Pad->cd();
   m_Pad->SetFillColor(15);
   m_Pad->Clear();
   m_Pad->Divide(2,2);

   // draw 30 deg view
   m_Pad->cd(1);
   DrawView(30, 30);
   DrawTitle();

   // draw front view
   m_Pad->cd(2);
   DrawView(0, -90);
   DrawTitle("Front");

   // draw top view
   m_Pad->cd(3);
   DrawView(90, -90);
   DrawTitle("Top");

   // draw side view
   m_Pad->cd(4);
   DrawView(90, 0);
   DrawTitle("Side");

   m_Pad->cd(2);
}

//_____________________________________________________________________________
 void ATLFDisplay::DrawTitle(Option_t *option)
{
//    Draw the event title

   Float_t xmin = gPad->GetX1();
   Float_t xmax = gPad->GetX2();
   Float_t ymin = gPad->GetY1();
   Float_t ymax = gPad->GetY2();
   Float_t dx   = xmax-xmin;
   Float_t dy   = ymax-ymin;
   if (strlen(option) == 0) {
      TPaveText *title = new TPaveText(xmin +0.01*dx, ymax-0.09*dy, xmin +0.5*dx, ymax-0.01*dy);
      title->SetBit(kCanDelete);
      title->SetFillColor(42);
      title->Draw();
      char ptitle[100];
      sprintf(ptitle,"Pythia event: %d, Run:%d",gATLFast->Event(), gATLFast->Run());
      title->AddText(ptitle);
      sprintf(ptitle,"Pythia Mode: %s",gATLFast->MCMaker()->GetTitle());
      title->AddText(ptitle);
   } else {
      TPaveLabel *label = new TPaveLabel(xmin +0.01*dx, ymax-0.07*dy, xmin +0.2*dx, ymax-0.01*dy,option);
      label->SetBit(kCanDelete);
      label->SetFillColor(42);
      label->Draw();
   }
}

//_____________________________________________________________________________
 void ATLFDisplay::DrawView(Float_t theta, Float_t phi)
{
//    Draw a view of ATLAS

   gPad->SetFillColor(1);
   // Display ATLAS outline
   gPad->Clear();

   Int_t iret;
   TView *view = new TView(1);
   view->SetRange(-m_Rin, -m_Rin, -m_Zin, m_Rin, m_Rin, m_Zin);

   m_Nodin->Draw("same");

    // add itself to the list
   AppendPad();
   
   //Loop on all makers to add their products to the pad
   TIter next(gATLFast->Makers());
   ATLFMaker *maker;
   while ((maker = (ATLFMaker*)next())) {
      maker->Draw();
   }
   view->SetView(phi, theta, 0, iret);
}

//_____________________________________________________________________________
 void ATLFDisplay::DrawViewGL()
{
//    Draw current view using OPENGL

   TPad *pad = (TPad*)gPad->GetPadSave();
   pad->cd();
   TView *view = pad->GetView();
   if (!view) return;
   pad->x3d("OPENGL");
}

//_____________________________________________________________________________
 void ATLFDisplay::DrawViewX3D()
{
//    Draw current view using X3D

   TPad *pad = (TPad*)gPad->GetPadSave();
   pad->cd();
   TView *view = pad->GetView();
   if (!view) return;
   pad->x3d();
}

//______________________________________________________________________________
 void ATLFDisplay::ExecuteEvent(Int_t event, Int_t px, Int_t py)
{
//*-*-*-*-*-*-*-*-*-*-*Execute action corresponding to one event*-*-*-*
//*-*                  =========================================

   if (gPad->GetView()) {
      gPad->GetView()->ExecuteRotateView(event, px, py);
   }
}

//_____________________________________________________________________________
 void ATLFDisplay::GetEvent(Int_t event)
{
//    Read event in memory

   gATLFast->GetEvent(event);

   Draw();
}

//_____________________________________________________________________________
 void ATLFDisplay::Paint(Option_t *)
{
//    Paint miscellaneous items

}

//_____________________________________________________________________________
 void ATLFDisplay::PaintFruit(TObject *obj, Float_t eta, Float_t phi, Float_t
pt, Int_t type, Option_t *option)
{
//    Display fruit from obj

   ATLFFruit *fruit = new ATLFFruit(obj, eta, phi, pt, type);
   m_Fruits->Add(fruit);
   fruit->Paint(option);
}

//_____________________________________________________________________________
 void ATLFDisplay::PaintParticles(Option_t *option)
{
   if (m_DrawParticles) m_Particle->Paint(option);
}

//_____________________________________________________________________________
 void ATLFDisplay::SetGeometry(Float_t rin)
{
//  Set ATLAS in/out outline parameters

   m_Rin  = rin;
   m_Rout = 1.2*rin;
   m_Zin  = 600;
   m_Zout = 680;
}

//_____________________________________________________________________________
 void ATLFDisplay::SetPTcut(Float_t ptcut)
{
   m_PTcut = ptcut;

   if (m_DrawAllViews) {
      m_Pad->cd(1); gPad->Modified();
      m_Pad->cd(2); gPad->Modified();
      m_Pad->cd(3); gPad->Modified();
      m_Pad->cd(4); gPad->Modified();
      m_Pad->cd();
   }
}

//_____________________________________________________________________________
 void ATLFDisplay::SetPTcutEGMUNU(Float_t ptcut)
{
   m_PTcutEGMUNU = ptcut;

   if (m_DrawAllViews) {
      m_Pad->cd(1); gPad->Modified();
      m_Pad->cd(2); gPad->Modified();
      m_Pad->cd(3); gPad->Modified();
      m_Pad->cd(4); gPad->Modified();
      m_Pad->cd();
   }
}

//_____________________________________________________________________________
 void ATLFDisplay::SetView(Float_t theta, Float_t phi)
{
//  change viewing angles for current event

   m_Pad->cd();
   m_DrawAllViews = kFALSE;
   m_Phi   = phi;
   m_Theta = theta;
   Int_t iret;

   TView *view = gPad->GetView();
   if (view) view->SetView(m_Phi, m_Theta, 0, iret);
   else      Draw();

   gPad->Modified();
}

//_____________________________________________________________________________
 void ATLFDisplay::ShowNextEvent(Int_t delta)
{
//  Display (current event_number+delta)
//    delta =  1  shown next event
//    delta = -1 show previous event

  if (delta) {
     gATLFast->Clear();
     Int_t current_event = gATLFast->Event();
     Int_t new_event     = current_event + delta;
     gATLFast->GetEvent(new_event); 
   }
  m_Pad->cd(); 
  Draw();
}

//______________________________________________________________________________
 void ATLFDisplay::SizeFruit() const
{
   const Int_t npoints = 2;
   gSize3D.numPoints += npoints;
   gSize3D.numSegs   += (npoints-1);
   gSize3D.numPolys  += 0;
}

//______________________________________________________________________________
 void ATLFDisplay::SizeParticles() const
{
   if (m_DrawParticles)  m_Particle->SizeParticles();
}