//
// $Id: SiBaseGeometry.cpp,v 1.15 2005/04/03 15:36:36 shfu Exp $
//
// File: SiBaseGeometry.cc
// Purpose: 
// Created: 09-OCT-1997   John Hobbs
//
// Jan 31, 2005 by Shaohua Fu
// added Layer0 // SFL0_Jan_2005
//
// $Revision: 1.15 $
//

// Include files
#include <iostream>
#include "SiBaseGeometry.hpp"
#include <geometry_system/components/CartesianCoordinate.hpp>
#include <rcp/RCP.hpp>
#include "d0_util/formatting.hpp"

// Global definitions
using namespace std;
using namespace dgs;
using edm::RCP;

// SiBaseGeometry::SiBaseGeometry(int nc, const float* center_zpos, // cmt.out SFL0_Jan_2005
// 			        const SiCenter* proto_center,
// 			       int ne, const float* end_zpos,
// 			       const SiEnd* proto_end)
// {

//   const SiCenter* use_center;
//   const SiEnd* use_end;

//   // Position the center tracker.
//   int i;
//   if( proto_center ) use_center = proto_center;
//   else use_center = new SiCenter;
//   for( i=0 ; i<nc ; i++ ) {
//     _centers.push_back(*use_center);
//     CartesianCoordinate pos(0.0,0.0,center_zpos[i]);
//     position_child_at(pos,_centers[i]);
//   }
//   if( !proto_center ) delete use_center;

//   // Position the end trackers.
//   if( proto_end ) use_end = proto_end;
//   else use_end = new SiEnd;
//   for( i=0 ; i<ne ; i++ ) {
//     _ends.push_back(*use_end);
//     CartesianCoordinate pos(0.0,0.0,end_zpos[i]);
//     position_child_at(pos,_ends[i]);
//   }
//   if( !proto_end ) delete use_end;

// }

SiBaseGeometry::SiBaseGeometry(int nc, const float* center_zpos, // added SFL0_Jan_2005
			        const SiCenter* proto_center,
			       int ne, const float* end_zpos,
			        const SiEnd* proto_end,
			       int nl0, const float* l0_zpos, // added SFL0_Jan_2005
			        const SiL0* proto_l0) // added SFL0_Jan_2005
{

  const SiCenter* use_center;
  const SiEnd* use_end;
  const SiL0* use_l0; // added SFL0_Jan_2005

  // Position the center tracker.
  int i;
  if( proto_center ) use_center = proto_center;
  else use_center = new SiCenter;
  for( i=0 ; i<nc ; i++ ) {
    _centers.push_back(*use_center);
    CartesianCoordinate pos(0.0,0.0,center_zpos[i]);
    position_child_at(pos,_centers[i]);
  }
  if( !proto_center ) delete use_center;

  // Position the end trackers.
  if( proto_end ) use_end = proto_end;
  else use_end = new SiEnd;
  for( i=0 ; i<ne ; i++ ) {
    _ends.push_back(*use_end);
    CartesianCoordinate pos(0.0,0.0,end_zpos[i]);
    position_child_at(pos,_ends[i]);
  }
  if( !proto_end ) delete use_end;

  // added SFL0_Jan_2005
  // Position the layer0 trackers.
  if( proto_l0 ) use_l0 = proto_l0;
  else use_l0 = new SiL0;
  for( i=0 ; i<nl0 ; i++ ) {
    _l0s.push_back(*use_l0);
    CartesianCoordinate pos(0.0,0.0,l0_zpos[i]);
    position_child_at(pos,_l0s[i]);
  }
  if( !proto_l0 ) delete use_l0;
  // end of SFL0_Jan_2005

}



// SiBaseGeometry::SiBaseGeometry(int nc, const float* center_zpos, // cmt.out SFL0_Jan_2005
// 			        const vector<SiCenter>& centers, 
// 			       int ne, const float* end_zpos,
// 			        const vector<SiEnd>& ends)
// {
//   // Position the center.
//   int i;
//   for( i=0 ; i<nc ; i++ ) {
//     _centers.push_back(centers[i]);
//     CartesianCoordinate pos(0.0,0.0,center_zpos[i]);
//     position_child_at(pos,_centers[i]);
//   }

//   // Position the ends.
//   for( i=0 ; i<ne ; i++ ) {
//     _ends.push_back(ends[i]);
//     CartesianCoordinate pos(0.0,0.0,end_zpos[i]);
//     position_child_at(pos,_ends[i]);
//   }
// }

SiBaseGeometry::SiBaseGeometry(int nc, const float* center_zpos, // added SFL0_Jan_2005
			        const vector<SiCenter>& centers, 
			       int ne, const float* end_zpos,
			        const vector<SiEnd>& ends,
			       int nl0, const float* l0_zpos, // added SFL0_Jan_2005
			        const vector<SiL0>& l0s) // added SFL0_Jan_2005
{
  // Position the center.
  int i;
  for( i=0 ; i<nc ; i++ ) {
    _centers.push_back(centers[i]);
    CartesianCoordinate pos(0.0,0.0,center_zpos[i]);
    position_child_at(pos,_centers[i]);
  }

  // Position the ends.
  for( i=0 ; i<ne ; i++ ) {
    _ends.push_back(ends[i]);
    CartesianCoordinate pos(0.0,0.0,end_zpos[i]);
    position_child_at(pos,_ends[i]);
  }

  // added SFL0_Jan_2005
  // Position the layer0.
  for( i=0 ; i<nl0 ; i++ ) {
    _l0s.push_back(l0s[i]);
    CartesianCoordinate pos(0.0,0.0,l0_zpos[i]);
    position_child_at(pos,_l0s[i]);
  }
  // end of SFL0_Jan_2005
}

void SiBaseGeometry::add_L0(SiL0 *theL0, double z_L0) // added SFL0_Jan_2005
{

  _l0s.clear();

  _l0s.push_back(*theL0);
  CartesianCoordinate pos(0.0,0.0,z_L0);
  position_child_at(pos,_l0s[0]);

}


// Version numbering
int SiBaseGeometry::set_constants_version(int new_version) {
  int previous = _constants_version;
  _constants_version = new_version;
  return previous;
}


// Accessors
  int i;
const list<GeometryElement*> SiBaseGeometry::get_children()
{
  list<GeometryElement*> kids;
  for( i=0 ; i<_centers.size() ; i++ ) kids.push_back( &_centers[i] );
  for( i=0 ; i<_ends.size() ; i++ ) kids.push_back( &_ends[i] );
  for( i=0 ; i<_l0s.size() ; i++ ) kids.push_back( &_l0s[i] ); // added SFL0_Jan_2005
  return kids;
}

std::ostream& operator <<(std::ostream& os, const SiBaseGeometry& me)
{
  os << "SiBaseGeometry at " << me.get_position() << endl
     << " has " << me.get_center_count() << " centers and "
     << me.get_end_count() << " ends." << endl;
  os << "                  and " << me.get_l0_count() << " layer0." << endl; // added SFL0_Jan_2005
  for( i=0 ; i<me._centers.size() ; i++ ) os<<"  "<<me._centers[i]<<endl;
  for( i=0 ; i<me._ends.size() ; i++ ) os<<"    "<<me._ends[i]<<endl;
  for( i=0 ; i<me._l0s.size() ; i++ ) os<<"      "<<me._l0s[i]<<endl; // added SFL0_Jan_2005
  return os;
}

//-----------------------------------------------------------------------------
//
//  The virtual constructor to build the default geometry...
//
//-----------------------------------------------------------------------------

#include "SiBaseGeometryRCP.hpp"

d0_Ref<SiBaseGeometry> SiBaseGeometry::build_default(RCP* RCPinit/*NULL*/)
//
// Purpose: Construct the default geometry described by RCPinit.
//
{
  int i;

  // Is this just a dummy call?
  if( RCPinit == (RCP*)NULL ) return new SiBaseGeometry;
  cout << "Constructing default silicon detector from RCP" << endl;

  // First define the necessary ladder types
  int nladder_types = RCPinit->getInt("nladder_types");
  vector<SiLadderType> ladderTypes;
  for( i=0 ; i<nladder_types ; i++ ) 
    ladderTypes.push_back(SiLadderType(*RCPinit,i+1));

  // Now build the individual layers
  int nlayer_types = RCPinit->getInt("nlayer_types");
  vector<SiLayerType> layerTypes;
  for( i=0 ; i<nlayer_types ; i++ ) 
    layerTypes.push_back(SiLayerType(*RCPinit,i+1,&ladderTypes));

  // and collect them into barrels
  int nbarrel_types = RCPinit->getInt("nbarrel_types");
  vector<SiBarrelType> barrelTypes;
  for( i=0 ; i<nbarrel_types ; i++ ) 
    barrelTypes.push_back(SiBarrelType(*RCPinit,i+1,&layerTypes));

  // Define the necessary wedge types
  int nwedge_types = RCPinit->getInt("nwedge_types");
  vector<SiWedgeType> wedgeTypes;
  for( i=0 ; i<nwedge_types ; i++ ) 
    wedgeTypes.push_back(SiWedgeType(*RCPinit,i+1));

  // collect the wedges into wedgeholders
  int nwedgeholder_types = RCPinit->getInt("nwedgeholder_types");
  vector<SiWedgeHolderType> wedgeholderTypes;
  for( i=0 ; i<nwedgeholder_types ; i++ ) 
    wedgeholderTypes.push_back(SiWedgeHolderType(*RCPinit,i+1,&wedgeTypes));

  // collect them into disks
  int ndisk_types = RCPinit->getInt("ndisk_types");
  vector<SiDiskType> diskTypes;
  for( i=0 ; i<ndisk_types ; i++ ) 
    diskTypes.push_back(SiDiskType(*RCPinit,i+1,&wedgeholderTypes));

  // collect the barrels and disks into centrals
  int ncentral_types = RCPinit->getInt("ncentral_types");
  vector<SiCentralType> centralTypes;
  for( i=0 ; i<ncentral_types ; i++ ) { 
    centralTypes.push_back(SiCentralType(*RCPinit,i+1,&barrelTypes,&diskTypes));
  }

  // collect the centrals into centers
  int ncenter_types = RCPinit->getInt("ncenter_types");
  vector<SiCenterType> centerTypes;
  for( i=0 ; i<ncenter_types ; i++ ) { 
    centerTypes.push_back(SiCenterType(*RCPinit,i+1,&centralTypes));
  }

  // collect the disks into ends
  int nend_types = RCPinit->getInt("nend_types");
  vector<SiEndType> endTypes;
  for( i=0 ; i<nend_types ; i++ ) 
    endTypes.push_back(SiEndType(*RCPinit,i+1,&diskTypes));


  // added SFL0_Jan_2005
  // collect the barrels into layer0
  int nl0_types = RCPinit->getInt("nl0_types");
  vector<SiL0Type> l0Types;
  for( i=0 ; i<nl0_types ; i++ ) {
    l0Types.push_back(SiL0Type(*RCPinit,i+1,&barrelTypes));
  }
  // end of SFL0_Jan_2005


  // position the center and end tracker
  int ncenters = RCPinit->getInt("ncenters");      // Center
  vector<SiCenter> theCenters;
  float* zpos_c = new float[ncenters];
  for(i=0 ; i<ncenters ; i++ ) {
    string baseid = "center" + d0_util::format_number(i+1) + "_";
    zpos_c[i] = RCPinit->getFloat(baseid+"z");
    int cid = RCPinit->getInt(baseid+"type");
    if( cid>0 && cid<=centerTypes.size() ) {
      const SiCenter* requestedCenter = (centerTypes[cid-1]).instance();
      if( requestedCenter ) theCenters.push_back(*requestedCenter);
      else std::cerr << "ERROR: Center ID = "<<cid<<" does not exist.  Skipping" << endl;
    }
    else std::cerr<<"ERROR: Center ID = "<<cid<<" out-of-range. Skipping"<<endl;
  }

  int nends = RCPinit->getInt("nends");      // End
  vector<SiEnd> theEnds;
  float* zpos_e = new float[nends];
  for( i=0 ; i<nends ; i++ ) {
    string baseid = "end" + d0_util::format_number(i+1) + "_";
    zpos_e[i] = RCPinit->getFloat(baseid+"z");
    int eid = RCPinit->getInt(baseid+"type");
    if( eid>0 && eid<=endTypes.size() ) {
      const SiEnd* requestedEnd = (endTypes[eid-1]).instance();
      if( requestedEnd ) theEnds.push_back(*requestedEnd);
      else std::cerr << "ERROR: End ID = "<<eid<<" does not exist.  Skipping" << endl;
    }
    else std::cerr<<"ERROR: End ID = "<<eid<<" out-of-range. Skipping"<<endl;
  }


  // added SFL0_Jan_2005
  // position the layer0 tracker
  int nl0s = RCPinit->getInt("nlayer0s");      // Layer0
  vector<SiL0> theL0s;
  float* zpos_l0 = new float[nl0s];
  for( i=0 ; i<nl0s ; i++ ) {
    string baseid = "l0" + d0_util::format_number(i+1) + "_";
    zpos_l0[i] = RCPinit->getFloat(baseid+"z");
    int l0id = RCPinit->getInt(baseid+"type");
    if( l0id>0 && l0id<=l0Types.size() ) {
      const SiL0* requestedL0 = (l0Types[l0id-1]).instance();
      if( requestedL0 ) theL0s.push_back(*requestedL0);
      else std::cerr << "ERROR: L0 ID = "<<l0id<<" does not exist.  Skipping" << endl;
    }
    else std::cerr<<"ERROR: L0 ID = "<<l0id<<" out-of-range. Skipping"<<endl;
  }
  // end of SFL0_Jan_2005



  d0_Ref<SiBaseGeometry> defaultGeometry = new SiBaseGeometry;
//   defaultGeometry = new SiBaseGeometry(ncenters,zpos_c,theCenters, // cmt.out SFL0_Jan_2005
//   				       nends,zpos_e,theEnds);

  defaultGeometry = new SiBaseGeometry(ncenters,zpos_c,theCenters, // added SFL0_Jan_2005
  				       nends,zpos_e,theEnds,
				       nl0s,zpos_l0,theL0s); // added SFL0_Jan_2005

  delete zpos_c;
  delete zpos_e;
  delete zpos_l0; // added SFL0_Jan_2005

  // Well...
  return defaultGeometry;
}

bool operator==(const SiBaseGeometry& lhs, const SiBaseGeometry &rhs)
{
  if( lhs.get_position() != rhs.get_position() ) return false;
  if( lhs._centers.size() != rhs._centers.size() ) return false;
  if( lhs._ends.size() != rhs._ends.size() ) return false;
  if( lhs._l0s.size() != rhs._l0s.size() ) return false; // added SFL0_Jan_2005
  return true;
}

bool operator!=(const SiBaseGeometry& lhs, const SiBaseGeometry &rhs)
{
  return !(rhs==lhs);
}