#include "IReconBase.hxx"
#include "IReconCluster.hxx"
#include "IIntegerDatum.hxx"
#include "IRealDatum.hxx"

#include <tut.h>

#include <iostream>
#include <sstream>
#include <string>


namespace tut {
    struct baseTReconBase {
        baseTReconBase() {
            // Run before each test.
        }

        ~baseTReconBase() {
            // Run after each test.
        }
        
    };

    // Declare the test
    typedef test_group<baseTReconBase>::object testTReconBase;
    test_group<baseTReconBase> groupTReconBase("IReconBase");

    // Test the basic constructor and destructor.
    template<> template <>
    void testTReconBase::test<1> () {
        COMET::IReconCluster base;

        ensure_equals("Default status is empty",base.GetStatus(),(unsigned)0);
        ensure_equals("Default quality is zero",base.GetQuality(),0);
        ensure_equals("Default degrees of freedom are zero",base.GetNDOF(),0);
        ensure("No default constituents", !base.GetConstituents());
    }

    // Test SetStatus(), ClearStatus(), and CheckStatus().
    template<> template <>
    void testTReconBase::test<2> () {
        COMET::IReconCluster base;

        ensure("No status bit is set", 
               !base.CheckStatus(COMET::IReconBase::kStatusMask));
        ensure("Default kRan is false",
               !base.CheckStatus(COMET::IReconBase::kRan));
        base.SetStatus(COMET::IReconBase::kRan);
        ensure("The kRan bit is true",
               base.CheckStatus(COMET::IReconBase::kRan));
        ensure("Bit in status mask is set",
               base.CheckStatus(COMET::IReconBase::kStatusMask));
        ensure("The kSuccess bit is false",
               !base.CheckStatus(COMET::IReconBase::kSuccess));
        ensure("The kChi2Fit bit is false",
               !base.CheckStatus(COMET::IReconBase::kChi2Fit));
        ensure("The kLikelihoodFit bit is false",
               !base.CheckStatus(COMET::IReconBase::kLikelihoodFit));
        ensure("The kKalman bit is false",
               !base.CheckStatus(COMET::IReconBase::kKalmanFit));
        ensure("Check several bits (including kRan) is true.",
               base.CheckStatus(COMET::IReconBase::kRan
                                | COMET::IReconBase::kSuccess));
        ensure("Check several bits (not including kRan) are false",
               !base.CheckStatus(COMET::IReconBase::kSuccess
                                 | COMET::IReconBase::kChi2Fit));
        base.ClearStatus(COMET::IReconBase::kRan);
        ensure("The kRan Bit is cleared",
               !base.CheckStatus(COMET::IReconBase::kRan));
        ensure("No status bit set after clear", 
               !base.CheckStatus(COMET::IReconBase::kStatusMask));
    }

    // Check the detector bits.
    template<> template <>
    void testTReconBase::test<3> () {
        COMET::IReconCluster base;
        
        ensure("No detector used by default",
               !base.UsesDetector(COMET::IReconBase::kDetectorMask));


        ensure("CTH is not used by default",
               !base.UsesDetector(COMET::IReconBase::kCTH));
        base.AddDetector(COMET::IReconBase::kCDC);
        ensure("CDC was added",
               base.UsesDetector(COMET::IReconBase::kCDC));
        ensure("StrawTrk was not added",
               !base.UsesDetector(COMET::IReconBase::kStrawTrk));
        ensure("ECAL was not added",
               !base.UsesDetector(COMET::IReconBase::kECAL));
        ensure("A CDC module was added",
               base.UsesDetector(COMET::IReconBase::kCDC));

        base.RemoveDetector(COMET::IReconBase::kCDC);
        ensure("CDC was removed",
               !base.UsesDetector(COMET::IReconBase::kCDC));
        ensure("No CDC modules are used",
               !base.UsesDetector(COMET::IReconBase::kCDC));
    }

    // Check the copy constructor.
    template<> template <>
    void testTReconBase::test<4> () {
        COMET::IReconCluster orig;
        orig.SetName("name");
        orig.SetTitle("title");
        orig.SetMoments(1,2,3,4,5,6);
        COMET::IIntegerDatum* iDatum 
            = new COMET::IIntegerDatum("integerDatum","title");
        orig.AddDatum(iDatum);

        COMET::IHandle<COMET::IIntegerDatum> origInt 
            = orig.Get<COMET::IIntegerDatum>("integerDatum");
        (*origInt)[0] = 1;
        origInt->push_back(2);
        origInt->push_back(3);

        COMET::IReconCluster copy(orig);

        ensure_equals("Name of orig and copy are the same",
                      std::string(copy.GetName()),
                      std::string(orig.GetName()));

        ensure_equals("Title of orig and copy are the same",
                      std::string(copy.GetTitle()),
                      std::string(orig.GetTitle()));

        COMET::IHandle<COMET::IIntegerDatum> copyInt 
            = copy.Get<COMET::IIntegerDatum>("integerDatum");

        ensure_equals("Integer datums have the same titles",
                      std::string(copyInt->GetTitle()),
                      std::string(origInt->GetTitle()));

        for (int i=0; i<3; ++i) {
            ensure_equals("Original integer datum has correct value",
                          (*origInt)[i],i+1);
            ensure_equals("Copy integer datum has correct value",
                          (*copyInt)[i],i+1);
            ensure_equals("Integer datums have the same value",
                          (*copyInt)[0], (*origInt)[0]);
        }

    }

    // Check the copy constructor.
    template<> template <>
    void testTReconBase::test<5> () {
        COMET::IReconCluster orig;
        orig.SetName("name");
        orig.SetTitle("title");
        orig.SetMoments(1,2,3,4,5,6);
        COMET::IRealDatum* iDatum 
            = new COMET::IRealDatum("realDatum","title");
        orig.AddDatum(iDatum);

        COMET::IHandle<COMET::IRealDatum> origReal 
            = orig.Get<COMET::IRealDatum>("realDatum");
        (*origReal)[0] = 1;
        origReal->push_back(2);
        origReal->push_back(3);

        COMET::IReconCluster copy(orig);

        ensure_equals("Name of orig and copy are the same",
                      std::string(copy.GetName()),
                      std::string(orig.GetName()));

        ensure_equals("Title of orig and copy are the same",
                      std::string(copy.GetTitle()),
                      std::string(orig.GetTitle()));

        COMET::IHandle<COMET::IRealDatum> copyReal 
            = copy.Get<COMET::IRealDatum>("realDatum");

        ensure_equals("Real datums have the same titles",
                      std::string(copyReal->GetTitle()),
                      std::string(origReal->GetTitle()));

        for (int i=0; i<3; ++i) {
            ensure_distance("Original real datum has correct value",
                            (*origReal)[i],i+1.0,1E-6);
            ensure_distance("Copy real datum has correct value",
                            (*copyReal)[i],i+1.0,1E-6);
            ensure_equals("Real datums have the same value",
                          (*copyReal)[0], (*origReal)[0]);
        }

    }


};