#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 <limits>
using std::numeric_limits;

#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 "PndDrcOptVol.h"
#include "PndDrcUtil.h"

//----------------------------------------------------------------------
PndDrcOptVol::PndDrcOptVol()
{
  m_optMat      = 0; 
}
//----------------------------------------------------------------------
PndDrcOptVol::~PndDrcOptVol()
{
  delete m_optMat; 
}
//----------------------------------------------------------------------
PndDrcOptVol* PndDrcOptVol::clone() const
{
  return new PndDrcOptVol(*this);
}
//----------------------------------------------------------------------
void PndDrcOptVol::copy(const PndDrcOptVol& d)
{
  if (!(&(d.optMaterial())))
    {
      cerr<<" ***  PndDrcOptVol::copy: optMaterial undefined."<<endl;
      
      exit(EXIT_FAILURE);
    }
  
  if (&(d.optMaterial())) m_optMat = (d.optMaterial()).clone();
}
//----------------------------------------------------------------------
PndDrcOptVol::PndDrcOptVol(const PndDrcOptVol& d) : PndDrcOptDev(d)
{  
  if (d.m_verbosity>=1) cout<<"  PndDrcOptVol::PndDrcOptVol"
			    <<"(const PndDrcOptVol&) name,copy: "
			    <<d.m_name<<" "<<d.m_copyNumber<<endl;
  copy(d);
}
//----------------------------------------------------------------------
PndDrcOptVol& PndDrcOptVol::operator=(const PndDrcOptVol& d)
{
  if (d.m_verbosity>=1) cout<<"  PndDrcOptVol::operator="
			    <<"(const PndDrcOptVol&) name,copy: "
			    <<d.m_name<<" "<<d.m_copyNumber<<endl;
  if (&d != this)
    {
      static_cast<PndDrcOptDev&>((*this)) = d; // assignment of base class part.
      copy(d);
    }
  return *this;
}
//----------------------------------------------------------------------
void PndDrcOptVol::setOptMaterial(const PndDrcOptMatAbs& mat)
{
  if (&mat)
    {
      delete m_optMat;
      m_optMat = mat.clone();
    }
}
//----------------------------------------------------------------------
void PndDrcOptVol::propagate(PndDrcPhoton& ph)
{
  static const double eps = 1.0e-9;


  if (verbosity()>=4) cout<<"    PndDrcOptVol::propagate"<<endl;
  //if (verbosity()>=4) ph.print();
  list<PndDrcSurfAbs*>::const_iterator isurf;

 
  while (ph.fate() == Drc::PhotFlying)
    {// while
      ph.setDevice(this);
      //---------------
      // search the closest surface which is not the surface where the photon is 
      // right now. 
      PndDrcSurfAbs* surf_closest=0;
      double path_length_min = numeric_limits<double>::max();
      for(isurf=m_listSurf.begin(); isurf != m_listSurf.end(); ++isurf) 
	{
	  if (verbosity()>=4) cout<<"     check "<<(*isurf)->name()
				  <<" (surface coupling = "
				  <<(*isurf)->coupled()<<")"<<endl;
	  XYZPoint pos_new;
	  double   path_length;
	  if ((*isurf)->surfaceHit(ph,pos_new,path_length))
	    {
	      if (verbosity()>=4) cout<<"     hit for "<<(*isurf)->name()<<endl;
	      if (verbosity()>=4) cout<<"     path_length "<<path_length<<endl;
	      if (path_length<path_length_min && path_length>eps)
		{
		  path_length_min = path_length;
		  surf_closest    = (*isurf);
		}
	    }
	  else
	    {
	      if (verbosity()>=4) cout<<"     no hit "<<(*isurf)->name()<<endl;
	    }

	}
      if (surf_closest==0)
	{
	  if (ph.fate() == Drc::PhotFlying) 
	    {
	      if (verbosity()>=4) 
		cout<<"     no hit with any surface ->edge hit->lost"<<endl;
	      if (m_photonTrace) ph.print(*m_photonTraceStream);
	      ph.setFate(Drc::PhotLost);
	      break;
	    }
	}
      // reset photon, that was only a search...
      ph.setFate(Drc::PhotFlying);

      //---------------


      if (verbosity()>=4) cout<<"     closest "<<surf_closest->name()<<endl;
      XYZPoint pos_new;
      double   path_length;
      if (surf_closest->surfaceHit(ph,pos_new,path_length))
	{// hit surf_closest

	  if (verbosity()>=4) 
	    {
	      XYZPoint pos_old(ph.position());
	      cout<<"     hit, set pos from "<<pos_old<<endl;
	      cout<<"                  to   "<<pos_new<<endl;
	    }

	  //if (ph.fate()!=PndDrc::PhotFlying) return;

	  // ----------- Absorption 
	  if (optMaterial().absorptionFlag(ph.wavelength(),path_length))
	    {
	      //ph.setPosition(ph.position()+path_length*ph.direction());
	      if (m_photonTrace) ph.print(*m_photonTraceStream);
	      ph.setFate(Drc::PhotAbsorbed);
	      break; // leave while loop
	    }
	  else
	    {
	      ph.setPosition(pos_new);
	      if (m_photonTrace) ph.print(*m_photonTraceStream);
	      if (ph.fate()!=Drc::PhotFlying) break;//###1
	    }
	  //------------

	  //------------ check coupled volumes

	  if (verbosity()>=4) cout<<"     surface coupling = "
				  <<surf_closest->coupled()
				  <<" for "
				  <<name()<<" "
				  <<copyNumber()<<" "
				  <<surf_closest->name()<<endl;

	  if (surf_closest->coupled())
	    {// if surf_closest coupled
	      list<PndDrcOptDev*>::const_iterator  idev_coupled;
	      list<PndDrcSurfAbs*>::const_iterator isurf_coupled;
	      
	      for (idev_coupled  = (surf_closest->coupledDeviceList()).begin(),
		     isurf_coupled = (surf_closest->coupledSurfaceList()).begin(); 
		   idev_coupled != (surf_closest->coupledDeviceList()).end(); 
		   ++idev_coupled, ++isurf_coupled)
		{
		  if (verbosity()>=4) cout<<"     coupling to dev,copy,surf= "
					  <<(*idev_coupled)->name()<<","
					  <<(*idev_coupled)->copyNumber()<<","
					  <<(*isurf_coupled)->name()<<endl;

		  // deal with eps problem in sphere and parabolid
		  PndDrcPhoton ph1(ph);
		  if (! (*isurf_coupled)->isFlat())
		  {
		    ph1.setPosition(ph.position()-ph.direction()*0.1);
		    if (verbosity()>=4) cout<<"     bring back from "
		  		      <<ph.position()<<" to "
		  		      <<ph1.position()<<endl;
		  }

		  bool hit = (*isurf_coupled)->surfaceHit(ph1,pos_new,path_length);

		  if (verbosity()>=4) cout<<"     hit="<<hit<<" with "
					  <<(*isurf_coupled)->name()<<endl;
		  if (hit)
		    {

		      if (&(surf_closest->reflectivity())) // Reflectivity defined
			{
			  // check reflectivity
			  XYZVector norm = surf_closest->normal(ph.position());
			  Drc::Reflectivity refl = Drc::ReflReflected;
			  refl = surf_closest->reflectivity().reflectivity(ph,norm);
		      
		      
			  if (refl == Drc::ReflAbsorbed)
			    {
			      if (verbosity()>=4) 
				cout<<"     PndDrcOptMirror::propagate: mirror absorbed"<<endl;
			      ph.setFate(Drc::PhotAbsorbed);
			      return;
			    }
			  if (refl == Drc::ReflTransmitted)
			    {
			      // do nothing
			    }
			  if (refl == Drc::ReflReflected)
			    {
			      ph.reflect(norm);
			    }
			  if (refl == Drc::ReflRefracted)
			    {
			      //if (refract(ph,norm))
			      //{
			      //  ph.setFate(PndDrc::PhotLost); // Photon refracted in nirvana.
			      //  if (verbosity()>=4) cout<<"     Photon lost"<<endl;
			      //}
			      // do nothing
			    }

			}


		      // bring photon inside coupled volume
		      // to prevent infinite recursion of coupled surface hits.
		      // The factor 2 comes from comparisons with same eps in 
		      // surfaceHit.

		      PndDrcOptMatAbs* opt_mat = &((*idev_coupled)->optMaterial());
		      if (verbosity()>=4) cout<<"     opt_mat="<<opt_mat<<endl;
		      if (opt_mat)
			{
			  double n1 = optMaterial().refIndex(ph.wavelength());
			  double n2 = opt_mat->refIndex(ph.wavelength());
			  bool iref = ph.refract(surf_closest->normal(ph.position()),
						 n1,n2);

			  if (verbosity()>=4) cout<<" refract in new volume flag = "
						  <<iref<<endl;

			  if (iref) // refraction in new volume
			    {
			      if (verbosity()>=4) cout<<"     go into new volume "
						      <<(*idev_coupled)->name()<<endl;
			      (*idev_coupled)->propagate(ph);
			    }
			  else
			    {
			      break; // coupled surface loop, since phot. is reflected.
			    }
			}
		      else // screen or mirror...
			{
			  // do not bring photons inside flat objects
			  // ph.setPosition(ph.position()+2*eps*ph.direction());
			  (*idev_coupled)->propagate(ph);
			}
		      if (ph.fate() != Drc::PhotFlying) break;
		    }
		}
	    }
	  //----------
	  else
	    {// uncoupled surfaces
	      XYZVector norm = surf_closest->normal(ph.position());

	      if (&(surf_closest->reflectivity())) // Reflectivity defined
		{
		  ph.setDevice(this);

		  Drc::Reflectivity refl = Drc::ReflReflected;
		  refl = surf_closest->reflectivity().reflectivity(ph,norm);
			   

		  if (refl == Drc::ReflAbsorbed)
		    {
		      if (verbosity()>=4) 
			cout<<"     PndDrcOptMirror::propagate: mirror absorbed"<<endl;
		      ph.setFate(Drc::PhotAbsorbed);
		      return;
		    }
		  if (refl == Drc::ReflTransmitted)
		    {
		      // do nothing
		    }
		  if (refl == Drc::ReflReflected)
		    {
		      ph.reflect(norm);
		    }
		  if (refl == Drc::ReflRefracted)
		    {
		      if (ph.refract(norm,optMaterial().refIndex(ph.wavelength())))
			{
			  ph.setFate(Drc::PhotLost); // Photon refracted in nirvana.
			  if (verbosity()>=4) cout<<"     Photon lost"<<endl;
			}
		    }
		}
	      else if (ph.refract(norm,optMaterial().refIndex(ph.wavelength())) && 
		       ph.fate() == Drc::PhotFlying) 
		{//perfect surface
		  ph.setFate(Drc::PhotLost); // Photon refracted in nirvana.
		  if (verbosity()>=4) cout<<"     Photon lost"<<endl;
		}
	      // else, do nothing, photon is reflected.
	    }
	  if (ph.fate() != Drc::PhotFlying) break; // while loop
	}// if surf_closest... 
    }
}