#include "CXLevelSchemePlayer.h"

#include <iostream>
#include <iomanip>
#include <vector>

#include "TH1F.h"
#include "TArrow.h"
#include "TLatex.h"
#include "TPad.h"
#include "TGToolTip.h"
#include "TBox.h"
#include "TROOT.h"
#include "KeySymbols.h"
#include "TFile.h"
#include "TObjArray.h"
#include "TMath.h"
#include "TCutG.h"

#include "GammaLink.h"
#include "Link.h"
#include "NuclearLevel.h"
#include "Spin.h"
#include "Measure.h"
#include "LevelScheme.h"
#include "BaseLSPlayer.h"
#include "GLSPlayer.h"
#include "TSystemDirectory.h"

#include "CXCanvas.h"
#include "CXMainWindow.h"
#include "CXGuiLSPlayer.h"

using namespace std;

typedef std::vector<Float_t> Float_vec_t;

CXLevelSchemePlayer::CXLevelSchemePlayer(const char* name, const char *title) :
    TNamed(name,title),
    fCanReplot(true)
{
    Color_t c[12] = {kBlue-6, kCyan-6, kGreen-6, kYellow-6 , kRed-6, kMagenta-6, kAzure, kTeal, kSpring, kOrange, kPink, kViolet};
    for(int i=0 ; i<48 ; i++) fColorWheel[i] = c[i%12] - (int)i/12;
    fCurrentColor = fColorWheel[0];

    fBashColor = new CXBashColor;

    fListOfDatabase = new TList;
    fListOfDatabase->SetOwner();

    fExpDataDir = Form("%s/DataBase/LevelScheme/EXP_DATA/",getenv("GWSYS"));
    fENSDFDataDir = Form("%s/DataBase/LevelScheme/ENSDF/",getenv("GWSYS"));

    gSystem->mkdir(fExpDataDir.Data(),kTRUE);
    gSystem->mkdir(fENSDFDataDir.Data(),kTRUE);

    TSystemDirectory dir(fENSDFDataDir,fENSDFDataDir);
    if(dir.GetListOfFiles() == nullptr || dir.GetListOfFiles()->GetEntries()<=2 ){
        TString temp = Form("%s/DataBase/LevelScheme/README",getenv("GWSYS"));
        fBashColor->InfoMessage(Form("No ENSDF data found in %s, follow the procedure explained in %s to download the data from the ENSDF web site",fENSDFDataDir.Data(),temp.Data()));
    }

    fListOfArrows = new TList;
    fListOfArrows->SetOwner();

    fListOfLatex = new TList;
    fListOfLatex->SetOwner();

    fListOfBoxes = new TList;
    fListOfBoxes->SetOwner();

    fListOfCXArrows = new TList;
    fListOfCXArrows->SetOwner();
}

CXLevelSchemePlayer::~CXLevelSchemePlayer()
{
    delete fListOfDatabase;
}

void CXLevelSchemePlayer::ConnectCanvas()
{
    //    TList *l = fMainWindow->GetCanvas()->GetListOfSignals();
    //    if(l==nullptr || l->FindObject("ProcessedEventLevelScheme(int,int,int,TObject*)") == nullptr)
    fMainWindow->GetCanvas()->Connect("ProcessedEvent(Int_t, Int_t, Int_t, TObject*)","CXLevelSchemePlayer", this, "ProcessedEventLevelScheme(Int_t, Int_t, Int_t, TObject*)");
}

void CXLevelSchemePlayer::CleanArrows()
{
    gPad = fMainWindow->GetSelectedPad();

    if(gPad == nullptr) return;

    for(int i=0 ; i<fListOfArrows->GetEntries() ; i++) {
        if(gPad->GetListOfPrimitives()->FindObject(fListOfArrows->At(i))) {
            gPad->GetListOfPrimitives()->Remove(fListOfArrows->At(i));
            fListOfArrows->RemoveAt(i);
            gPad->GetListOfPrimitives()->Remove(fListOfLatex->At(i));
            fListOfLatex->RemoveAt(i);
            gPad->GetListOfPrimitives()->Remove(fListOfBoxes->At(i));
            fListOfBoxes->RemoveAt(i);
            i--;
        }
    }
}

LevelScheme *CXLevelSchemePlayer::DrawArrows(TString ListOfNuclei,TH1 *h, TString DataSet)
{
    LevelScheme *RefLevel = nullptr;

    if(fMainWindow->GetCanvas() == nullptr)
        fBashColor->InfoMessage("Oops, current canvas not found...");

    gPad = fMainWindow->GetSelectedPad();

    ConnectCanvas();

    fCanReplot = false;

    fGuiLSPlayer->GetBranchingRatio(fMinStrenght,fMaxStrenght);
    fGuiLSPlayer->GetELevels(fMinELevel,fMaxELevel);
    fGuiLSPlayer->GetSpins(fMinSpin,fMaxSpin);
    fGuiLSPlayer->GetLifeTime(fMinLifeTime,fMaxLifeTime);

    fCurrentHist = h;

    fCurrentHist->GetYaxis()->UnZoom();

    gPad->Update();
    gPad->Modified();

    Int_t IColor = 0;

    fCurrentColor = fColorWheel[IColor];

    fLevelDraw = false;

    TObjArray *arr = ListOfNuclei.Tokenize(" ");
    for(int i=0 ; i<arr->GetEntries() ; i++) {
        TString Nuc = arr->At(i)->GetName();

        fCurrentColor = fColorWheel[IColor];
        IColor++;

        LevelScheme *levtest = DrawArrowsForNuc(Nuc,DataSet);
        if(RefLevel == nullptr) RefLevel = levtest;
    }
    delete arr;

    if(fLevelDraw) {
        if(fGuiLSPlayer->IsFullTitleMode())
            fCurrentHist->SetMaximum(fCurrentHist->GetMaximum()*1.45);
        else
            fCurrentHist->SetMaximum(fCurrentHist->GetMaximum()*1.25);

        gPad->Update();
        gPad->Modified();

        Float_t YMax = 0;

        Float_t PadMax = gPad->GetUymax();
        if(gPad->GetLogy())
            PadMax = TMath::Power(10,gPad->GetUymax());

        while(YMax>PadMax || YMax==0) {
            for(int i=0 ; i<fListOfLatex->GetEntries() ; i++) {
                TLatex *l = (TLatex*)fListOfLatex->At(i);
                if(gPad->GetListOfPrimitives()->FindObject(l) == nullptr) continue;
                Float_t Y = l->GetY()-(gPad->AbsPixeltoY(l->GetBBox().fY+l->GetBBox().fWidth)-gPad->AbsPixeltoY(l->GetBBox().fY));
                if(Y>YMax)
                    YMax = Y;
            }

            if(YMax>0.) fCurrentHist->SetMaximum(YMax*1.01);

            gPad->Update();
            gPad->Modified();

            for(int i=0 ; i<fListOfLatex->GetEntries() ; i++)
            {
                TLatex *l = (TLatex*)fListOfLatex->At(i);
                if(gPad->GetListOfPrimitives()->FindObject(l) == nullptr) continue;
                Float_t Y = l->GetY()-(gPad->AbsPixeltoY(l->GetBBox().fY+l->GetBBox().fWidth)-gPad->AbsPixeltoY(l->GetBBox().fY));
                if(Y>YMax)
                    YMax = Y;
            }

            PadMax = gPad->GetUymax();
            if(gPad->GetLogy())
                PadMax = TMath::Power(10,gPad->GetUymax());
        }

        if(YMax<fCurrentHist->GetBinContent(fCurrentHist->GetMaximumBin()))
            fCurrentHist->GetYaxis()->UnZoom();

        gPad->Update();
        gPad->Modified();
    }

    fCanReplot = true;

    return RefLevel;
}

LevelScheme *CXLevelSchemePlayer::DrawArrowsForNuc(TString NucName, TString DataSet)
{
    LevelScheme *RefLevel = nullptr;

    CXNucleus nuc(NucName);
    if(nuc.IsKnown() == false) return nullptr;

    ///ENSDF data
    if(fGuiLSPlayer->GetDataType()==1 || fGuiLSPlayer->GetDataType()==3) {
        LevelScheme *lev = (LevelScheme*)fListOfDatabase->FindObject(Form("%s_ENSDF_%s",NucName.Data(),DataSet.Data()));
        if(lev==nullptr) {
            lev = ImportENSDFData(nuc.GetSymbol(),false,DataSet);
            if(lev == nullptr) lev = new LevelScheme;
            lev->SetName(Form("%s_ENSDF_%s",NucName.Data(),DataSet.Data()));
            fListOfDatabase->Add(lev);
        }
        if(lev != nullptr && lev->GetLinks().GetEntries()>0) {
            if(fGuiLSPlayer->GetYrastMode())
                CalcYrast(lev);
            for(Int_t i=0 ; i<lev->GetLinks().GetSize() ; i++) {
                const GammaLink *gamma=(GammaLink*)lev->GetLinks().At(i);
                DrawArrow(fCurrentHist,gamma,nuc,"ENSDF");
            }
        }

        RefLevel = lev;
    }

    ///Experimental data
    if(fGuiLSPlayer->GetDataType()==2 || fGuiLSPlayer->GetDataType()==3) {
        LevelScheme *lev = (LevelScheme*)fListOfDatabase->FindObject(Form("%s",NucName.Data()));
        if(lev != nullptr) {
            fListOfDatabase->Remove(lev);
            delete lev;
        }

        lev = ImportExpData(nuc.GetSymbol());

        if(lev != nullptr) {
            lev->SetName(Form("%s",NucName.Data()));
            fListOfDatabase->Add(lev);

            if(fGuiLSPlayer->GetYrastMode())
                CalcYrast(lev);

            for(Int_t i=0 ; i<lev->GetLinks().GetSize() ; i++) {
                const GammaLink *gamma=(GammaLink*)lev->GetLinks().At(i);
                DrawArrow(fCurrentHist,gamma,nuc,"EXP");
            }
        }
        RefLevel = lev;
    }

    return RefLevel;
}

void CXLevelSchemePlayer::CalcYrast(LevelScheme *lev)
{
    fYrastEnergies.clear();

    for(Int_t i=0 ; i<lev->GetLinks().GetSize() ; i++)
    {
        const GammaLink *gamma=(GammaLink*)lev->GetLinks().At(i);

        Float_t ELev = ((Gw::NuclearLevel*)((GammaLink*)gamma)->GetIL())->GetEnergy().GetValue();
        Float_t spin = ((Gw::NuclearLevel*)((GammaLink*)gamma)->GetIL())->GetSpin().Get();

        if(fYrastEnergies[2*spin]==0 || ELev<fYrastEnergies[2*spin])
            if(spin>0)
                fYrastEnergies[2*spin] = ELev;
    }
}

void CXLevelSchemePlayer::DrawArrow(TH1 *hist, const GammaLink *gamma, CXNucleus Nuc, TString DataType)
{
    if(hist == nullptr)
        return;

    Float_t Energy = ((GammaLink*)gamma)->GetEnergy().GetValue();

    if(Energy < fCurrentHist->GetBinLowEdge(fCurrentHist->GetXaxis()->GetFirst()) || Energy > fCurrentHist->GetBinLowEdge(fCurrentHist->GetXaxis()->GetLast()))
        return;

    Float_t Strengh = ((GammaLink*)gamma)->GetStrength().GetValue();

    if( fGuiLSPlayer->UseBranchingRatio() && (Strengh<fMinStrenght || Strengh>fMaxStrenght))
        return;

    Float_t ELevI = ((Gw::NuclearLevel*)((GammaLink*)gamma)->GetIL())->GetEnergy().GetValue();
    Float_t ELevF = ((Gw::NuclearLevel*)((GammaLink*)gamma)->GetFL())->GetEnergy().GetValue();

    if(fGuiLSPlayer->UseELevels() && (ELevI<fMinELevel || ELevI>fMaxELevel))
        return;

    Float_t spinI = ((Gw::NuclearLevel*)((GammaLink*)gamma)->GetIL())->GetSpin().Get();
    Float_t spinF = ((Gw::NuclearLevel*)((GammaLink*)gamma)->GetFL())->GetSpin().Get();

    if(fGuiLSPlayer->UseSpins() && (spinI<fMinSpin || spinI>fMaxSpin))
        return;

    if(fGuiLSPlayer->GetYrastMode() && ELevI>fYrastEnergies[2*spinI])
        return;

    //    if(fGuiLSPlayer->GetYrastMode() && ELevF>fYrastEnergies[2*spinF])
    //        return;

    Float_t LifeTime = ((Gw::NuclearLevel*)((GammaLink*)gamma)->GetIL())->GetT().GetValue();

    if(fGuiLSPlayer->UseLifeTime() && (LifeTime<fMinLifeTime || LifeTime>fMaxLifeTime))
        return;

    Float_t MaxGlob = hist->GetMaximum();

    Int_t XMinbin = hist->GetXaxis()->GetFirst();
    Int_t XMaxbin = hist->GetXaxis()->GetLast();

    Int_t XMin = hist->GetBinLowEdge(XMinbin);
    Int_t XMax = hist->GetBinLowEdge(XMaxbin);

    hist->GetXaxis()->SetRangeUser(Energy-3,Energy+3);
    Float_t MaxLoc = hist->GetMaximum();
    hist->GetXaxis()->SetRange(XMinbin, XMaxbin);

    Int_t A = Nuc.GetA();

    TArrow *GammaArrow = new TArrow(Energy,(MaxLoc + MaxGlob/100.) ,Energy,(MaxLoc +MaxGlob/10.),0.005,"<|");

    GammaArrow->SetAngle(40);
    GammaArrow->SetLineColor(fCurrentColor);
    GammaArrow->SetFillColor(fCurrentColor);
    GammaArrow->SetLineWidth(1);

    if(DataType=="EXP")
    {
        GammaArrow->SetAngle(45);
        GammaArrow->SetArrowSize(0.02);
        GammaArrow->SetLineWidth(2);
    }
    else
    {
        GammaArrow->SetAngle(40);
        GammaArrow->SetArrowSize(0.01);
        GammaArrow->SetLineWidth(1);
    }
    GammaArrow->Draw();
    GammaArrow->SetBit(TObject::kCannotPick);

    fListOfArrows->Add(GammaArrow);

    TBox *box; box = new TBox();
    box->SetX1(Energy-(XMax-XMin)/300.);
    box->SetX2(Energy+(XMax-XMin)/300.);
    box->SetY1(MaxLoc +1.2*MaxGlob/10.);
    box->SetY2(MaxLoc +2.6*MaxGlob/10.);
    if(fGuiLSPlayer->IsFullTitleMode())
        box->SetY2(MaxLoc +4.0*MaxGlob/10.);
    box->SetFillStyle(0);
    box->SetFillColor(0);
    box->SetLineWidth(0);
    box->SetLineColor(0);
    box->SetLineStyle(3);

    TString GammaTitle=Form("^{%d}%s : %0.1f",A,Nuc.GetSymbol("EL").Data(),Energy);
    if(DataType=="EXP") GammaTitle.Append(" => Exp data");

    TString ToolTip;

    ToolTip.Append(Form("%s : %0.1f keV",Nuc.GetSymbol().Data(),Energy));

    ///Bug sur la multipolarite pour le moment
    //    TString Multipolority = ((GammaLink*)gamma)->GetAttr1();

    //    if(Multipolority != "") ToolTip.Append(Form(" %s",Multipolority.Data()));

    //    Float_t Mixing = ((GammaLink*)gamma)->GetMixing().GetValue();
    //    if(Multipolority != "" && Mixing!=0) ToolTip.Append(Form("(%.1f)",Mixing));

    ToolTip.Append(" ==> ");

    Bool_t AdvancedTitle = fGuiLSPlayer->IsFullTitleMode();

    TString SIL = GetSpinFromLev(((Gw::NuclearLevel*)((GammaLink*)gamma)->GetIL()));
    TString ILE = Form("%.1f",ELevI);

    ToolTip.Append(Form("%s (%s keV)",SIL.Data(),ILE.Data()));
    if(AdvancedTitle) GammaTitle.Append(Form(" : %s",SIL.Data()));

    ToolTip.Append(" --> ");
    if(AdvancedTitle) GammaTitle.Append(" --> ");

    TString SFL = GetSpinFromLev(((Gw::NuclearLevel*)((GammaLink*)gamma)->GetFL()));
    TString FLE = Form("%.1f",ELevF);

    ToolTip.Append(Form("%s (%s keV)",SFL.Data(),FLE.Data()));
    if(AdvancedTitle) GammaTitle.Append(Form(" : %s",SFL.Data()));

    ToolTip.Append(Form(" ; I=%.1f",((GammaLink*)gamma)->GetStrength().GetValue()));

    if(LifeTime != 0) {
        TString LifeTimeText;

        if(LifeTime<1e-12)
            LifeTimeText = Form(" ; T1/2 = %.1f fs",LifeTime*1e15);
        if(LifeTime>1e-12 && LifeTime<1e-9)
            LifeTimeText = Form(" ; T1/2 = %.1f ps",LifeTime*1e12);
        if(LifeTime>1e-9 && LifeTime<1e-6)
            LifeTimeText = Form(" ; T1/2 = %.1f ns",LifeTime*1e9);
        if(LifeTime>1e-6 && LifeTime<1e-3)
            LifeTimeText = Form(" ; T1/2 = %.1f us",LifeTime*1e6);
        if(LifeTime>1e-3 && LifeTime<1e-0)
            LifeTimeText = Form(" ; T1/2 = %.1f ms",LifeTime*1e3);
        if(LifeTime>1e-0)
            LifeTimeText = Form(" ; T1/2 = %.1f s",LifeTime);

        ToolTip.Append(LifeTimeText);
        if(AdvancedTitle) GammaTitle.Append(LifeTimeText);
    }

    if(DataType=="EXP") ToolTip.Append(" ==> Exp data");

    TLatex *Latex = new TLatex(Energy,MaxLoc +1.2*MaxGlob/10.,GammaTitle);
    Latex->SetTextAngle(90);
    if(DataType=="EXP")
    {
        Latex->SetTextFont(22);
        Latex->SetTextSize(fGuiLSPlayer->GetTextSize());
    }
    else
    {
        Latex->SetTextFont(132);
        Latex->SetTextSize(fGuiLSPlayer->GetTextSize());
    }
    Latex->SetTextColor(fCurrentColor);
    Latex->SetBit(TObject::kCannotPick);
    Latex->Draw();
    fListOfLatex->Add(Latex);

    box->SetToolTipText(ToolTip.Data(),500);
    box->Draw();
    fListOfBoxes->Add(box);

    fLevelDraw = true;
}

LevelScheme *CXLevelSchemePlayer::ImportExpData(const char *NucSymbol)
{
    CXNucleus nuc(NucSymbol);

    TString FileName = Form("%s/%s.root",fExpDataDir.Data(),nuc.GetSymbol().Data());

    if(!gSystem->IsFileInIncludePath(FileName))
    {
        fBashColor->WarningMessage(Form("Experimental level Scheme for Nucleus %s not found in %s/",nuc.GetSymbol().Data(),fExpDataDir.Data()));
        return nullptr;
    }
    else
    {
        TFile *FileOut = new TFile(FileName);

        LevelScheme *lev = (LevelScheme*)FileOut->Get(nuc.GetSymbol().Data());
        return lev;
    }
}

LevelScheme *CXLevelSchemePlayer::ImportENSDFData(const char *NucSymbol, bool quietmode,TString dataset, bool graphical)
{
    TVirtualPad *tempPad = gPad;

    CXNucleus nuc(NucSymbol);
    TString ZMaj = ((TString)nuc.GetSymbol());
    ZMaj.ToUpper();
    if(dataset == "") dataset = "ADOPTED LEVELS, GAMMAS";
    ZMaj.Append(Form(" %s",dataset.Data()));

    if(quietmode) ZMaj.Append("NoVerbose");
    if(!graphical) ZMaj.Append("NoGraphical");

    TString FileName = fENSDFDataDir + "/" + ((TString)nuc.GetSymbol()) + ".ens";

    if(!gSystem->IsFileInIncludePath(FileName) && !quietmode) {
        fBashColor->WarningMessage(Form("ENSDF level Scheme for Nucleus %s not found in %s/",nuc.GetSymbol().Data(),fENSDFDataDir.Data()));
        return nullptr;
    }
    else {
        LevelScheme *lev =  new LevelScheme;
        TPad *p = new TPad();
        p->cd();
        lev->Import(FileName.Data(),ZMaj.Data());
        delete p;

        gPad = tempPad;

        //        if(lev->GetLinks().GetSize() == 0)
        //            return nullptr;
        //        else
        return lev;
    }
}

TString CXLevelSchemePlayer::PrintNucleusGammas(LevelScheme *lev, TString NucName, bool print)
{
    if(lev == nullptr) return "";

    TString Text="";

    if(print) {
        TString text = Form("** Gamma-rays transitions for nucleus %s **",NucName.Data());
        TString stars; for (int i=0 ; i<text.Length() ; i++) stars.Append("*");
        cout<<endl<<endl<<stars<<endl<<text<<endl<<stars<<endl<<endl;

        cout<<Form("    E Gamma :      Ji (    Ei    ) -->      Jf (     Ef   ) ( I %% )")<<endl;
        cout<<     "-------------------------------------------------------------------"<<endl;

        cout<<endl;
    }

    for(Int_t i=0 ; i<lev->GetLinks().GetSize() ; i++) {

        Gw::GammaLink *Link= (Gw::GammaLink*)lev->GetLinks().At(i);

        Float_t Energy = Link->GetEnergy().GetValue();

        NuclearLevel *NucLevI = (NuclearLevel*)Link->GetIL();
        NuclearLevel *NucLevF = (NuclearLevel*)Link->GetFL();

        Float_t Strengh = Link->GetStrength().GetValue();

        Float_t ELevI   = NucLevI->GetEnergy().GetValue();
        TString spinI_s = GetSpinFromLev(NucLevI);

        Float_t ELevF   = NucLevF->GetEnergy().GetValue();
        TString spinF_s = GetSpinFromLev(NucLevF);

        TString TransitionName = Form(" %6.1f keV : %7s (%6.1f keV) --> %7s (%6.1f keV) (%3.f %%) ",Energy,spinI_s.Data(),ELevI,spinF_s.Data(),ELevF,Strengh);

        if(print) cout<<TransitionName<<endl;
        Text += Form("!%-7g %-7s->%-7s",Energy,spinI_s.Data(),spinF_s.Data());

    }
    return Text;
}

TString CXLevelSchemePlayer::PrintNucleusGammas(Int_t Z, Int_t N, bool print)
{
    CXNucleus nuc(Z,Z+N);
    LevelScheme *lev = ImportENSDFData(nuc.GetSymbol());

    if(lev == nullptr) {
        cout<<Form("%s Level scheme not found",nuc.GetSymbol().Data())<<endl;
        return Form("%s Level scheme not found",nuc.GetSymbol().Data());
    }

    return PrintNucleusGammas(lev,nuc.GetSymbol(),print);
}

LevelScheme *CXLevelSchemePlayer::GetLevelScheme(TString Symb, bool print, TString dataset)
{
    LevelScheme *lev = ImportENSDFData(Symb,!print,dataset);
    return lev;
}

TString CXLevelSchemePlayer::PrintNucleusLevels(LevelScheme *lev, TString NucName, bool print)
{
    if(lev == nullptr) return "";

    TString Text="";

    if(print) {
        TString text = Form("** Levels info for nucleus %s **",NucName.Data());
        TString stars; for (int i=0 ; i<text.Length() ; i++) stars.Append("*");
        cout<<endl<<endl<<stars<<endl<<text<<endl<<stars<<endl<<endl;

        cout<<left<<setw(15)<<"Energy"<<setw(6)<<"Spin"<<setw(8)<<"T 1/2"<<endl;
        cout<<"--------------------------"<<endl<<endl;
    }
    for(Int_t i=0 ; i<lev->GetLevels().GetSize() ; i++) {
        NuclearLevel *NucLev = (NuclearLevel*)lev->GetLevels().At(i);
        Float_t ELev   = NucLev->GetEnergy().GetValue();
        TString spin = GetSpinFromLev(NucLev);
        Float_t LifeTime = NucLev->GetT().GetValue();

        TString LifeTimeText="";
        if(LifeTime >0.) {
            if(LifeTime<1e-12)
                LifeTimeText = Form("%.1f fs",LifeTime*1e15);
            if(LifeTime>1e-12 && LifeTime<1e-9)
                LifeTimeText = Form("%.1f ps",LifeTime*1e12);
            if(LifeTime>1e-9 && LifeTime<1e-6)
                LifeTimeText = Form("%.1f ns",LifeTime*1e9);
            if(LifeTime>1e-6 && LifeTime<1e-3)
                LifeTimeText = Form("%.1f us",LifeTime*1e6);
            if(LifeTime>1e-3 && LifeTime<1e-0)
                LifeTimeText = Form("%.1f ms",LifeTime*1e3);
            if(LifeTime>1e-0)
                LifeTimeText = Form("%.1f s",LifeTime);
            if(LifeTime>60)
                LifeTimeText = Form("%.1f min",LifeTime/60.);
            if(LifeTime>3600)
                LifeTimeText = Form("%.1f h",LifeTime/3600.);
            if(LifeTime>3600*12)
                LifeTimeText = Form("%.1f d",LifeTime/(3600.*12));
            if(LifeTime>3600*12*365)
                LifeTimeText = Form("%.1f years",LifeTime/(3600.*12*365));
            if(LifeTime>1e15)
                LifeTimeText = Form("STABLE");
        }
        if(print) cout<<left<<setw(15)<<ELev<<setw(6)<<spin<<setw(8)<<LifeTimeText<<endl;
        Text += Form("!%-7g %-7s %-10s",ELev,spin.Data(),LifeTimeText.Data());
    }
    return Text;
}

TString CXLevelSchemePlayer::PrintNucleusLevels(Int_t Z, Int_t N, bool print)
{
    CXNucleus nuc(Z,Z+N);
    LevelScheme *lev = ImportENSDFData(nuc.GetSymbol());

    if(lev == nullptr) {
        cout<<Form("%s Level scheme not found",nuc.GetSymbol().Data())<<endl;
        return Form("%s Level scheme not found",nuc.GetSymbol().Data());
    }

    return PrintNucleusLevels(lev,nuc.GetSymbol(),print);
}

void CXLevelSchemePlayer::PlotLevelScheme(TString NucName, TString Type, TString DataSet)
{
    LevelScheme *lev = nullptr;

    if(Type=="ENSDF")
        lev = ImportENSDFData(NucName,true,DataSet,false);
    else
        lev = ImportExpData(NucName);

    if(lev == nullptr) {
        cout<<Form("%s Level scheme for %s not found",Type.Data(), NucName.Data())<<endl;
        return;
    }

    fRangeXMin = 1e6;
    fRangeXMax = -1e6;

    if(fGuiLSPlayer->GetYrastMode())
        CalcYrast(lev);

    fGuiLSPlayer->GetBranchingRatio(fMinStrenght,fMaxStrenght);
    fGuiLSPlayer->GetELevels(fMinELevel,fMaxELevel);
    fGuiLSPlayer->GetSpins(fMinSpin,fMaxSpin);
    fGuiLSPlayer->GetLifeTime(fMinLifeTime,fMaxLifeTime);

    TCanvas *ctest = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("GLSPlayer");
    if(ctest != 0x0) ctest->Close();
    ctest = new TCanvas("GLSPlayer","GLSPlayer");
    ctest->cd();

    LevelScheme *LS_To_Plot = new LevelScheme;

    GLSPlayer *LSPlayer = (GLSPlayer*)LS_To_Plot->GetPlayer();

    CXNucleus Nuc(NucName);

    for(Int_t i=0 ; i<lev->GetLinks().GetSize() ; i++) {
        Gw::GammaLink *Link= (Gw::GammaLink*)lev->GetLinks().At(i);

        NuclearLevel *NucLevI = (NuclearLevel*)Link->GetIL();
        NuclearLevel *NucLevF = (NuclearLevel*)Link->GetFL();

        Float_t Strengh = Link->GetStrength().GetValue();
        Float_t ELevI   = NucLevI->GetEnergy().GetValue();
        TString spinI_s = GetSpinFromLev(NucLevI);
        Float_t spinI   = NucLevI->GetSpin().Get();
        Float_t ELevF   = NucLevF->GetEnergy().GetValue();
        TString spinF_s = GetSpinFromLev(NucLevF);
        Float_t LifeTimeI = NucLevI->GetT().GetValue();
        Float_t LifeTimeF = NucLevF->GetT().GetValue();
        TString LifeTimestrI = GetLTString(LifeTimeI);
        TString LifeTimestrF = GetLTString(LifeTimeF);

        if( fGuiLSPlayer->UseBranchingRatio() && (Strengh<fMinStrenght || Strengh>fMaxStrenght))
            continue;

        if(fGuiLSPlayer->UseELevels() && (ELevI<fMinELevel || ELevI>fMaxELevel))
            continue;

        if(fGuiLSPlayer->UseSpins() && (spinI<fMinSpin || spinI>fMaxSpin))
            continue;

        if(fGuiLSPlayer->GetYrastMode() && ELevI>fYrastEnergies[2*spinI])
            continue;

        //        if(fGuiLSPlayer->GetYrastMode() && ELevF>fYrastEnergies[2*spinF])
        //            continue;

        if(fGuiLSPlayer->UseLifeTime() && (LifeTimeI<fMinLifeTime || LifeTimeI>fMaxLifeTime))
            continue;

        NuclearLevel *NucLevel_F = GetLevel(NucLevF,LS_To_Plot);
        if(NucLevel_F == nullptr) {
            cout<<"tot "<< ELevF<<" "<<(TMath::Abs(ELevF)<0.001)<<endl;
            if(TMath::Abs(ELevF)<0.001){
                NucLevel_F = LSPlayer->AddGroundLevel(Nuc.GetZ(),Nuc.GetA(),spinF_s.Data());
                NucLevel_F->SetLabels(spinF_s.Data(),"",LifeTimestrF.Data(),Form("%g",ELevF));
            }
            else {
                NucLevel_F = LSPlayer->AddLevel(ELevF,0,spinF_s.Data());
                NucLevel_F->SetLabels(spinF_s.Data(),"",LifeTimestrF.Data(),Form("%g",ELevF));
            }
        }

        LS_To_Plot->SetCLevel(NucLevel_F);

        NuclearLevel *NucLevel_I = GetLevel(NucLevI,LS_To_Plot);
        if(NucLevel_I == nullptr) {
            NucLevel_I = LSPlayer->AddLevel(ELevI,0,spinI_s.Data());
            NucLevel_I->SetLabels(spinI_s.Data(),"",LifeTimestrI.Data(),Form("%g",ELevI));
        }

        LSPlayer->HandleMovement(kKeyPress,-666,kKey_s,NucLevel_I);
        LSPlayer->HandleMovement(kKeyPress,-666,kKey_s,NucLevel_F);

        DrawLink(LS_To_Plot,Link);
    }

    Float_t YMax=0;
    for(int i=0 ; i<LS_To_Plot->GetLevels().GetEntries() ; i++) {
        NuclearLevel *lev = (NuclearLevel*)LS_To_Plot->GetLevels().At(i);
        lev->SetVisLabel("1111");

        if(lev->GetEnergy().Get()>YMax)
            YMax = lev->GetEnergy().Get();

        lev->SetX1(fRangeXMin);
        lev->SetX2(fRangeXMax);

        lev->SetLineColor(kBlack);
        lev->SetLineWidth(1);
    }

    for(int i=0 ; i<LS_To_Plot->GetLinks().GetEntries() ; i++) {
        Link* link = (Link*)LS_To_Plot->GetLinks().At(i);

        link->RefreshPoints();
        link->Paint();
    }

//    LS_To_Plot->SetName("");
    LS_To_Plot->Draw();
    LSPlayer->GetLSAxis()->SetRange(0,YMax,fRangeXMin,fRangeXMax);

    ctest->SetName(Form("ENSDFLS_%s",NucName.Data()));
    ctest->SetTitle(Form("ENSDF level Scheme for nuc %s",NucName.Data()));

    gSystem->ProcessEvents();
    LSPlayer->RefreshLinks();
}

void CXLevelSchemePlayer::DrawLink(LevelScheme *ls, GammaLink *gammalink)
{
    Float_t energy = gammalink->GetEnergy().Get();
    Float_t strenght = gammalink->GetStrength().Get();

    //    cout<<"DrawLink "<<energy<<" "<<strenght<<" "<<GetSpinFromLev((NuclearLevel*)gammalink->GetIL())<<" -> "<<GetSpinFromLev((NuclearLevel*)gammalink->GetFL())<< endl;
    GLSPlayer *LSPlayer = (GLSPlayer*)ls->GetPlayer();
    LSPlayer->AddLink(strenght,0,energy);

    GammaLink *NewLink = (GammaLink*) ls->GetLinks().Last();
    if(fGuiLSPlayer->GetColorMode()) NewLink->SetArrowStyle(2);
    else NewLink->SetArrowStyle(1);

    if(ls->GetLinks().GetEntries()==1) {
        NewLink->RefreshPoints();
        NewLink->Paint();
    }

    Bool_t ok = false;

    while(ok==false) {
        Float_t xmin_new,xmax_new,ymin_new,ymax_new;
        GetLimits(NewLink,xmin_new,xmax_new,ymin_new,ymax_new);

        if(xmin_new<fRangeXMin) fRangeXMin = xmin_new;
        if(xmax_new>fRangeXMax) fRangeXMax = xmax_new;

        ok = true;

        for(Int_t i=0 ; i<ls->GetLinks().GetSize()-1 ; i++) {
            GammaLink *Link= (Gw::GammaLink*)ls->GetLinks().At(i);
            Float_t xmin,xmax,ymin,ymax;
            GetLimits(Link,xmin,xmax,ymin,ymax);

            if((ymin+0.5>ymax_new) || (ymax-0.5<ymin_new))
                continue;
            else if((xmax<xmin_new) || (xmin>xmax_new))
                continue;
            else {
                ShiftLink(NewLink,60);
                ok = false;
                break;
            }
        }
    }
}

void CXLevelSchemePlayer::GetLimits(GammaLink *link, Float_t &xmin,Float_t &xmax,Float_t &ymin,Float_t &ymax)
{
    xmin = link->GetX()[0];
    xmax = link->GetX()[0];
    ymin = link->GetY()[0];
    ymax = link->GetY()[0];

    for(int i=0 ; i<8 ; i++)
    {
        if(link->GetX()[i]<xmin) xmin = link->GetX()[i];
        if(link->GetX()[i]>xmax) xmax = link->GetX()[i];
        if(link->GetY()[i]<ymin) ymin = link->GetY()[i];
        if(link->GetY()[i]>ymax) ymax = link->GetY()[i];
    }
}

void CXLevelSchemePlayer::ShiftLink(GammaLink *link, Float_t XShift)
{
    for(int i=0 ; i<8 ; i++)
    {
        link->SetPoint(i,link->GetX()[i]+XShift,link->GetY()[i]);
    }
}

void CXLevelSchemePlayer::ResizeNucLev(NuclearLevel *nuclev,Float_t width)
{
    Float_t Center = nuclev->GetX1() + (nuclev->GetX2()-nuclev->GetX1())/2.;

    nuclev->SetX1(Center-width/2);
    nuclev->SetX2(Center+width/2);
}

NuclearLevel *CXLevelSchemePlayer::GetLevel(NuclearLevel *nuclev, LevelScheme *ls)
{
    Float_t ELevel = nuclev->GetEnergy().GetValue();

    ELevel = TMath::Nint(ELevel*10.)/10.;

    NuclearLevel *level = nullptr;

    for(Int_t i=0 ; i<ls->GetLevels().GetSize() ; i++) {
        level = (NuclearLevel*)ls->GetLevels().At(i);

        Float_t ELevel2 = level->GetEnergy().GetValue();

        if(level && TMath::Abs(ELevel2 - ELevel)<0.1 && (GetSpinFromLev(nuclev) == GetSpinFromLev(level)) )
            return level;
    }

    return nullptr;
}

TString CXLevelSchemePlayer::GetSpinFromLev(NuclearLevel *nuclev)
{
    Float_t spin = nuclev->GetSpin().Get();

    TString  PL = "+";
    if(nuclev->GetParity().IsParity(Gw::Parity::kMinus))
        PL = "-";

    TString SL = Form("%.1f",spin);

    TString Lev;

    if(SL.EndsWith(".5"))
        Lev = Form("%d/2%s",TMath::Nint(2*SL.Atof()),PL.Data());
    else
        Lev = Form("%d%s",SL.Atoi(),PL.Data());

    if(nuclev->GetSpin().IsData(InfoData::kUnknown))
        Lev="?";
    else if(nuclev->GetSpin().IsData(InfoData::kTentative))
        Lev.Append(")").Prepend("(");

    return Lev;
}

void CXLevelSchemePlayer::ProcessedEventLevelScheme(Int_t eventType, Int_t eventX, Int_t eventY, TObject* obj)
{
    if( eventType == kKeyPress )
    {
        EKeySym keysym = (EKeySym)eventY;

        if ( keysym == kKey_r)
        {
            Int_t index = -1;
            if(fListOfBoxes->FindObject(obj))
                index = fListOfBoxes->IndexOf(obj);

            if(index != -1)
                RemoveArrow(index);
        }
    }
}

void CXLevelSchemePlayer::RemoveArrow(Int_t ArrowIndex)
{
    TList *l = fMainWindow->GetCanvas()->GetListOfPrimitives();

    l->Remove(fListOfBoxes->RemoveAt(ArrowIndex));
    l->Remove(fListOfArrows->RemoveAt(ArrowIndex));
    l->Remove(fListOfLatex->RemoveAt(ArrowIndex));

    fMainWindow->GetCanvas()->Modified();
    fMainWindow->GetCanvas()->Update();
}

TString CXLevelSchemePlayer::GetLTString(Float_t LifeTime)
{
    TString Value="";

    if(LifeTime >0.) {
        if(LifeTime<1e-12)
            Value = Form("%.3g fs",LifeTime*1e15);
        else if(LifeTime<1e-9)
            Value = Form("%.3g ps",LifeTime*1e12);
        else if(LifeTime<1e-6)
            Value = Form("%.3g ns",LifeTime*1e9);
        else if(LifeTime<1e-3)
            Value = Form("%.3g us",LifeTime*1e6);
        else if(LifeTime<1e-0)
            Value = Form("%.3g ms",LifeTime*1e3);
        else if(LifeTime<60)
            Value = Form("%.3g s",LifeTime);
        else if(LifeTime<3600)
            Value = Form("%.3g min",LifeTime/60.);
        else if(LifeTime<3600*12)
            Value = Form("%.3g h",LifeTime/3600.);
        else if(LifeTime<3600*24*365.242190517)
            Value = Form("%.3g d",LifeTime/(3600.*24));
        else if(!isinf(LifeTime))
            Value = Form("%.3g y",LifeTime/(3600.*24*365.242190517));
        else
            Value = Form("STABLE");
    }
    Value.Append(" ");

    return Value;
}

ClassImp(CXLevelSchemePlayer);