//
// $Id: BaseGeometry.cpp,v 1.13 2006/01/10 21:14:10 snyder Exp $
//
// File: BaseGeometry.cc
// Purpose: 
// Created: 28-OCT-1997   John Hobbs
//
// $Revision: 1.13 $
//
//

// Include files
#include <string>
#include <rcp/RCP.hpp>
#include <rcp/XRCP.hpp>
#include <d0stream/d0StreamFactory.hpp>
#include <d0stream/d0Stream.hpp>
#include <d0stream/d0Key.hpp>

#include "geometry_system/utils/GeometryIO.hpp"
#include "BaseGeometry.hpp"
#include <silicon_geometry/base/SiBaseGeometry.hpp>     //Get rid of these later
#include <cft_geometry/base/CftBaseGeometry.hpp>        // when d0om::refcast doesn't
#include <calorimeter_geometry/base/CalBaseGeometry.hpp>// need the complete class def 
#include <cps_geometry/base/CpsBaseGeometry.hpp>
#include <fps_geometry/base/FPSBaseGeometry.hpp>
#include <fps_geometry/base/FPSUnit.hpp>
#include <muon_geometry/base/MuoBaseGeometry.hpp>

using namespace std;
using namespace edm;
using namespace dgs;

  ///  Constructor given sub-detector geometries explicitly
  BaseGeometry::BaseGeometry(
	       const d0_Ref<SiBaseGeometry>& si, 
	       const d0_Ref<CftBaseGeometry>& cft, 
	       const d0_Ref<CalBaseGeometry>& cal,
	       const d0_Ref<CpsBaseGeometry>& cps,
	       const d0_Ref<FPSBaseGeometry>& fps,
	       const d0_Ref<MuoBaseGeometry>& muon):
    _silicon(si), _cft(cft), _cal(cal), _cps(cps), _fps(fps), _muon(muon),
    _constants_version(-1)
    {}

BaseGeometry::~BaseGeometry(){}

// The virtual constructor
d0_Ref<BaseGeometry> BaseGeometry::build_default(RCP *rinit)
//
// Purpose: Construct a complete D0 geometry from RCP (or default)
// Arguements: rinit - The RCP for initialization
// Returns:    A d0 geometry
//
{
  // Create an empty geometry and then fill it...
  d0_Ref<BaseGeometry> iam = new BaseGeometry;

  // with each detector in turn
  string dettag;
  try {
    // silicon...
    dettag = "SMT";
    if( rinit->getBool("useSmt" ) ) {
      RCP SmtRCP = rinit->getRCP("SmtBaseGeometry");
      iam->_silicon = SiBaseGeometry::build_default(&SmtRCP);
      iam->_silicon->set_constants_version(-1);
    }

    // fiber tracker
    dettag = "CFT";
    if( rinit->getBool("useCft") ) {
      RCP CftRCP = rinit->getRCP("CftBaseGeometry");
      iam->_cft = CftBaseGeometry::build_default(&CftRCP);
      iam->_cft->set_constants_version(-1);
    }

    // with calorimeter (no RCP yet)...
    dettag = "CAL";
    if( rinit->getBool("useCal") ) {
      iam->_cal = CalBaseGeometry::build_default();
      iam->_cal->set_constants_version(-1);
    }

    // with CPS
    dettag = "CPS";
    if( rinit->getBool("useCps") ) {
      RCP CpsRCP = rinit->getRCP("CpsBaseGeometry");
      iam->_cps = CpsBaseGeometry::build_default(&CpsRCP);
      iam->_cps->set_constants_version(-1);
    }

    // with FPS (this should tie to EC's, but it currently does not, so
    // life is a bit more complicated
    dettag = "FPS";
    if( rinit->getBool("useFPS") ) {
      RCP nFpsRCP = rinit->getRCP("FPSNorthGeometry");
      RCP sFpsRCP = rinit->getRCP("FPSSouthGeometry");
      iam->_fps = new FPSBaseGeometry(&nFpsRCP,&sFpsRCP);
      iam->_fps->set_constants_version(-1);
    }

    // with muon
    dettag = "Muon";
    if( rinit->getBool("useMuo") ) {
      RCP MuonRCP = rinit->getRCP("MuoBaseGeometry");
      iam->_muon = MuoBaseGeometry::build_default(&MuonRCP);
      iam->_muon->set_constants_version(-1);
    }
    return iam;
  }

  catch(XRCPNotFound RCPError) {
    clog << RCPError.logMessage() << endl;
    return NULL;
  }

}

// Write a geometry instance to the given file
bool BaseGeometry::writeGeometry(d0_Ref<BaseGeometry> det, string fname, string type)
{
  return dgs::GeometryIO::writeGeometry(det,fname,type);
}

// Read a geometry instance from the given file
d0_Ref<BaseGeometry> BaseGeometry::readGeometry(string fname, string type)
{
  d0_Ref_Any top = dgs::GeometryIO::readGeometry(fname,type,"BaseGeometry");
  d0_Ref<BaseGeometry> theDetector = d0om::refcast<BaseGeometry>(top);
  return theDetector;
}
                                             
// Constant geometry accessors

d0_Ref<const SiBaseGeometry> BaseGeometry::get_silicon() const 
  { return d0om::refcast<const SiBaseGeometry> (_silicon); }
d0_Ref<const CftBaseGeometry> BaseGeometry::get_cft() const
  { return d0om::refcast<const CftBaseGeometry> (_cft); }
d0_Ref<const CalBaseGeometry> BaseGeometry::get_calorimeter() const
  { return d0om::refcast<const CalBaseGeometry> (_cal); }
d0_Ref<const CpsBaseGeometry> BaseGeometry::get_cps() const
  { return d0om::refcast<const CpsBaseGeometry> (_cps); }
d0_Ref<const FPSBaseGeometry> BaseGeometry::get_fps() const
  { return d0om::refcast<const FPSBaseGeometry> (_fps); }
d0_Ref<const MuoBaseGeometry> BaseGeometry::get_muon() const
  { return d0om::refcast<const MuoBaseGeometry> (_muon); }

// Mutable geometry accessors

d0_Ref<SiBaseGeometry> BaseGeometry::get_mutable_silicon() { return _silicon; }
d0_Ref<CftBaseGeometry> BaseGeometry::get_mutable_cft() { return _cft; }
d0_Ref<CalBaseGeometry> BaseGeometry::get_mutable_calorimeter() {return _cal; }
d0_Ref<CpsBaseGeometry> BaseGeometry::get_mutable_cps() { return _cps; }
d0_Ref<FPSBaseGeometry> BaseGeometry::get_mutable_fps() { return _fps; }
d0_Ref<MuoBaseGeometry> BaseGeometry::get_mutable_muon() { return _muon; }

int BaseGeometry::set_constants_version( int serial_number ) 
{
  int old = _constants_version;
  _constants_version = serial_number;
  return old;
}

// Complete the GeometryElement interface
const list<GeometryElement*> BaseGeometry::get_children()
//
// Purpose: Return the list of subdetectors
//
{
  list<GeometryElement*> kids;
  if( _silicon ) kids.push_back(_silicon.ptr());
  if( _cft ) kids.push_back(_cft.ptr());
  if( _cal ) kids.push_back(_cal.ptr());
  if( _cps ) kids.push_back(_cps.ptr());
  if( _fps ) {
    kids.push_back(_fps->get_mutable_north());
    kids.push_back(_fps->get_mutable_south());
  }
  if( _muon ) kids.push_back(_muon.ptr());
  return kids;
}


// A dump

ostream& operator <<( ostream& os, const BaseGeometry& me)
//
// Purpose: Print a text dump of a geometry tree.
//
{
  os << "BaseGeometry at " << me.get_position() << endl;
  if( me._silicon )  os << *me._silicon << endl;
  if( me._cft ) os << *me._cft << endl;
  if( me._cal ) os << *me._cal << endl;
  if( me._cps ) os << *me._cps << endl;
  if( me._fps ) os << *me._fps << endl;
  if( me._muon ) os << *me._muon << endl;
  return os;
}

#include "d0_geometry/base/all_refs.hpp"