#include <RQ_OBJECT.h>
#include <TEveBoxSet.h>
#include <TEveBrowser.h>
#include <TEveEventManager.h>
#include <TEveGeoNode.h>
#include <TEveGeoShape.h>
#include <TEveManager.h>
#include <TEvePathMark.h>
#include <TEveProjectionAxes.h>
#include <TEveProjectionManager.h>
#include <TEveScene.h>
#include <TEveTrack.h>
#include <TEveTrackPropagator.h>
#include <TEveVector.h>
#include <TEveViewer.h>
#include <TEveWindow.h>
#include <TFile.h>
#include <TGButton.h>
#include <TGColorSelect.h>
#include <TGFrame.h>
#include <TGLLightSet.h>
#include <TGLViewer.h>
#include <TGLabel.h>
#include <TGNumberEntry.h>
#include <TGSlider.h>
#include <TGTab.h>
#include <TGeoManager.h>
#include <TGeoMaterial.h>
#include <TGeoMedium.h>
#include <TGeoVolume.h>
#include <TROOT.h>
#include <TSystem.h>

#include <print>

// MultiView
//
// Structure encapsulating standard views: 3D, r-phi and rho-z.
// Includes scenes and projection managers.
//
// Should be used in compiled mode.
// Implemented in MultiView.C
/// \file
/// \ingroup tutorial_eve
/// Multi-view (3d, rphi, rhoz) service class using EVE Window Manager.
///
/// \macro_code
///
/// \author Matevz Tadel
struct MultiView
{
    TEveProjectionManager* fRPhiMgr;
    TEveProjectionManager* fRhoZMgr;

    TEveViewer* f3DView;
    TEveViewer* fRPhiView;
    TEveViewer* fRhoZView;

    TEveScene* fRPhiGeomScene;
    TEveScene* fRhoZGeomScene;
    TEveScene* fRPhiEventScene;
    TEveScene* fRhoZEventScene;

    //---------------------------------------------------------------------------
    MultiView()
    {
        // Constructor --- creates required scenes, projection managers
        // and GL viewers.

        // Scenes
        //========

        fRPhiGeomScene = gEve->SpawnNewScene("RPhi Geometry", "Scene holding projected geometry for the RPhi view.");
        fRhoZGeomScene = gEve->SpawnNewScene("RhoZ Geometry", "Scene holding projected geometry for the RhoZ view.");
        fRPhiEventScene =
            gEve->SpawnNewScene("RPhi Event Data", "Scene holding projected event-data for the RPhi view.");
        fRhoZEventScene =
            gEve->SpawnNewScene("RhoZ Event Data", "Scene holding projected event-data for the RhoZ view.");

        // Projection managers
        //=====================

        fRPhiMgr = new TEveProjectionManager(TEveProjection::kPT_RPhi);
        gEve->AddToListTree(fRPhiMgr, kFALSE);
        {
            TEveProjectionAxes* a = new TEveProjectionAxes(fRPhiMgr);
            a->SetMainColor(kWhite);
            a->SetTitle("R-Phi");
            a->SetTitleSize(0.05);
            a->SetTitleFont(102);
            a->SetLabelSize(0.025);
            a->SetLabelFont(102);
            fRPhiGeomScene->AddElement(a);
        }

        fRhoZMgr = new TEveProjectionManager(TEveProjection::kPT_RhoZ);
        gEve->AddToListTree(fRhoZMgr, kFALSE);
        {
            TEveProjectionAxes* a = new TEveProjectionAxes(fRhoZMgr);
            a->SetMainColor(kWhite);
            a->SetTitle("Rho-Z");
            a->SetTitleSize(0.05);
            a->SetTitleFont(102);
            a->SetLabelSize(0.025);
            a->SetLabelFont(102);
            fRhoZGeomScene->AddElement(a);
        }

        // Viewers
        //=========

        TEveWindowSlot* slot = 0;
        TEveWindowPack* pack = 0;

        slot = TEveWindow::CreateWindowInTab(gEve->GetBrowser()->GetTabRight());
        pack = slot->MakePack();
        pack->SetElementName("Multi View");
        pack->SetHorizontal();
        pack->SetShowTitleBar(kFALSE);
        pack->NewSlot()->MakeCurrent();
        f3DView = gEve->SpawnNewViewer("3D View", "");
        f3DView->AddScene(gEve->GetGlobalScene());
        f3DView->AddScene(gEve->GetEventScene());

        pack = pack->NewSlot()->MakePack();
        pack->SetShowTitleBar(kFALSE);
        pack->NewSlot()->MakeCurrent();
        fRPhiView = gEve->SpawnNewViewer("RPhi View", "");
        fRPhiView->GetGLViewer()->SetCurrentCamera(TGLViewer::kCameraOrthoXOY);
        fRPhiView->AddScene(fRPhiGeomScene);
        fRPhiView->AddScene(fRPhiEventScene);

        pack->NewSlot()->MakeCurrent();
        fRhoZView = gEve->SpawnNewViewer("RhoZ View", "");
        fRhoZView->GetGLViewer()->SetCurrentCamera(TGLViewer::kCameraOrthoXOY);
        fRhoZView->AddScene(fRhoZGeomScene);
        fRhoZView->AddScene(fRhoZEventScene);
    }

    //---------------------------------------------------------------------------

    void SetDepth(Float_t d)
    {
        // Set current depth on all projection managers.
        fRPhiMgr->SetCurrentDepth(d);
        fRhoZMgr->SetCurrentDepth(d);
    }

    //---------------------------------------------------------------------------

    void ImportGeomRPhi(TEveElement* el) { fRPhiMgr->ImportElements(el, fRPhiGeomScene); }

    void ImportGeomRhoZ(TEveElement* el) { fRhoZMgr->ImportElements(el, fRhoZGeomScene); }

    void ImportEventRPhi(TEveElement* el) { fRPhiMgr->ImportElements(el, fRPhiEventScene); }

    void ImportEventRhoZ(TEveElement* el) { fRhoZMgr->ImportElements(el, fRhoZEventScene); }

    //---------------------------------------------------------------------------

    void DestroyEventRPhi() { fRPhiEventScene->DestroyElements(); }

    void DestroyEventRhoZ() { fRhoZEventScene->DestroyElements(); }
}* gMultiView {nullptr};

class event_viewer : public TObject
{
    RQ_OBJECT("event_viewer")

    long long event_id {0};             ///< Current event id.
    const Int_t jumps_no {5};           ///< Number of JumpNav fields
    TEveGeoShape* gGeomGentle {nullptr};
    TGeoManager* gGeom {nullptr};       ///< Geometry manager
    TGeoMedium* Fiber {nullptr};        ///< Fiber medium object
    TGeoVolume* fiber {nullptr};        ///< Fiber volume object
    Int_t marker_type {3};              ///< Hit marker type
    Int_t fiber_color {kWhite};         ///< active fibers color
    Int_t active_fiber_color {kGreen};  ///< active fibers color
    Int_t active_fiber_alpha {50};      ///< active fibers color
    Int_t charge_color {kMagenta};      ///< deposited charge color
    Int_t cluster_color {kYellow};      ///< deposited charge color
    Int_t cluster_alpha {95};
    Int_t cluster_scale {1};
    TGLabel* l_evt {nullptr};           ///< Displays current event number
    TGLabel* l_all {nullptr};           ///< Displays all events number

public:
    event_viewer(const char* file,
                 const char* ascii_params = "sabat_params.txt",
                 const char* sabat_geometry = "sabat_geometry.root")
        : TObject()
    {
        TEveManager::Create();

        /**** EVENTS ****/

        /**** GEOMETRY ****/
        std::string params_file(ascii_params);

        bool load = 0;

        TEveGeoTopNode* en {nullptr};
        if (load) {
            auto geom = TFile::Open(sabat_geometry, "READ");

            if (!geom) {
                std::print(stderr, "No geometry file {:s}", sabat_geometry);
                abort();
            }
            auto gse = (TEveGeoShapeExtract*)geom->Get("Gentle");
            gGeomGentle = TEveGeoShape::ImportShapeExtract(gse, 0);
            geom->Close();
            delete geom;
            gEve->AddGlobalElement(gGeomGentle);
        } else {
            en = make_geometry();
            gGeomGentle = new TEveGeoShape;
            gGeomGentle->AddElement(en);
            gEve->AddGlobalElement(gGeomGentle);
        }

        /**** VIEW ****/
        gMultiView = new MultiView;
        gMultiView->f3DView->GetGLViewer()->SetStyle(TGLRnrCtx::kOutline);
        gMultiView->SetDepth(-10);
        gMultiView->ImportGeomRPhi(gGeomGentle);
        gMultiView->ImportGeomRhoZ(gGeomGentle);
        gMultiView->SetDepth(0);

        gEve->FullRedraw3D(kTRUE);

        /**** GL Viewer ****/
        auto v = gEve->GetDefaultGLViewer();
        //     v->GetClipSet()->SetClipType(TGLClip::EType(1));
        v->SetGuideState(TGLUtil::kAxesOrigin, kTRUE, kFALSE, 0);
        v->RefreshPadEditor(v);
        v->GetLightSet()->SetLight(TGLLightSet::kLightLeft, kTRUE);
        v->GetLightSet()->SetLight(TGLLightSet::kLightRight, kTRUE);
        v->GetLightSet()->SetLight(TGLLightSet::kLightTop, kTRUE);
        v->GetLightSet()->SetLight(TGLLightSet::kLightBottom, kTRUE);
        v->GetLightSet()->SetLight(TGLLightSet::kLightFront, kTRUE);
        v->DoDraw();

        /**** GUI ****/
        gEve->GetViewers()->SwitchColorSet();
        gEve->GetDefaultGLViewer()->SetStyle(TGLRnrCtx::kOutline);

        gEve->GetBrowser()->GetTabRight()->SetTab(0);

        make_gui();
    }

    virtual ~event_viewer() {}

    void make_gui()
    {
        // Create minimal GUI for event navigation.

        TEveBrowser* browser = gEve->GetBrowser();
        browser->StartEmbedding(TRootBrowser::kLeft);

        TGMainFrame* main_frame = new TGMainFrame(gClient->GetRoot(), 1000, 600);
        main_frame->SetWindowName("XX GUI");
        main_frame->SetCleanup(kDeepCleanup);

        TGGroupFrame* group_navi = new TGGroupFrame(main_frame, "Basic Navigation", kHorizontalFrame);
        group_navi->SetTitlePos(TGGroupFrame::kLeft);
        {
            TGTextButton* b = nullptr;

            b = new TGTextButton(group_navi, "&Prev");
            group_navi->AddFrame(b, new TGLayoutHints(kLHintsExpandX, 0, 0, 5, 0));
            b->Connect("Clicked()", "event_viewer", this, "Prev()");

            TGVerticalFrame* group_event_info = new TGVerticalFrame(group_navi);

            TGHorizontalFrame* group_event_current = new TGHorizontalFrame(group_event_info);

            TGLabel* l = new TGLabel(group_event_current, "E:");
            group_event_current->AddFrame(l, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 0, 0, 5, 0));

            l_evt = new TGLabel(nullptr, "        ");
            group_event_current->AddFrame(l_evt, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 0, 0, 5, 0));

            TGHorizontalFrame* group_event_all = new TGHorizontalFrame(group_event_info);

            l = new TGLabel(group_event_all, "T:");
            group_event_all->AddFrame(l, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 0, 0, 5, 0));

            l_all = new TGLabel(nullptr, "        ");
            group_event_all->AddFrame(l_all, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 0, 0, 5, 0));

            group_event_info->AddFrame(group_event_current, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));
            group_event_info->AddFrame(group_event_all, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));

            group_navi->AddFrame(group_event_info, new TGLayoutHints(kLHintsExpandX, 0, 0, 5, 0));

            b = new TGTextButton(group_navi, "&Next");
            group_navi->AddFrame(b, new TGLayoutHints(kLHintsExpandX, 0, 0, 5, 0));
            b->Connect("Clicked()", "event_viewer", this, "Next()");
        }
        main_frame->AddFrame(group_navi, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));

        TGHorizontalFrame* hf {nullptr};

        TGGroupFrame* frame_quick_nav = new TGGroupFrame(main_frame, "Quick Navigation", kVerticalFrame);
        frame_quick_nav->SetTitlePos(TGGroupFrame::kLeft);
        for (int i = 0; i < jumps_no; ++i) {
            hf = new TGHorizontalFrame(frame_quick_nav);
            {
                TGTextButton* b1 = new TGTextButton(hf, "Load");
                hf->AddFrame(b1, new TGLayoutHints(kLHintsExpandX));

                TGLabel* l = new TGLabel(hf, "  Selected ");
                hf->AddFrame(l, new TGLayoutHints(kLHintsCenterY, 0, 0, 0, 0));

                TGNumberEntry* l_evt_jump = new TGNumberEntry(hf,
                                                              0,
                                                              5,
                                                              -1,
                                                              TGNumberFormat::kNESInteger,
                                                              TGNumberFormat::kNEAAnyNumber,
                                                              TGNumberFormat::kNELLimitMinMax,
                                                              0,
                                                              999);
                hf->AddFrame(l_evt_jump);

                QuickJumpNavHandler* fhj = new QuickJumpNavHandler(this, l_evt_jump);

                TGTextButton* b2 = new TGTextButton(hf, TString::Format("Jump &%d", i + 1));
                hf->AddFrame(b2, new TGLayoutHints(kLHintsExpandX, 5, 0, 0, 0));

                b1->Connect("Clicked()", "event_viewer::QuickJumpNavHandler", fhj, "Load()");
                b2->Connect("Clicked()", "event_viewer::QuickJumpNavHandler", fhj, "Jump()");
            }
            frame_quick_nav->AddFrame(hf, new TGLayoutHints(kLHintsExpandX, 0, 0, 2, 2));
        }
        main_frame->AddFrame(frame_quick_nav, new TGLayoutHints(kLHintsExpandX));

        // Fibers properties
        MaterialPropHandler* mph = new MaterialPropHandler(this, matFiber);

        TGGroupFrame* frame_properties = new TGGroupFrame(main_frame, "Fibers Properties", kVerticalFrame);
        frame_properties->SetTitlePos(TGGroupFrame::kLeft);

        hf = new TGHorizontalFrame(frame_properties);
        {
            TGLabel* l = new TGLabel(hf, "Transparency");
            hf->AddFrame(l, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 0, 0, 0, 0));

            TGHSlider* hslider = new TGHSlider(hf, 100, kSlider1 | kScaleDownRight, 1);
            hslider->SetRange(80, 100);
            hslider->Connect(
                "PositionChanged(Int_t)", "event_viewer::MaterialPropHandler", mph, "PositionChanged(Int_t)");
            hf->AddFrame(hslider, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));

            l = new TGLabel(hf, "xxx");
            hf->AddFrame(l, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 0, 0, 0, 0));
            mph->SetAlphaLabel(l);
            hslider->SetPosition(95);
            mph->PositionChanged(95);
        }
        frame_properties->AddFrame(hf, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));

        hf = new TGHorizontalFrame(frame_properties);
        {
            TGLabel* l = new TGLabel(hf, "Fiber Color");
            hf->AddFrame(l, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 0, 0, 0, 0));

            TGColorSelect* csel = new TGColorSelect(hf, TColor::Number2Pixel(fiber_color), 100);
            csel->Connect("ColorSelected(Pixel_t)", "event_viewer::MaterialPropHandler", mph, "ColorSelected(Pixel_t)");
            hf->AddFrame(csel, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 5, 2, 2, 2));
        }
        frame_properties->AddFrame(hf, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));

        // Active Fiber Properties
        ObstaclePropHandler* fiber_oph = new ObstaclePropHandler(this, &active_fiber_color, &active_fiber_alpha);

        hf = new TGHorizontalFrame(frame_properties);
        {
            TGLabel* l = new TGLabel(hf, "Active Fiber Color");
            hf->AddFrame(l, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 0, 0, 0, 0));

            TGColorSelect* csel = new TGColorSelect(hf, TColor::Number2Pixel(active_fiber_color), 100);
            csel->Connect(
                "ColorSelected(Pixel_t)", "event_viewer::ObstaclePropHandler", fiber_oph, "ColorSelected(Pixel_t)");
            hf->AddFrame(csel, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 5, 2, 2, 2));
        }
        frame_properties->AddFrame(hf, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));

        hf = new TGHorizontalFrame(frame_properties);
        {
            TGLabel* l = new TGLabel(hf, "Alpha");
            hf->AddFrame(l, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 0, 0, 0, 0));

            TGHSlider* hslider = new TGHSlider(hf, 100, kSlider1 | kScaleDownRight, 1);
            hslider->SetRange(0, 100);
            hslider->Connect(
                "PositionChanged(Int_t)", "event_viewer::ObstaclePropHandler", fiber_oph, "AlphaChanged(Int_t)");
            hf->AddFrame(hslider, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));

            l = new TGLabel(hf, "xxx");
            hf->AddFrame(l, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 0, 0, 0, 0));
            fiber_oph->SetAlphaLabel(l);
            hslider->SetPosition(active_fiber_alpha);
            fiber_oph->AlphaChanged(active_fiber_alpha);
        }
        frame_properties->AddFrame(hf, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));

        // Charge deposition
        ObstaclePropHandler* charge_oph = new ObstaclePropHandler(this, &charge_color);

        hf = new TGHorizontalFrame(frame_properties);
        {
            TGLabel* l = new TGLabel(hf, "Charge Deposition Color");
            hf->AddFrame(l, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 0, 0, 0, 0));

            TGColorSelect* csel = new TGColorSelect(hf, TColor::Number2Pixel(charge_color), 100);
            csel->Connect(
                "ColorSelected(Pixel_t)", "event_viewer::ObstaclePropHandler", charge_oph, "ColorSelected(Pixel_t)");
            hf->AddFrame(csel, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 5, 2, 2, 2));
        }
        frame_properties->AddFrame(hf, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));

        // CLUSTER
        ObstaclePropHandler* cluster_oph =
            new ObstaclePropHandler(this, &cluster_color, &cluster_alpha, &cluster_scale);

        hf = new TGHorizontalFrame(frame_properties);
        {
            TGLabel* l = new TGLabel(hf, "Cluster Box Color");
            hf->AddFrame(l, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 0, 0, 0, 0));

            TGColorSelect* csel = new TGColorSelect(hf, TColor::Number2Pixel(cluster_color), 100);
            csel->Connect(
                "ColorSelected(Pixel_t)", "event_viewer::ObstaclePropHandler", cluster_oph, "ColorSelected(Pixel_t)");
            hf->AddFrame(csel, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 5, 2, 2, 2));
        }
        frame_properties->AddFrame(hf, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));

        hf = new TGHorizontalFrame(frame_properties);
        {
            TGLabel* l = new TGLabel(hf, "Alpha");
            hf->AddFrame(l, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 0, 0, 0, 0));

            TGHSlider* hslider = new TGHSlider(hf, 100, kSlider1 | kScaleDownRight, 1);
            hslider->SetRange(0, 100);
            hslider->Connect(
                "PositionChanged(Int_t)", "event_viewer::ObstaclePropHandler", cluster_oph, "AlphaChanged(Int_t)");
            hf->AddFrame(hslider, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));

            l = new TGLabel(hf, "xxx");
            hf->AddFrame(l, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 0, 0, 0, 0));
            cluster_oph->SetAlphaLabel(l);
            hslider->SetPosition(cluster_alpha);
            cluster_oph->AlphaChanged(cluster_alpha);
        }
        frame_properties->AddFrame(hf, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));

        hf = new TGHorizontalFrame(frame_properties);
        {
            TGLabel* l = new TGLabel(hf, "Scale");
            hf->AddFrame(l, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 0, 0, 0, 0));

            TGHSlider* hslider = new TGHSlider(hf, 100, kSlider1 | kScaleDownRight, 1);
            hslider->SetRange(1, 100);
            hslider->Connect(
                "PositionChanged(Int_t)", "event_viewer::ObstaclePropHandler", cluster_oph, "ScaleChanged(Int_t)");
            hf->AddFrame(hslider, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));

            l = new TGLabel(hf, "xxx");
            hf->AddFrame(l, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 0, 0, 0, 0));
            cluster_oph->SetScaleLabel(l);
            hslider->SetPosition(cluster_scale);
            cluster_oph->ScaleChanged(cluster_scale);
        }
        frame_properties->AddFrame(hf, new TGLayoutHints(kLHintsExpandX, 0, 0, 0, 0));

        main_frame->AddFrame(frame_properties, new TGLayoutHints(kLHintsExpandX));

        main_frame->MapSubwindows();
        main_frame->Resize();
        main_frame->MapWindow();

        browser->StopEmbedding();
        browser->SetTabTitle("Event Control", 0);
    }

    //______________________________________________________________________________
    void load_event()
    {
        // Load event specified in global event_id.
        // The contents of previous event are removed.

        std::print("[{:s}]  this: {:p}   l_evt: {:p} l_all: {:p}  event: {:d}\n",
                   __PRETTY_FUNCTION__,
                   (void*)this,
                   (void*)l_evt,
                   (void*)l_all,
                   event_id);

        l_evt->SetText(TString::Format("%5lld", event_id).Data());
        l_all->SetText(TString::Format("%5lld", 999ll).Data());

        gEve->GetViewers()->DeleteAnnotations();

        gEve->FullRedraw3D(kFALSE);
    }

    /******************************************************************************/
    // GUI
    /******************************************************************************/
    void print_geom_tree(TGeoNode* node, int indent = 0)
    {
        if (indent == 0) {
            printf("%*c%s\n", indent, ' ', node->GetName());
        }

        TObjArray* objs = node->GetNodes();
        if (!objs) {
            return;
        }

        for (int i = 0; i < objs->GetEntries(); ++i) {
            TGeoNode* n = dynamic_cast<TGeoNode*>(objs->At(i));
            if (n) {
                printf("%*c[%d]  %s\n", indent + 4, ' ', i, n->GetName());
                print_geom_tree(n, indent + 4);
            }
        }
    }

    TGeoMaterial* matFiber {nullptr};

    TEveGeoTopNode* make_geometry()
    {
        //--- Definition of a simple geometry
        gGeom = new TGeoManager("Assemblies", "Geometry using assemblies");
        gGeom->SetVerboseLevel(0);

        //--- define some materials
        TGeoMaterial* matVacuum = new TGeoMaterial("Vacuum", 0, 0, 0);
        matFiber = new TGeoMaterial("LYSO:Ce_solid", 1, 1, 1);
        matFiber->SetTransparency(95);

        //--- define some media
        TGeoMedium* Vacuum = new TGeoMedium("Vacuum", 1, matVacuum);
        Fiber = new TGeoMedium("LYSO:Ce", 2, matFiber);

        //--- make the top container volume
        TGeoVolume* top = gGeom->MakeBox("TOP", Vacuum, 10000., 10000., 1000.);
        gGeom->SetTopVolume(top);

        fiber = gGeom->MakeBox("FIBER", Fiber, 0.5, 50., 0.5);
        fiber->SetLineColor(fiber_color);

        TGeoVolume* plane = gGeom->MakeBox("PLANE", Vacuum, 100., 100., 1.);

        TGeoRotation* rot0 = new TGeoRotation("rot0", 0, 0, 0);
        TGeoRotation* rot90 = new TGeoRotation("rot90", 90, 0, 0);

        TGeoVolume* mod = gGeom->MakeBox("MODULE", Vacuum, 1000., 1000., 100.);

        //--- close the gGeometry
        gGeom->CloseGeometry();

        auto node1 = gGeom->GetTopNode();
        //     print_gGeom_tree(node1, 0);

        TEveGeoTopNode* en = new TEveGeoTopNode(gGeom, node1);
        //     en->SetVisOption(1);
        //     en->SetVisLevel(4);

        //     en->SaveExtract("sifi_geometry.root", "Gentle", kFALSE);

        return en;
    }

    auto Next() -> void
    {
        std::print("[{:s}]  At event: {:d} of {:d} total.\n", __PRETTY_FUNCTION__, event_id, 999);

        if (event_id == 999) {
            std::print("Already at the last event: {:d} of {:d}.\n", event_id, 999);
        } else {
            ++(event_id);
            load_event();
        }
    }

    auto Prev() -> void
    {
        std::print("[{:s}]  At event: {:d} of {:d} total.\n", __PRETTY_FUNCTION__, event_id, 999);

        if (event_id == 0) {
            std::print("Already at the first event: {:d} of {:d}.\n", event_id, 999);
        } else {
            --(event_id);
            load_event();
        }
    }

    class QuickJumpNavHandler
    {
        event_viewer* evi {nullptr};

    public:
        QuickJumpNavHandler(event_viewer* eviewer, TGNumberEntry* widget)
            : evi {eviewer}
            , l_evt_jump(widget)
        {
        }

        void Load() { l_evt_jump->SetIntNumber(evi->event_id); }

        void Jump()
        {
            std::print("[{:s}]  At event: {:d} of {:d} total.\n",
                       __PRETTY_FUNCTION__,
                       evi->event_id,
                       999);

            if (evi->event_id == l_evt_jump->GetIntNumber()) {
                std::print("Already at the event {:d} of {:d}.\n", evi->event_id, 999);
                return;
            }

            evi->event_id = l_evt_jump->GetIntNumber();
            if (evi->event_id >= 0 and evi->event_id < 999) {
                evi->load_event();
            }
        }

    private:
        TGNumberEntry* l_evt_jump {nullptr};
    };

    class MaterialPropHandler
    {
        event_viewer* evi {nullptr};

    public:
        MaterialPropHandler(event_viewer* eviewer, TGeoMaterial* material)
            : evi {eviewer}
            , material(material)
        {
        }

        void PositionChanged(Int_t n)
        {
            material->SetTransparency(n);
            if (alpha_label) {
                alpha_label->SetText(TString::Format("% 3d", n));
            }
            gEve->FullRedraw3D(kFALSE);
        }

        void ColorSelected(Pixel_t c)
        {
            if (evi->fiber) {
                evi->fiber->SetLineColor(TColor::GetColor(c));
            }
            gEve->FullRedraw3D(kFALSE);
        }

        void SetAlphaLabel(TGLabel* l) { alpha_label = l; }

    private:
        TGeoMaterial* material;
        TGLabel* alpha_label;
    };

    class ObstaclePropHandler
    {
    private:
        event_viewer* evi {nullptr};
        int* color;
        int* alpha;
        int* scale;
        TGLabel* alpha_label;
        TGLabel* scale_label;

    public:
        ObstaclePropHandler(event_viewer* eviewer, int* _color = nullptr, int* _alpha = nullptr, int* _scale = nullptr)
            : evi {eviewer}
            , color(_color)
            , alpha(_alpha)
            , scale(_scale)
            , alpha_label(nullptr)
            , scale_label(nullptr)
        {
        }

        void SetAlphaLabel(TGLabel* l) { alpha_label = l; }

        void SetScaleLabel(TGLabel* l) { scale_label = l; }

        void ColorSelected(Pixel_t c)
        {
            std::print("{:s}\n", __PRETTY_FUNCTION__);

            if (color) {
                *color = TColor::GetColor(c);
                evi->load_event();
            }
        }

        void AlphaChanged(Int_t n)
        {
            std::print("{:s}\n", __PRETTY_FUNCTION__);

            if (alpha) {
                *alpha = n;
                evi->load_event();
            }
            if (alpha_label) {
                alpha_label->SetText(TString::Format("% 3d", n));
            }
        }

        void ScaleChanged(Int_t n)
        {
            std::print("{:s}\n", __PRETTY_FUNCTION__);

            if (scale) {
                *scale = n;
                evi->load_event();
            }
            if (scale_label) {
                scale_label->SetText(TString::Format("% 3d", n));
            }
        }
    };

    //______________________________________________________________________________
    void sabat_read()
    {
    }

    ClassDef(event_viewer, 0);
};

void event_display(const char* file = nullptr,
                   const char* ascii_params = "sabat_pars.txt",
                   const char* sabat_geometry = "sabat_geometry.root")
{
    event_viewer evi(file, ascii_params, sabat_geometry);

    // evi.load_event();
}

#if !defined(__ROOTCLING__)

#    include <TApplication.h>

#    include <CLI/CLI.hpp>
#    include <fmt/core.h>

auto main(int argc, char** argv) -> int
{
    CLI::App app {"Sabat DST application"};
    argv = app.ensure_utf8(argv);

    int64_t first_event {0};
    app.add_option("-f,--first", first_event, "number of events to skip")->check(CLI::PositiveNumber);

    int64_t n_events_to_process {0};
    app.add_option("-e,--events", n_events_to_process, "number of events to analyze")->check(CLI::PositiveNumber);

    std::string ascii_par {"sabat_pars.txt"};
    app.add_option("-a,--ascii", ascii_par, "ascii parameters file")->check(CLI::ExistingFile);

    std::string geom_file {"sabat_geometry.root"};
    app.add_option("-g,--geom", geom_file, "geometry file")->check(CLI::ExistingFile);

    std::string input_file {};
    app.add_option("input_file", input_file, "file to process")->check(CLI::ExistingFile);

    bool debug_mode {false};
    app.add_flag("-d", debug_mode, "debug mode");

    CLI11_PARSE(app, argc, argv);

    std::print("Args:: input file: {:s}  ascii pars: {:s}  geom file: {:s}\n", input_file, ascii_par, geom_file);

    TApplication rapp("app", &argc, argv);

    event_display(input_file.c_str(), ascii_par.c_str(), geom_file.c_str());

    rapp.Run();
}

#endif /* !defined(__ROOTCLING__) */