#include <iostream>
using std::cout;
using std::cerr;
using std::cin;
using std::endl;


#include <valarray>
using std::valarray;

#include <fstream>
using std::fstream;

#include <string>
using std::string;

#include <list>
using std::list;

#include <map>
using std::multimap;

#include <cmath>

#include "TObject.h"  
#include "TVector3.h"
#include "TRandom.h"
#include "Math/Vector3D.h"
using ROOT::Math::XYZVector;

#include "Math/Point3D.h"
using ROOT::Math::XYZPoint;

#include "Math/Transform3D.h"
using ROOT::Math::Transform3D;

#include "Math/RotationX.h"
using ROOT::Math::RotationX;
#include "Math/RotationY.h"
using ROOT::Math::RotationY;
#include "Math/RotationZ.h"
using ROOT::Math::RotationZ;
#include "Math/Rotation3D.h"
using ROOT::Math::Rotation3D;

#include "PndDrcPhoton.h"
#include "PndDrcOptReflAbs.h"
#include "PndDrcSurfAbs.h"
#include "PndDrcOptMatAbs.h"
#include "PndDrcOptDev.h"
#include "PndDrcOptDevSys.h"


//----------------------------------------------------------------------
PndDrcOptDevSys::PndDrcOptDevSys()
{
  m_copyNumber  = 0;
  m_name        = "unnamed";
  m_verbosity   = 0;

  m_listDev.clear();
  m_listSysOri.clear();
  m_listSysOriCopy.clear();
  m_listSysOri1Coupling.clear();
  m_listSysOri2Coupling.clear();
  m_listSysOri1CopyCoupling.clear();
  m_listSysOri2CopyCoupling.clear();
  m_listDev1Coupling.clear();
  m_listDev2Coupling.clear();
  m_listDev1CopyCoupling.clear();
  m_listDev2CopyCoupling.clear();
  m_listSurf1Coupling.clear();
  m_listSurf2Coupling.clear();
  m_listSurf1CopyCoupling.clear();
  m_listSurf2CopyCoupling.clear();
}
//----------------------------------------------------------------------
void PndDrcOptDevSys::copy(const PndDrcOptDevSys& d)
{
  m_copyNumber        = d.m_copyNumber;
  m_name              = d.m_name;
  m_verbosity         = d.m_verbosity;

  list<PndDrcOptDev*>::const_iterator idev;
  list<string>::const_iterator        isys_ori;
  list<int>::const_iterator           isys_ori_copy;
  list<string>::const_iterator        isys_ori1;
  list<string>::const_iterator        isys_ori2;
  list<int>::const_iterator           isys_ori1_copy;
  list<int>::const_iterator           isys_ori2_copy;
  list<string>::const_iterator        idev1;
  list<string>::const_iterator        idev2;
  list<int>::const_iterator           idev1_copy;
  list<int>::const_iterator           idev2_copy;
  list<string>::const_iterator        isurf1;
  list<string>::const_iterator        isurf2;
  list<int>::const_iterator           isurf1_copy;
  list<int>::const_iterator           isurf2_copy;


  for(idev=d.m_listDev.begin(),
	isys_ori=d.m_listSysOri.begin(),
	isys_ori_copy=d.m_listSysOriCopy.begin(); 
      idev != d.m_listDev.end(); 
      ++idev,
	++isys_ori,
	++isys_ori_copy) 
    {
      const PndDrcOptDev* tmp = (*idev);
      PndDrcOptDev* tmp1 = tmp->clone();
      m_listDev.push_back(tmp1);
      m_listSysOri.push_back((*isys_ori));
      m_listSysOriCopy.push_back((*isys_ori_copy));
    }

  
  // copy couplings


  for(idev1            = d.m_listDev1Coupling.begin(),  
	idev2          = d.m_listDev2Coupling.begin(),
	idev1_copy     = d.m_listDev1CopyCoupling.begin(),  
	idev2_copy     = d.m_listDev2CopyCoupling.begin(),
	isurf1         = d.m_listSurf1Coupling.begin(), 
	isurf2         = d.m_listSurf2Coupling.begin(),
	isurf1_copy    = d.m_listSurf1CopyCoupling.begin(), 
	isurf2_copy    = d.m_listSurf2CopyCoupling.begin(),
	isys_ori1      = d.m_listSysOri1Coupling.begin(),
	isys_ori2      = d.m_listSysOri2Coupling.begin(),
	isys_ori1_copy = d.m_listSysOri1CopyCoupling.begin(),
	isys_ori2_copy = d.m_listSysOri2CopyCoupling.begin();
      idev1 != d.m_listDev1Coupling.end();
      ++idev1,
	++idev2,
	++idev1_copy,
	++idev2_copy,
	++isurf1,
	++isurf2,
	++isurf1_copy,
	++isurf2_copy,
	++isys_ori1,
	++isys_ori2,
	++isys_ori1_copy,
	++isys_ori2_copy) 
    {
      coupleDevice1((*idev1),(*idev2),
		    (*isurf1),(*isurf2),
		    (*isys_ori1),(*isys_ori2),
		    (*idev1_copy),(*idev2_copy),
		    (*isurf1_copy),(*isurf2_copy),
		    (*isys_ori1_copy),(*isys_ori2_copy));
    }
  

}
//----------------------------------------------------------------------
PndDrcOptDevSys::PndDrcOptDevSys(const PndDrcOptDevSys& d)
{
  if (d.m_verbosity>=1) cout<<"  PndDrcOptDevSys::PndDrcOptDevSys"
			    <<"(const PndDrcOptDevSys&) name,copy: "
			    <<d.m_name<<" "<<d.m_copyNumber<<endl;
  copy(d);
}
//----------------------------------------------------------------------
PndDrcOptDevSys& PndDrcOptDevSys::operator=(const PndDrcOptDevSys& d)
{
  if (d.m_verbosity>=1) cout<<"  PndDrcOptDevSys::operator="
			    <<"(const PndDrcOptDevSys&) name,copy: "
			    <<d.m_name<<" "<<d.m_copyNumber<<endl;
  if (&d != this) copy(d);
  return *this;

}
//----------------------------------------------------------------------
PndDrcOptDevSys::~PndDrcOptDevSys()
{
  list<PndDrcOptDev*>::const_iterator idev;

  for(idev=m_listDev.begin(); idev != m_listDev.end(); ++idev) 
    {
      delete (*idev);
   }
}
//----------------------------------------------------------------------
PndDrcOptDevSys* PndDrcOptDevSys::clone() const
{
  return new PndDrcOptDevSys(*this);
}
//----------------------------------------------------------------------
void PndDrcOptDevSys::setCopyNumber(int i)
{
  setNameCopyNumber(name(),i);
}
//----------------------------------------------------------------------
void PndDrcOptDevSys::setName(string name1)
{
  setNameCopyNumber(name1,copyNumber());
}
//----------------------------------------------------------------------
void PndDrcOptDevSys::setNameCopyNumber(string name1, int icopy)
{
  list<PndDrcOptDev*>::iterator idev;
  list<string>::iterator isys;
  list<int>::iterator isys_copy;


  // replace in content lists
  for(idev=m_listDev.begin(),
	isys=m_listSysOri.begin(), 
	isys_copy=m_listSysOriCopy.begin(); 
      idev != m_listDev.end(); 
      ++idev,
	++isys, 
	++isys_copy) 
    {
      if ((*isys)==name() && (*isys_copy)==copyNumber())
	{
	  (*isys_copy) = icopy;
	  (*isys)      = name1;
	}    
    }
  
  // replace name in coupling lists

  list<string>::iterator        isys_ori1;
  list<string>::iterator        isys_ori2;
  list<int>::iterator           isys_ori1_copy;
  list<int>::iterator           isys_ori2_copy;

  for(isys_ori1      = m_listSysOri1Coupling.begin(),
	isys_ori2      = m_listSysOri2Coupling.begin(),
	isys_ori1_copy = m_listSysOri1CopyCoupling.begin(),
	isys_ori2_copy = m_listSysOri2CopyCoupling.begin();
      isys_ori1 != m_listSysOri1Coupling.end();
	++isys_ori1,
	++isys_ori2,
	++isys_ori1_copy,
	++isys_ori2_copy) 
    { 
      if ((*isys_ori1)==name() && (*isys_ori1_copy)==copyNumber())
	{
	  (*isys_ori1_copy) = icopy;
	  (*isys_ori1)      = name1;
	}    
      if ((*isys_ori2)==name() && (*isys_ori2_copy)==copyNumber())
	{
	  (*isys_ori2_copy) = icopy;
	  (*isys_ori2)      = name1;
	}
    }

  m_copyNumber = icopy;
  m_name       = name1;

}
//----------------------------------------------------------------------
void PndDrcOptDevSys::addDevice(const PndDrcOptDev& dev)
{
  addDevice(dev,name(),copyNumber());
}
//----------------------------------------------------------------------
void PndDrcOptDevSys::addDevice(const PndDrcOptDev& dev, string sys_ori, int sys_ori_copy)
{
  if (m_verbosity>=1) cout<<"  PndDrcOptDevSys::addDevice:"
			    <<" name,copy = "
			    <<dev.name()<<" "<<dev.copyNumber()<<endl;
  PndDrcOptDev* tmp = dev.clone();
  m_listDev.push_back(tmp);
  m_listSysOri.push_back(sys_ori);
  m_listSysOriCopy.push_back(sys_ori_copy);
  

}
//----------------------------------------------------------------------
void PndDrcOptDevSys::addDeviceSystem(const PndDrcOptDevSys& sys)
{
  if (m_verbosity>=1) cout<<"  PndDrcOptDevSys::addDeviceSystem: "
			    <<" name,copy = "
			    <<sys.name()<<" "<<sys.copyNumber()<<endl;
  

  PndDrcOptDevSys* tmp = sys.clone();
  
  list<PndDrcOptDev*>::const_iterator idev;
  for (idev =  tmp->deviceList().begin(); 
       idev != tmp->deviceList().end();
       ++idev)
    {
      addDevice(*(*idev),sys.name(),sys.copyNumber());
    }
  
  // copy couplings
  list<string>::const_iterator        isys_ori1;
  list<string>::const_iterator        isys_ori2;
  list<int>::const_iterator           isys_ori1_copy;
  list<int>::const_iterator           isys_ori2_copy;
  list<string>::const_iterator        idev1;
  list<string>::const_iterator        idev2;
  list<int>::const_iterator           idev1_copy;
  list<int>::const_iterator           idev2_copy;
  list<string>::const_iterator        isurf1;
  list<string>::const_iterator        isurf2;
  list<int>::const_iterator           isurf1_copy;
  list<int>::const_iterator           isurf2_copy;


  for(idev1            = tmp->m_listDev1Coupling.begin(),  
	idev2          = tmp->m_listDev2Coupling.begin(),
	idev1_copy     = tmp->m_listDev1CopyCoupling.begin(),  
	idev2_copy     = tmp->m_listDev2CopyCoupling.begin(),
	isurf1         = tmp->m_listSurf1Coupling.begin(), 
	isurf2         = tmp->m_listSurf2Coupling.begin(),
	isurf1_copy    = tmp->m_listSurf1CopyCoupling.begin(), 
	isurf2_copy    = tmp->m_listSurf2CopyCoupling.begin(),
	isys_ori1      = tmp->m_listSysOri1Coupling.begin(),
	isys_ori2      = tmp->m_listSysOri2Coupling.begin(),
	isys_ori1_copy = tmp->m_listSysOri1CopyCoupling.begin(),
	isys_ori2_copy = tmp->m_listSysOri2CopyCoupling.begin();
      idev1 != tmp->m_listDev1Coupling.end();
      ++idev1,
	++idev2,
	++idev1_copy,
	++idev2_copy,
	++isurf1,
	++isurf2,
	++isurf1_copy,
	++isurf2_copy,
	++isys_ori1,
	++isys_ori2,
	++isys_ori1_copy,
	++isys_ori2_copy) 
    {
      coupleDevice1((*idev1),(*idev2),
		    (*isurf1),(*isurf2),
		    (*isys_ori1),(*isys_ori2),
		    (*idev1_copy),(*idev2_copy),
		    (*isurf1_copy),(*isurf2_copy),
		    (*isys_ori1_copy),(*isys_ori2_copy));
    }
  


}

//----------------------------------------------------------------------
void PndDrcOptDevSys::embedDevice(PndDrcOptDev& d_daughter, PndDrcOptDev& d_mother)
{
  if (m_verbosity>=1) cout<<"  PndDrcOptDevSys::embedDevice:  name,copy = "
			  <<d_daughter.name()<<" "<<d_daughter.copyNumber()<<" in "
			  <<d_mother.name()<<" "<<d_mother.copyNumber()<<endl;;


  // add daughter
  addDevice(d_daughter);

  // create clones of surfaces of daughter and add them to mother
  // and connect them

  list<PndDrcSurfAbs*>::const_iterator isurf;
  for (isurf=d_daughter.surfaceList().begin(); 
       isurf != d_daughter.surfaceList().end(); ++isurf)
    {

      
      if (!(*isurf)->internal()) // internal surfaces are not connected.
	{
	  const PndDrcSurfAbs* tmp  = (*isurf);
	  PndDrcSurfAbs*       tmp1 = tmp->clone();
	  // Append an "_embedded" to the new surface name which is 
	  // in moment that of the surface name of the daughter
	  tmp1->setName(tmp->name()+"_embedded");


	  // find d_mother which has after adding a different pointer...
	  
	  PndDrcOptDev* d_mother1=0;
	  
	  list<PndDrcOptDev*>::const_iterator idev;
	  for(idev=m_listDev.begin(); idev != m_listDev.end(); ++idev) 
	    {
	      if ((*idev)->name() == d_mother.name()) 
		{
		  d_mother1=(*idev);
		} 
	    }
	  if (d_mother1==0)
	    {
	      cerr<<"*** PndDrcOptDevSys::embedDevice: device not found."<<endl;
	      exit(EXIT_FAILURE); 
	    }
	  d_mother1->addSurface(*tmp1);

	  // Connect both
	  coupleDevice(d_mother.name(),d_daughter.name(),tmp1->name(),tmp->name());	  
	}
    }
}

//----------------------------------------------------------------------
void PndDrcOptDevSys::coupleDevice(string dev1,       string dev2,
				string surf1,      string surf2,
				int    dev_copy1,  int    dev_copy2,
				int    surf_copy1, int    surf_copy2)
{
  coupleDevice1(dev1,dev2,surf1,surf2,name(),name(),dev_copy1,dev_copy2,surf_copy1,surf_copy2,0,0);
}

//----------------------------------------------------------------------
void PndDrcOptDevSys::coupleDevice1(string dev1,       string dev2,
				 string surf1,      string surf2,
				 string sys1,       string sys2,
				 int    dev_copy1,  int    dev_copy2,
				 int    surf_copy1, int    surf_copy2,
				 int    sys_copy1,  int    sys_copy2)
{
  list<PndDrcOptDev*>::const_iterator idev;
  list<string>::const_iterator        isys_ori;
  list<int>::const_iterator           isys_ori_copy;
  

  PndDrcOptDev*  d1=0;
  PndDrcOptDev*  d2=0;
  PndDrcSurfAbs* s1=0;
  PndDrcSurfAbs* s2=0;



  for(idev=m_listDev.begin(),
	isys_ori=m_listSysOri.begin(),
	isys_ori_copy=m_listSysOriCopy.begin(); 
      idev != m_listDev.end(); 
      ++idev,
	++isys_ori,
	++isys_ori_copy) 
    {

      //cout<<" PndDrcOptDevSys::coupleDevice1: check "<<endl;
      //cout<<" dev1 "<<(*idev)->name()<<" "<<(*idev)->copyNumber()<<" to "<<dev1<<" "<<dev_copy1<<endl;
      //cout<<" sys1 "<<(*isys_ori)<<" "<<(*isys_ori_copy)<<" to "<<sys1<<" "<<sys_copy1<<endl;
      
      if ((*idev)->name() == dev1 && (*idev)->copyNumber() == dev_copy1 &&
	  (*isys_ori) == sys1 && (*isys_ori_copy) == sys_copy1) 
	{
	  d1=(*idev);
	}
      
      //cout<<" PndDrcOptDevSys::coupleDevice1: check "<<endl;
      //cout<<" dev2 "<<(*idev)->name()<<" "<<(*idev)->copyNumber()<<" to "<<dev2<<" "<<dev_copy2<<endl;
      //cout<<" sys2 "<<(*isys_ori)<<" "<<(*isys_ori_copy)<<" to "<<sys2<<" "<<sys_copy2<<endl;

      if ((*idev)->name() == dev2 && (*idev)->copyNumber() == dev_copy2 &&
	  (*isys_ori) == sys2 && (*isys_ori_copy) == sys_copy2) 
	{
	  d2=(*idev);
	}
    }

  //cout<<" pointers = "<<(long int)(d1)<<" "<<(long int)(d2)<<endl;

  if (d1 && d2)
    {
      list<PndDrcSurfAbs*>::const_iterator isurf;
      for(isurf=d1->surfaceList().begin(); isurf != d1->surfaceList().end(); ++isurf) 
	{	  
	  //cout<<" test s1="<<(*isurf)->name()<<endl;
	  
	  if ((*isurf)->name()== surf1 && (*isurf)->copyNumber() == surf_copy1) s1=(*isurf); 
	}
      for(isurf=d2->surfaceList().begin(); isurf != d2->surfaceList().end(); ++isurf) 
	{
	  //cout<<" test s2="<<(*isurf)->name()<<endl;
	  if ((*isurf)->name()== surf2 && (*isurf)->copyNumber() == surf_copy2) s2=(*isurf); 
	}
      if (s1 && s2)
	{
	  if (m_verbosity>=1)
	    {
	      cout<<" PndDrcOptDevSys::coupleDevice "
		  <<dev1<<"/"<<surf1<<" with "
		  <<dev2<<"/"<<surf2<<endl;
	    }
	  s1->setCoupled(d2,s2);
	  s2->setCoupled(d1,s1);
	  m_listDev1Coupling.push_back(dev1);
	  m_listDev2Coupling.push_back(dev2);
	  m_listSurf1Coupling.push_back(surf1);
	  m_listSurf2Coupling.push_back(surf2);
	  m_listSysOri1Coupling.push_back(sys1);
	  m_listSysOri2Coupling.push_back(sys2);
	  m_listDev1CopyCoupling.push_back(dev_copy1);
	  m_listDev2CopyCoupling.push_back(dev_copy2);
	  m_listSurf1CopyCoupling.push_back(surf_copy1);
	  m_listSurf2CopyCoupling.push_back(surf_copy2);
	  m_listSysOri1CopyCoupling.push_back(sys_copy1);
	  m_listSysOri2CopyCoupling.push_back(sys_copy2);
	  
	}
      else
	{
	  cerr<<" *** PndDrcOptDevSys::coupleDevice: surface not found"<<endl;
	  if (!s1) cerr<<"     "<<surf1<<" missing"<<endl;
	  if (!s2) cerr<<"     "<<surf2<<" missing"<<endl;
	  exit(EXIT_FAILURE);
	}
    }
  else
    {
      cerr<<" *** PndDrcOptDevSys::coupleDevice: device not found"<<endl;
      if (!d1) cerr<<"     "<<dev1<<" missing"<<endl;
      if (!d2) cerr<<"     "<<dev2<<" missing"<<endl;
      exit(EXIT_FAILURE);
    }

}
//----------------------------------------------------------------------
void PndDrcOptDevSys::print(fstream& stream) const
{
  list<PndDrcOptDev*>::const_iterator idev;

  for(idev=m_listDev.begin(); idev != m_listDev.end(); ++idev) 
    {
      (*idev)->print(stream);
   }
}
//----------------------------------------------------------------------
void PndDrcOptDevSys::setPrintColor(int col)
{
  list<PndDrcOptDev*>::const_iterator idev;

  for(idev=m_listDev.begin(); idev != m_listDev.end(); ++idev) 
    {
      (*idev)->setPrintColor(col);
   }
}
//----------------------------------------------------------------------
void PndDrcOptDevSys::addTransform(const Transform3D& trans)
{

  list<PndDrcOptDev*>::const_iterator i;
	      
  for (i=m_listDev.begin(); i != m_listDev.end(); ++i)
    {
      const_cast<PndDrcOptDev*>(*i)->addTransform(trans);
    }

}
//----------------------------------------------------------------------
void PndDrcOptDevSys::print() const
{
  list<PndDrcOptDev*>::const_iterator i;
	  
  cout<<"     PndDrcOptDevSys::print name= "<<m_name<<endl;
  cout<<"                         entries= "<<m_listDev.size()<<endl;
  
  for (i=m_listDev.begin(); i != m_listDev.end(); ++i)
    {
      cout<<"\t\t"<<std::hex<<int(*i)<<std::dec<<" "<<(*i)->name()<<endl;
      (*i)->print();
    }

  cout<<"                         couplings= "<<m_listDev1Coupling.size()<<endl;

  list<string>::const_iterator        isys_ori1;
  list<string>::const_iterator        isys_ori2;
  list<int>::const_iterator           isys_ori1_copy;
  list<int>::const_iterator           isys_ori2_copy;
  list<string>::const_iterator        idev1;
  list<string>::const_iterator        idev2;
  list<int>::const_iterator           idev1_copy;
  list<int>::const_iterator           idev2_copy;
  list<string>::const_iterator        isurf1;
  list<string>::const_iterator        isurf2;
  list<int>::const_iterator           isurf1_copy;
  list<int>::const_iterator           isurf2_copy;


  for(idev1            = m_listDev1Coupling.begin(),  
	idev2          = m_listDev2Coupling.begin(),
	idev1_copy     = m_listDev1CopyCoupling.begin(),  
	idev2_copy     = m_listDev2CopyCoupling.begin(),
	isurf1         = m_listSurf1Coupling.begin(), 
	isurf2         = m_listSurf2Coupling.begin(),
	isurf1_copy    = m_listSurf1CopyCoupling.begin(), 
	isurf2_copy    = m_listSurf2CopyCoupling.begin(),
	isys_ori1      = m_listSysOri1Coupling.begin(),
	isys_ori2      = m_listSysOri2Coupling.begin(),
	isys_ori1_copy = m_listSysOri1CopyCoupling.begin(),
	isys_ori2_copy = m_listSysOri2CopyCoupling.begin();
      idev1 != m_listDev1Coupling.end();
      ++idev1,
	++idev2,
	++idev1_copy,
	++idev2_copy,
	++isurf1,
	++isurf2,
	++isurf1_copy,
	++isurf2_copy,
	++isys_ori1,
	++isys_ori2,
	++isys_ori1_copy,
	++isys_ori2_copy) 
    { 
      cout<<endl;
      cout<<"      sys1  = "<<(*isys_ori1)<<"\t"<<(*isys_ori1_copy)
	  <<" \t with sys2  = "<<(*isys_ori2)<<"\t"<<(*isys_ori2_copy)<<endl;
      cout<<"      dev1  = "<<(*idev1)<<"\t"<<(*idev1_copy)
	  <<" \t with dev2  = "<<(*idev2)<<"\t"<<(*idev2_copy)<<endl;
      cout<<"      surf1 = "<<(*isurf1)<<"\t"<<(*isurf1_copy)
	  <<" \t with surf2 = "<<(*isurf2)<<"\t"<<(*isurf2_copy)<<endl;
      
    }

}