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

// Unbelievably ugly hack to let me test private methods.
#include "IGeometryId.hxx"
#include "COMETGeomId.hxx"
#include "COMETGeomIdDef.hxx"
#include "ICTHGeomId.hxx"

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

    // Declare the test
    typedef test_group<baseGeomId>::object testGeomId;
    test_group<baseGeomId> groupGeomId("GeomId");

    // Test CTH geometry identifiers.
    template<> template<>
    void testGeomId::test<1> () {
        COMET::IGeometryId gid = COMET::GeomId::CTH::Detector();
        ensure("CTH Detector IsCTH", COMET::GeomId::CTH::IsCTH(gid));

        for (int i=0; i<2; ++i) {
            gid = COMET::GeomId::CTH::Module(i);
            ensure("Module IsCTH", COMET::GeomId::CTH::IsCTH(gid));
            ensure_equals("Module matches id",
                          COMET::GeomId::CTH::GetModule(gid), i);
      int nSegments = pow(2,fabs(COMET::GeomId::Def::CTH::kCTHSegIdMSB -
               COMET::GeomId::Def::CTH::kCTHSegIdLSB));
            for (int j=0; j<nSegments; ++j) {
               for (int k=0; k< 2; ++k) {
                   gid = COMET::GeomId::CTH::Counter(i,j,k,0);
                 ensure("Counter IsCTH", COMET::GeomId::CTH::IsCTH(gid));
                 ensure_equals("Counter matches id",
                          COMET::GeomId::CTH::GetSegmentId(gid), j);
                 ensure_equals("Scintillator flag  matches id",
             COMET::GeomId::CTH::GetScintillator(gid), k);
         }
      }
  }
    }

  /*
    // Test TPC geometry identifiers.
    template<> template<>
    void testGeomId::test<2> () {
        COMET::IGeometryId gid;

        for (int i = 0; i<3; ++i) {
            gid = COMET::GeomId::TPC::Module(i);
            ensure("Module IsTPC", COMET::GeomId::TPC::IsTPC(gid));
            ensure_equals("Module matchs id",
                          COMET::GeomId::TPC::GetModule(gid), i);
        }

        for (int t=0; t<3; ++t) {
            for (int h = 0; h<2; ++h) {
                for (int m = 0; m<12; ++m) {
                    gid = COMET::GeomId::TPC::MicroMega(t,h,m);
                    ensure("MM IsTPC", COMET::GeomId::TPC::IsTPC(gid));
                    ensure_equals("MM TPC matchs id",
                                  COMET::GeomId::TPC::GetMicroMegaTPC(gid), t);
                    ensure_equals("MM half matchs id",
                                  COMET::GeomId::TPC::GetMicroMegaHalf(gid), h);
                    ensure_equals("MM Number matchs id",
                                  COMET::GeomId::TPC::GetMicroMegaNumber(gid), m);
                }
            }
        }

        for (int t=0; t<3; ++t) {
            for (int h = 0; h<2; ++h) {
                for (int m = 0; m<12; ++m) {
                    for (int p=0; p<1728; ++p) {
                        gid = COMET::GeomId::TPC::Pad(t,h,m,p);
                        ensure("Pad IsTPC", COMET::GeomId::TPC::IsTPC(gid));
                        ensure_equals("Pad TPC matchs id",
                                      COMET::GeomId::TPC::GetPadTPC(gid), t);
                        ensure_equals("Pad half matchs id",
                                      COMET::GeomId::TPC::GetPadHalf(gid), h);
                        ensure_equals("Pad MM matchs id",
                                      COMET::GeomId::TPC::GetPadMicroMega(gid),m);
                        ensure_equals("Pad Number matchs id",
                                      COMET::GeomId::TPC::GetPadNumber(gid), p);
                    }
                }
            }
        }
    }
  */
  /*
    // Test FGD geometry identifiers.
    template<> template<>
    void testGeomId::test<3> () {
        COMET::IGeometryId gid;

        for (int i = 0; i<2; ++i) {
            gid = COMET::GeomId::FGD::FGD(i);
            ensure("Module IsFGD", COMET::GeomId::FGD::IsFGD(gid));
            ensure_equals("Module matchs id",
                          COMET::GeomId::FGD::GetFGD(gid), i);
        }

        for (int i=0; i<7; ++i) {
            gid = COMET::GeomId::FGD::Target(i);
            ensure("Target IsFGD", COMET::GeomId::FGD::IsFGD(gid));
            ensure_equals("Target matches id",
                          COMET::GeomId::FGD::GetTarget(gid), i);
        }

        for (int f=0; f<2; ++f) {
            for (int m = 0; m < 14; ++m) {
                for (int xy=0; xy<2; ++xy) {
                    gid = COMET::GeomId::FGD::Layer(f,m,xy);
                    ensure("Layer IsFGD", COMET::GeomId::FGD::IsFGD(gid));
                    ensure_equals("Layer FGD matches id",
                                  COMET::GeomId::FGD::GetLayerFGD(gid), f);
                    ensure_equals("Layer Module matches id",
                                  COMET::GeomId::FGD::GetLayerModule(gid), m);
                    ensure_equals("Layer Number matches id",
                                  COMET::GeomId::FGD::GetLayerNumber(gid), xy);
                }
            }
        }

        for (int f=0; f<2; ++f) {
            for (int m = 0; m < 14; ++m) {
                for (int xy=0; xy<2; ++xy) {
                    for (int b=0; b<100; ++b) {
                        gid = COMET::GeomId::FGD::Bar(f,m,xy,b);
                        ensure("Bar IsFGD", COMET::GeomId::FGD::IsFGD(gid));
                        ensure_equals("Bar FGD matches id",
                                      COMET::GeomId::FGD::GetBarFGD(gid), f);
                        ensure_equals("Bar Module matches id",
                                      COMET::GeomId::FGD::GetBarModule(gid), m);
                        ensure_equals("Bar Layer matches id",
                                      COMET::GeomId::FGD::GetBarLayer(gid), xy);
                        ensure_equals("Bar Number matches id",
                                      COMET::GeomId::FGD::GetBarNumber(gid), b);
                    }
                }
            }
        }
    }
  */
  /*
    // Test DSECal geometry identifiers.
    template<> template<>
    void testGeomId::test<4> () {
        COMET::IGeometryId gid = COMET::GeomId::DSECal::Detector();

        ensure("IsDSECal", COMET::GeomId::DSECal::IsDSECal(gid));

        for (int i=0; i<64; ++i) {
            gid = COMET::GeomId::DSECal::Layer(i);
            ensure("Layer IsDSECal", COMET::GeomId::DSECal::IsDSECal(gid));
            ensure_equals("Layer matches id",
                          COMET::GeomId::DSECal::GetLayer(gid), i);
        }

        for (int i=0; i<64; ++i) {
            gid = COMET::GeomId::DSECal::Radiator(i);
            ensure("Radiator IsDSECal", COMET::GeomId::DSECal::IsDSECal(gid));
            ensure_equals("Radiator matches id",
                          COMET::GeomId::DSECal::GetRadiator(gid), i);
        }

        for (int i=0; i<64; ++i) {
            for (int b=0; b<64; ++b) {
                gid = COMET::GeomId::DSECal::Bar(i,b);
                ensure("Layer IsDSECal", COMET::GeomId::DSECal::IsDSECal(gid));
                ensure_equals("DSECal Bar Layer matches id",
                              COMET::GeomId::DSECal::GetBarLayer(gid), i);
                ensure_equals("DSECal Bar Number matches id",
                              COMET::GeomId::DSECal::GetBarNumber(gid), b);
            }
        }

    }
  */
  /*
    // Test TECal geometry identifiers.
    template<> template<>
    void testGeomId::test<5> () {
        COMET::IGeometryId gid;

        for (int c = 0; c<2; ++c) {
            for (int m = 0; m<3; ++m) {
                gid = COMET::GeomId::TECal::Module(c,m);
                ensure("IsTECal", COMET::GeomId::TECal::IsTECal(gid));
            }
        }

        for (int c = 0; c<2; ++c) {
            for (int m = 0; m<3; ++m) {
                for (int i=0; i<64; ++i) {
                    gid = COMET::GeomId::TECal::Layer(c,m,i);
                    ensure("Layer IsTECal", COMET::GeomId::TECal::IsTECal(gid));
                    ensure_equals("TECal Layer Clam matches id",
                                  COMET::GeomId::TECal::GetLayerClam(gid), c);
                    ensure_equals("TECal Layer Module matches id",
                                  COMET::GeomId::TECal::GetLayerModule(gid), m);
                    ensure_equals("TECal Layer matches id",
                                  COMET::GeomId::TECal::GetLayerNumber(gid), i);
                }
            }
        }

        for (int c = 0; c<2; ++c) {
            for (int m = 0; m<3; ++m) {
                for (int i=0; i<64; ++i) {
                    gid = COMET::GeomId::TECal::Radiator(c,m,i);
                    ensure("Radiator IsTECal", COMET::GeomId::TECal::IsTECal(gid));
                    ensure_equals("TECal Radiator Clam matches id",
                                  COMET::GeomId::TECal::GetRadiatorClam(gid), c);
                    ensure_equals("TECal Radiator Module matches id",
                                  COMET::GeomId::TECal::GetRadiatorModule(gid), m);
                    ensure_equals("TECal Radiator matches id",
                                  COMET::GeomId::TECal::GetRadiatorNumber(gid), i);
                }
            }
        }


        for (int c = 0; c<2; ++c) {
            for (int m = 0; m<3; ++m) {
                for (int i=0; i<64; ++i) {
                    for (int b=0; b<64; ++b) {
                        gid = COMET::GeomId::TECal::Bar(c,m,i,b);
                        ensure("Layer IsTECal",
                               COMET::GeomId::TECal::IsTECal(gid));
                        ensure_equals("TECal Bar Clam matches id",
                                      COMET::GeomId::TECal::GetBarClam(gid), c);
                        ensure_equals("TECal Bar Module matches id",
                                      COMET::GeomId::TECal::GetBarModule(gid), m);
                        ensure_equals("TECal Bar Layer matches id",
                                      COMET::GeomId::TECal::GetBarLayer(gid), i);
                        ensure_equals("TECal Bar Number matches id",
                                      COMET::GeomId::TECal::GetBarNumber(gid), b);
                    }
                }
            }
        }
    }
  */
  /*
    // Test PECal geometry identifiers.
    template<> template<>
    void testGeomId::test<6> () {
        COMET::IGeometryId gid;

        for (int c = 0; c<2; ++c) {
            for (int m = 0; m<3; ++m) {
                gid = COMET::GeomId::PECal::Module(c,m);
                ensure("IsPECal", COMET::GeomId::PECal::IsPECal(gid));
            }
        }

        for (int c = 0; c<2; ++c) {
            for (int m = 0; m<3; ++m) {
                for (int i=0; i<64; ++i) {
                    gid = COMET::GeomId::PECal::Layer(c,m,i);
                    ensure("Layer IsPECal", COMET::GeomId::PECal::IsPECal(gid));
                    ensure_equals("PECal Layer Clam matches id",
                                  COMET::GeomId::PECal::GetLayerClam(gid), c);
                    ensure_equals("PECal Layer Module matches id",
                                  COMET::GeomId::PECal::GetLayerModule(gid), m);
                    ensure_equals("PECal Layer matches id",
                                  COMET::GeomId::PECal::GetLayerNumber(gid), i);
                }
            }
        }

        for (int c = 0; c<2; ++c) {
            for (int m = 0; m<3; ++m) {
                for (int i=0; i<64; ++i) {
                    gid = COMET::GeomId::PECal::Radiator(c,m,i);
                    ensure("Radiator IsPECal", COMET::GeomId::PECal::IsPECal(gid));
                    ensure_equals("PECal Radiator Clam matches id",
                                  COMET::GeomId::PECal::GetRadiatorClam(gid), c);
                    ensure_equals("PECal Radiator Module matches id",
                                  COMET::GeomId::PECal::GetRadiatorModule(gid), m);
                    ensure_equals("PECal Radiator matches id",
                                  COMET::GeomId::PECal::GetRadiatorNumber(gid), i);
                }
            }
        }


        for (int c = 0; c<2; ++c) {
            for (int m = 0; m<3; ++m) {
                for (int i=0; i<64; ++i) {
                    for (int b=0; b<64; ++b) {
                        gid = COMET::GeomId::PECal::Bar(c,m,i,b);
                        ensure("Layer IsPECal",
                               COMET::GeomId::PECal::IsPECal(gid));
                        ensure_equals("PECal Bar Clam matches id",
                                      COMET::GeomId::PECal::GetBarClam(gid), c);
                        ensure_equals("PECal Bar Module matches id",
                                      COMET::GeomId::PECal::GetBarModule(gid), m);
                        ensure_equals("PECal Bar Layer matches id",
                                      COMET::GeomId::PECal::GetBarLayer(gid), i);
                        ensure_equals("PECal Bar Number matches id",
                                      COMET::GeomId::PECal::GetBarNumber(gid), b);
                    }
                }
            }
        }
    }
  */
  /*
    // Test SMRD geometry identifiers.
    template<> template<>
    void testGeomId::test<7> () {
        COMET::IGeometryId gid;

        for (int c = 0; c<2; ++c) {
            for (int y=0; y<8; ++y) {
                for (int ll = 0; ll < 16; ++ll) {
                    for (int s = 0; s<8; ++s) {
                        gid = COMET::GeomId::SMRD::Module(c,y,ll,s);
                        ensure("Module IsSMRD",
                               COMET::GeomId::SMRD::IsSMRD(gid));
                        ensure_equals("SMRD Module Clam matches id",
                                      COMET::GeomId::SMRD::GetModuleClam(gid), c);
                        ensure_equals("SMRD Module Yoke matches id",
                                      COMET::GeomId::SMRD::GetModuleYoke(gid), y);
                        ensure_equals("SMRD Module Layer matches id",
                                      COMET::GeomId::SMRD::GetModuleLayer(gid),ll);
                        ensure_equals("SMRD Module Slot matches id",
                                      COMET::GeomId::SMRD::GetModuleSlot(gid), s);
                    }
                }
            }
        }

        for (int c = 0; c<2; ++c) {
            for (int y=0; y<8; ++y) {
                for (int ll = 0; ll < 16; ++ll) {
                    for (int s = 0; s<8; ++s) {
                        for (int b = 0; b<4; ++b) {
                            gid = COMET::GeomId::SMRD::Bar(c,y,ll,s,b);
                            ensure("Bar IsSMRD",
                                   COMET::GeomId::SMRD::IsSMRD(gid));
                            ensure_equals("SMRD Bar Clam matches id",
                                          COMET::GeomId::SMRD::GetBarClam(gid), c);
                            ensure_equals("SMRD Bar Yoke matches id",
                                          COMET::GeomId::SMRD::GetBarYoke(gid), y);
                            ensure_equals("SMRD Bar Layer matches id",
                                          COMET::GeomId::SMRD::GetBarLayer(gid),
                                          ll);
                            ensure_equals("SMRD Bar Slot matches id",
                                          COMET::GeomId::SMRD::GetBarSlot(gid), s);
                            ensure_equals("SMRD Bar Number matches id",
                                          COMET::GeomId::SMRD
                                          ::GetBarNumber(gid),b);
                        }
                    }
                }
            }
        }
    }
  */
};