#include <RAT/GeoPanelFactory.hh>
#include <RAT/DS/Run.hh>
#include <RAT/Detector.hh>
#include <RAT/DB.hh>
#include <RAT/Log.hh>
#include <RAT/EnvelopeConstructor.hh>

#include <RAT/PanelBase.hh>
#include <RAT/PanelS7.hh>
#include <RAT/PanelS19.hh>
#include <RAT/PanelT10.hh>
#include <RAT/PanelT14.hh>
#include <RAT/PanelT21.hh>

#include <G4SDManager.hh>
#include <G4LogicalVolume.hh>
#include <G4PVPlacement.hh>

#include <string>
#include <algorithm>

using namespace std;

namespace RAT
{

void
GeoPanelFactory::Construct( DBLinkPtr table,
                            const bool checkOverlaps )
{
  // Get the mother volume to find the mother material
  string motherName = table->GetS("mother");
  G4LogicalVolume *mother = Detector::FindLogicalVolume( motherName );

  AssembleFullPMT( table, mother->GetMaterial() );

  SetupOpticalModel( table );

  ConstructPanels( table, checkOverlaps );

  PlacePanels( table, checkOverlaps );

  DeletePanels();

  return;
}


void
GeoPanelFactory::ConstructPanels( DBLinkPtr table,
                                  const bool checkOverlaps )
{
  // Get the PANELINFO and build the panels
  DBLinkPtr panelInfo = DB::Get()->GetLink( "PANELINFO" );
  vector<int> panelNumber = panelInfo->GetIArray( "panel_number" );
  vector<int> panelType = panelInfo->GetIArray( "panel_type" );
  vector<double> panelR = panelInfo->GetDArray( "r" );
  vector<double> panelS = panelInfo->GetDArray( "s" );
  vector<double> panelT = panelInfo->GetDArray( "t" );
  vector<double> panelU = panelInfo->GetDArray( "u" );
  vector<double> panelV = panelInfo->GetDArray( "v" );
  vector<double> panelW = panelInfo->GetDArray( "w" );
  vector<double> panelX = panelInfo->GetDArray( "x" );
  vector<double> panelY = panelInfo->GetDArray( "y" );
  vector<double> panelZ = panelInfo->GetDArray( "z" );

  string volumeName = table->GetIndex();
  string motherName = table->GetS("mother");
  G4LogicalVolume *mother = Detector::FindLogicalVolume( motherName );
  // Panels are logical envelopes thus same material as mother
  G4Material* panelMaterial = mother->GetMaterial();

  G4VisAttributes* visAttributes = GeoFactory::LoadVisualisation( table );

  for( unsigned int uPanel = 0; uPanel < panelNumber.size(); uPanel++ )
    {
      const int panel = panelNumber[uPanel];
      const G4ThreeVector pos( panelX[uPanel], panelY[uPanel], panelZ[uPanel] );
      const G4ThreeVector xAxis( panelR[uPanel], panelS[uPanel], panelT[uPanel] );
      const G4ThreeVector zAxis( panelU[uPanel], panelV[uPanel], panelW[uPanel] );

      switch( panelType[uPanel] )
        {
        case 0: // S7
          fPanels[panel] = new PanelS7( volumeName, pos, zAxis, xAxis, panelMaterial, visAttributes );
          break;
        case 1: // S19
          fPanels[panel] = new PanelS19( volumeName, pos, zAxis, xAxis, panelMaterial, visAttributes );
          break;
        case 2: // T21
          fPanels[panel] = new PanelT21( volumeName, pos, zAxis, xAxis, panelMaterial, visAttributes );
          break;
        case 3: // T14
          fPanels[panel] = new PanelT14( volumeName, pos, zAxis, xAxis, panelMaterial, visAttributes );
          break;
        case 4: // T10
          fPanels[panel] = new PanelT10( volumeName, pos, zAxis, xAxis, panelMaterial, visAttributes );
          break;
        }

    }

  // Now place the PMTs into the panels
  DBLinkPtr pmtInfo = DB::Get()->GetLink( "PMTINFO" );
  panelNumber = pmtInfo->GetIArray("panelnumber");
  vector<int> type = pmtInfo->GetIArray("pmt_type");
  vector<double> pmtX = pmtInfo->GetDArray("x");
  vector<double> pmtY = pmtInfo->GetDArray("y");
  vector<double> pmtZ = pmtInfo->GetDArray("z");
  vector<double> dirX = pmtInfo->GetDArray("u");
  vector<double> dirY = pmtInfo->GetDArray("v");
  vector<double> dirZ = pmtInfo->GetDArray("w");

  vector<int> pmtTypeToBuild( 1, 1 ); // Default normal
  try { pmtTypeToBuild = table->GetIArray("pmt_build_type"); }
  catch (DBNotFoundError &e) { /*Default Normal PMTs*/ }

  //Loop over all the PMTs
  for( unsigned int uPMT = 0; uPMT < panelNumber.size(); uPMT++ )
    {
      const int panel = panelNumber[uPMT];
      G4ThreeVector pos( pmtX[uPMT], pmtY[uPMT], pmtZ[uPMT] );
      G4ThreeVector dir( dirX[uPMT], dirY[uPMT], dirZ[uPMT] );

      // Build only prescribed pmts, default is Normal
      if( find( pmtTypeToBuild.begin(), pmtTypeToBuild.end(), type[uPMT] ) == pmtTypeToBuild.end() )
        continue;
      CorrectPMTPosAndDir( type[uPMT], pos, dir );
      // Check if PMT is in a panel, if not then skip
      if( panel == -1 )
        continue;
      // Add the pmt to the panel
      fPanels[panel]->AddPMT( fEnvelope[ type[uPMT] ], uPMT, pos, dir );
    }
  // Finally loop over and build the panels
  for( map<int, PanelBase*>::iterator iTer = fPanels.begin(); iTer != fPanels.end(); ++iTer )
    iTer->second->Construct( checkOverlaps );
}

void
GeoPanelFactory::PlacePanels( DBLinkPtr table,
                              const bool checkOverlaps )
{
  string volumeName = table->GetIndex();
  string motherName = table->GetS( "mother" );
  G4VPhysicalVolume* physMother = Detector::FindPhysicalVolume( motherName );

  for( map<int, PanelBase*>::iterator iTer = fPanels.begin(); iTer != fPanels.end(); ++iTer )
    {
      string panelName = volumeName +std::string("_panel") + ::to_string( iTer->first );
      G4ThreeVector panelPosition;
      G4RotationMatrix* panelRotation = new G4RotationMatrix(); //Deleted by Magic :)

      iTer->second->GetRotationAndPosition( panelRotation, &panelPosition );

      // Place panel in the detector
      new G4PVPlacement( panelRotation,
                         panelPosition,
                         panelName,
                         iTer->second->GetLogicalVolume(),
                         physMother,
                         false,
                         iTer->first,
                         checkOverlaps );
	}
}

void
GeoPanelFactory::DeletePanels()
{
  for( map<int, PanelBase*>::iterator iTer = fPanels.begin(); iTer != fPanels.end(); ++iTer )
    delete iTer->second;
  fPanels.clear();
}

} // namespace RAT