#ifndef VTRACKINGSCENE_H_
#define VTRACKINGSCENE_H_

#include "VScene.h"
#include "VTrackingData.h"

class TClonesArray;
class CbmPixelHit;
class CbmTrack;
class CbmGlobalTrack;
class CbmStsTrack;
class FairMCPoint;

enum TrackingGraphicsItem {kVPOINT = 0, kVHIT = 1, kVTRACK = 2};

class VTrackingScene: public VScene
{
    Q_OBJECT

public:
	VTrackingScene();

	virtual ~VTrackingScene();

	virtual void DrawGeometry();

	virtual void ProcessEvent(
    		int ievent);

	virtual void ProcessCurEvent();

	virtual void LoadData();

    int GetNofItemTypes() const {return fNofItemTypes;}

    void SetSize(
    		TrackingGraphicsItem type,
    		double size) {
    	fSize[type] = size;
    }

    void SetColor(
    		TrackingGraphicsItem type,
    		const QColor& color) {
    	fColor[type] = color;
    }

    void IsDraw(
    		TrackingGraphicsItem type,
    		bool isDraw) {
    	fIsDraw[type] = isDraw;
    }

    const QColor& GetColor(
    		TrackingGraphicsItem type) const {return fColor[type];}

    double GetSize(
    		TrackingGraphicsItem type) const {return fSize[type];}

    bool IsDraw(
    		TrackingGraphicsItem type) const {return fIsDraw[type];}

	bool IsDrawXYProjection() const { return fIsDrawXYProjection; }

	bool IsDrawXZProjection() const { return fIsDrawXZProjection; }

	bool IsDrawYZProjection() const { return fIsDrawYZProjection; }

	void IsDrawXYProjection(bool isDraw) { fIsDrawXYProjection = isDraw; }

	void IsDrawXZProjection(bool isDraw) { fIsDrawXZProjection = isDraw; }

	void IsDrawYZProjection(bool isDraw) { fIsDrawYZProjection = isDraw; }

    void Update();

    void CreateHitArray();

    void CreatePointArray();

    void CreateTrackArray();

    void ClearArrays();

    void DrawOpenGL();

    void DrawQt();

    unsigned int GetHitsSize() {return fHits.size();}
    unsigned int GetPointsSize() {return fPoints.size();}
    unsigned int GetTracksSize() {return fTracks.size();}

    VMyHit GetHit(int n) {return fHits[n];}
    VMyHit GetPoint(int n) {return fPoints[n];}
    VMyTrack GetTrack(int n) {return fTracks[n];}

    QString GetTrackTitle() {return fTrackTitle;}
    QString GetTrackCaption() {return fTrackCaption;}

    void SetTrackTitle(QString title) {fTrackTitle=title;}
    void SetTrackCaption(QString caption) {fTrackCaption=caption;}
protected:

	virtual void CreateArrays();

    void DrawGeometryProjection(
    		const QPointF& origin,
    		const QSizeF& size,
    		const QString& text);

    virtual void ClearScene();

    void DrawHit(
		const VMyHit* hit,
		double size,
		QColor color,
		QGraphicsItemGroup* group);

    void DrawHits();

    void CreateHits(
    		const TClonesArray* hits,
    		const QString& detector);

    void DrawPoints();

    void CreatePoints(
    		const TClonesArray* points,
    		const QString& detector);

    void DrawTracks();

    void DrawTrack(
        	const VMyTrack& myTrack);

//    void ConstructTrack(const CbmGlobalTrack* track, int trackNum);
//    void ConstructStsTrack(CbmStsTrack* stsTrack, int trackNum);

//    void AddHitsToMyTrack(const CbmTrack* track, TClonesArray* hits, const QString& detector, int trackNum, QString& info);

    QPointF MapToXZ(
    		const QPointF& point);

    QPointF MapToYZ(
    		const QPointF& point);

    QPointF MapToXY(
    		const QPointF& point);

//    VMyHit* AssociateHit(int trackNum, float x, float y, float z);
private:
    // pointers to data arrays
    TClonesArray* fGlobalTracks; // CbmGlobalTrack
    TClonesArray* fMvdHits; // CbmMvdHit
    TClonesArray* fMvdPoints; // CbmMvdPoint
    TClonesArray* fStsHits; // CbmStsHit
    TClonesArray* fStsTracks; // CbmStsTrack
    TClonesArray* fStsPoints; // CbmStsPoint
    TClonesArray* fMuchPixelHits; // CbmMuchPixelHit
//    TClonesArray* fMuchTracks; // CbmMuchTrack
    TClonesArray* fMuchPoints; // CbmMuchPoint
    TClonesArray* fTrdHits; // CbmTrdHit
//    TClonesArray* fTrdTracks; // CbmTrdTrack
    TClonesArray* fTrdPoints; // CbmTrdPoint
    TClonesArray* fTofHits; // CbmTofHit
    TClonesArray* fTofPoints; // CbmTofPoint

    std::vector<QGraphicsItemGroup*> fGroup;

	int fNofItemTypes;
	std::vector<QColor> fColor;
	std::vector<double> fSize;
	std::vector<bool> fIsDraw;

	bool fIsDrawXYProjection;
	bool fIsDrawXZProjection;
	bool fIsDrawYZProjection;

    QPointF fOriginXZ;
    QPointF fOriginYZ;
    QPointF fOriginXY;
    QSizeF fGeoSize;

    QString fTrackTitle;
    QString fTrackCaption;

    std::vector<VMyHit> fHits;
    std::vector<VMyHit> fPoints;
    std::vector<VMyTrack> fTracks;
};

#endif /*VTRACKINGSCENE_H_*/