#include <iostream>
#include <tut.h>

#include "IReconBase.hxx"
#include "IReconNode.hxx"
#include "IReconState.hxx"
#include "IReconCluster.hxx"
#include "IReconShower.hxx"
#include "IReconTrack.hxx"
#include "IReconVertex.hxx"
#include "IReconPID.hxx"

namespace tut {
    struct baseTReconTrack {
        baseTReconTrack() {
            // Run before each test.
        }
        ~baseTReconTrack() {
            // Run after each test.
        }
    };

    // Declare the test
    typedef test_group<baseTReconTrack>::object testTReconTrack;
    test_group<baseTReconTrack> groupTReconTrack("IReconTrack");

    // Test the IReconTrack constructor and destructor.
    template<> template<>
    void testTReconTrack::test<1> () {
        COMET::IReconTrack recObj;

        ensure_distance("Default quality is zero", 
                        recObj.GetQuality(), 0.0, 
                        std::numeric_limits<double>::epsilon());

        ensure_equals("Default degrees of freedom",
                      recObj.GetNDOF(), 0);

        ensure("Default state",recObj.GetState());

        COMET::IHandle<COMET::ITrackState> recState = recObj.GetState();
        ensure("Default state is ITrackState",recState);

        COMET::IHandle<COMET::IClusterState> clusterState = recObj.GetState();
        ensure("Default state is not IClusterState",!clusterState);

        ensure_equals("Default TReconNodesContainer has size zero",
                      recObj.GetNodes().size(), (unsigned) 0);

        ensure("Default has no hits",!recObj.GetHits());
    }

    // Test the state definition.
    template<> template<>
    void testTReconTrack::test<2> () {
        COMET::IReconTrack recObj;
        COMET::IHandle<COMET::ITrackState> recState = recObj.GetState();

        ensure("The state is valid", recState);

        const int stateDim = recState->GetDimensions();
        ensure_equals("Track state dimensions", stateDim, 12);
    }

    // Test nodes which are saved have the correct type of state and all have
    // an associated object.
    template<> template<>
    void testTReconTrack::test<3> () {
        COMET::IReconTrack recObj;
        COMET::IReconNodeContainer& recNodes = recObj.GetNodes();
        COMET::IHandle<COMET::IReconNode> recNode;
        COMET::IHandle<COMET::IReconBase> recCluster(new COMET::IReconCluster);
        COMET::IHandle<COMET::IReconState> recState(new COMET::ITrackState);

        ensure_equals("Node container starts empty.",recNodes.size(),
                      (unsigned)0);

#ifdef MISSING_STATE_CHECK
        try {
            recNode = COMET::IHandle<COMET::IReconNode>(new COMET::IReconNode);
            recNode->SetObject(recCluster);
            recNodes.push_back(recNode);
            fail("IReconNodeContainer node state is empty");
        } 
        catch (COMET::EWrongStateType& ex) {
            // OK!
            std::cout << std::endl << "Caught " << ex.what() << std::endl;
        }
#endif

        try {
            recNode = COMET::IHandle<COMET::IReconNode>(new COMET::IReconNode);
            recNode->SetState(recState);
            recNodes.push_back(recNode);
            recNode->ls();
            fail("IReconNodeContainer object is empty");
        } 
        catch (COMET::EObjectEmpty& ex) {
            // OK!
            std::cout << std::endl << "Caught " << ex.what() << std::endl;
        }

        try {
            recNode = COMET::IHandle<COMET::IReconNode>(new COMET::IReconNode);
            recNode->SetObject(recCluster);
            recNode->SetState(recState);
            recNodes.push_back(recNode);
        }
        catch (...) {
            fail("IReconNodeContainer failed with correct object and state");
        }
    }

    // Test the getters and setters.
    template<> template<>
    void testTReconTrack::test<4> () {
        COMET::IReconTrack recObj;
        COMET::IHandle<COMET::ITrackState> recState = recObj.GetState();

        ensure("The state is valid", recState);

        const double eDeposit = 1.414;
        recState->SetEDeposit(eDeposit);

        const TLorentzVector pos(1.1,1.2,1.3,1.4);
        recState->SetPosition(pos);

        TVector3 dir(0.1, 0.2, 0.3);
        dir = dir.Unit();
        recState->SetDirection(dir);

        const double curvature = 2.17;
        recState->SetCurvature(curvature);

        const TVector3 width(0.3, 0.4, 0.0);
        recState->SetWidth(width.X(), width.Y());
        
        ensure_distance("Track energy deposit saved",
                        recObj.GetEDeposit(), eDeposit, 0.00001);

        ensure_lessthan("Track position saved",
                        (recObj.GetPosition()-pos).Mag(), 0.0001);

        ensure_lessthan("Track direction saved",
                        (recObj.GetDirection()-dir).Mag(), 0.0001);

        ensure_distance("Track curvature saved",
                        recObj.GetCurvature(), curvature, 0.00001);

        ensure_lessthan("Track width saved",
                        (recObj.GetWidth()-width).Mag(), 0.0001);

    }

    // Test the getters and setters.
    template<> template<>
    void testTReconTrack::test<5> () {
        COMET::IReconTrack recObj;
        COMET::IHandle<COMET::ITrackState> recState = recObj.GetState();

        ensure("The state is valid", recState);

        const TLorentzVector pos(1.1,1.2,1.3,1.4);
        recState->SetPosition(pos);

        ensure_distance("Track X position and value",
                        recState->GetPosition().X(),
                        recState->GetValue(recState->GetPositionIndex()),
                        0.01);
        ensure_distance("Track Y position and value",
                        recState->GetPosition().Y(),
                        recState->GetValue(recState->GetPositionIndex()+1),
                        0.01);
        ensure_distance("Track Z position and value",
                        recState->GetPosition().Z(),
                        recState->GetValue(recState->GetPositionIndex()+2),
                        0.01);
        ensure_distance("Track T position and value",
                        recState->GetPosition().T(),
                        recState->GetValue(recState->GetPositionIndex()+3),
                        0.01);

        ensure_lessthan("Track position saved",
                        (recObj.GetPosition()-pos).Mag(), 0.0001);

    }
};