#include "DetectorConstruction.hh"
#include "MCEvent.hh"
//#include "DataManager.hh"
#include "G4Material.hh"
#include "G4NistManager.hh"
#include "G4Box.hh"
#include "G4SubtractionSolid.hh"
#include "G4Tubs.hh"
#include "Randomize.hh"
#include "G4Sphere.hh"
#include "G4LogicalVolume.hh"
#include "G4PVPlacement.hh"
#include "G4GeometryTolerance.hh"
#include "G4GeometryManager.hh"
#include "G4NistManager.hh"
#include "G4UserLimits.hh"
#include "G4VisAttributes.hh"
#include "G4ios.hh"
#include "G4SystemOfUnits.hh"
#include "G4PhysicalConstants.hh"

//-----------------------------------------------------------------------------
 
DetectorConstruction::DetectorConstruction(G4double worldSize)
 
{
  solidWorld =0;
  logicWorld =0; 
  physiWorld =0;
  
  stepLimit = 0;

  NISTManager = G4NistManager::Instance();

  World_VisAtt = 0;
 
  fWorldLength = worldSize;
   
  size_of_material = 8.0000002*mm;
  size_of_small_cube = 4.*mm;
  spcace_between_cubes = 0.0000001*mm;	 //Defined to avoid geometry overlapping at the border of each small cube


  num_small_cubes_per_side = 2; //size_of_soil/size_of_small_cube;
  //-----------------------------------------------------------------;
}

//-----------------------------------------------------------------------------
 
DetectorConstruction::~DetectorConstruction()
{
  if(solidWorld!=0) delete solidCrystal;

  if(logicAir!=0) delete logicAir;
  if(logicWater!=0) delete logicWater;
  
   for (G4int i = 0; i < num_small_cubes_per_side; i++)
    {
      for (G4int j = 0; j <num_small_cubes_per_side; j++)
	{
	  for (G4int k = 0; k < num_small_cubes_per_side; k++)
	    {

		G4int copyNumber = i + j*num_small_cubes_per_side + k*num_small_cubes_per_side*num_small_cubes_per_side;
		 if(small_cube_pv[copyNumber]!=0) delete small_cube_pv[copyNumber]; 
	     
	    }
	  }
	}
  
  if(World_VisAtt!=0)  {delete World_VisAtt;   World_VisAtt = 0;}
  if(solidWorld!=0){delete solidWorld; solidWorld = 0;}
  if(logicWorld!=0){delete logicWorld; logicWorld = 0;}
  if(physiWorld!=0){delete physiWorld; physiWorld = 0;}
  
  

  if(stepLimit!=0){delete stepLimit; stepLimit =0;}
}

//-----------------------------------------------------------------------------
 
G4VPhysicalVolume* DetectorConstruction::Construct()
{  
  //ConstructMaterials();

  G4GeometryManager::GetInstance()->SetWorldMaximumExtent(fWorldLength);
  G4cout << "Computed tolerance = "
         << G4GeometryTolerance::GetInstance()->GetSurfaceTolerance()/mm
         << " mm" << G4endl;

  G4double HalfWorldLength = 0.5*fWorldLength;

  solidWorld = new G4Box("sWorld", HalfWorldLength, HalfWorldLength, HalfWorldLength);
  logicWorld = new G4LogicalVolume(solidWorld, NISTManager->FindOrBuildMaterial("G4_WATER"), "lWorld", 0, 0, 0);
  
  physiWorld = new G4PVPlacement(0, G4ThreeVector(0.*mm,0.*mm,0.*mm), logicWorld, "pvWorld", 0, false, 0);   
 

  solidCrystal = new G4Box("tinyCrystal", size_of_small_cube/2., size_of_small_cube/2., size_of_small_cube/2.);

  logicAir = new G4LogicalVolume(solidCrystal, NISTManager->FindOrBuildMaterial("G4_AIR"), "airCrystal");
  logicWater = new G4LogicalVolume(solidCrystal, NISTManager->FindOrBuildMaterial("G4_WATER"), "waterCrystal");
  
  //!!!!!!!!!!!!!!!!!!!!!need a reference here!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

  std::ostringstream tmp_str;
 
  for (G4int i = 0; i < num_small_cubes_per_side; i++)
    {
      for (G4int j = 0; j <num_small_cubes_per_side; j++)
	{
	  for (G4int k = 0; k < num_small_cubes_per_side; k++)
	    {

	      G4int copyNumber = i + j*num_small_cubes_per_side + k*num_small_cubes_per_side*num_small_cubes_per_side;
	        G4String pv_name = "small_cube_pv_";
               tmp_str<<copyNumber;
               pv_name+=tmp_str.str();
 		G4double x = -0.5*(size_of_material + size_of_small_cube + spcace_between_cubes)+i*(size_of_small_cube + spcace_between_cubes);		
 		G4double y = -0.5*(size_of_material + size_of_small_cube + spcace_between_cubes)+j*(size_of_small_cube + spcace_between_cubes);
       		G4double z = -0.5*(size_of_material + size_of_small_cube + spcace_between_cubes)+k*(size_of_small_cube + spcace_between_cubes);

/*
	      											
	      G4double randomNum = G4UniformRand(); 						
	      if (randomNum <0.43)								
		{
		  small_cube_pv[copyNumber]=new G4PVPlacement(0,                                //Rotation
				    G4ThreeVector(x,y,z),      					//Position
				    logicWater,
				    pv_name,                         				//name
				    logicWorld,
				    false,                         				//no boolean operation
				    copyNumber);						//copy number
				    //true);                     				
		} 
	      else if (randomNum <0.715)
		{
	small_cube_pv[copyNumber]=new G4PVPlacement(0,                 		                
				    G4ThreeVector(x,y,z),      					
				    logicWater,
				    pv_name,                     			        
				    logicWorld,
				    false,                              			
				    copyNumber);                         			
				    //true);
		}
              else 
		{
	small_cube_pv[copyNumber]=new G4PVPlacement(0,                          	        
				    G4ThreeVector(x,y,z),      					
				    logicWater,
				    pv_name,                          				
				    logicWorld,
				    false,                              			
				    copyNumber);                         			
				    //true);
		}
*/		    
	    }
	}
    }
  			   
//--------- Visualization attributes -------------------------------

  VisualizationAttributes();

  
  return physiWorld;
}

//======================================================================

void DetectorConstruction::VisualizationAttributes()
{

  World_VisAtt = new G4VisAttributes();
  World_VisAtt->SetForceWireframe(true);  
    logicWorld->SetVisAttributes(World_VisAtt);

  VisAttWater = new G4VisAttributes(true, G4Colour(1., 0., 0., 1.));
  logicWater->SetVisAttributes(VisAttWater);

  VisAttAir = new G4VisAttributes(true, G4Colour(0., 1., 0., 1.));
  logicAir->SetVisAttributes(VisAttAir);
}