#include "PndFieldCreator.h"

#include "PndFieldMap.h"
#include "PndConstField.h"
#include "PndSolenoidMap.h"
#include "PndDipoleMap.h"
#include "PndTransMap.h"
#include "PndMultiField.h"
#include "PndMultiFieldPar.h"
#include "PndConstPar.h"
#include "PndDipoleMap.h"
#include "PndSolenoidMap.h"
#include "PndDipolePar.h"
#include "PndSolenoidPar.h"
#include "PndTransPar.h"
#include "PndTransMap.h"
#include "PndMapPar.h"
#include "FairBaseParSet.h"
#include "FairRunAna.h"
#include "FairRuntimeDb.h"

#include "TObjArray.h"

using std::cout;
using std::endl;

static PndFieldCreator gPndFieldCreator;


PndFieldCreator::PndFieldCreator()
	:FairFieldFactory(),
     fFieldPar(0),
     fSPar(0),
     fDPar(0),
     fTPar(0),
     fCPar(0),
     fMPar(0)
    
{
	fCreator=this;
 
}

PndFieldCreator::PndFieldCreator(const  PndFieldCreator& L)
	:FairFieldFactory(),
     fFieldPar(L.fFieldPar),
     fSPar(L.fSPar),
     fDPar(L.fDPar),
     fTPar(L.fTPar),
     fCPar(L.fCPar),
     fMPar(L.fMPar)
    
{
  fCreator = L.fCreator;
}

PndFieldCreator::~PndFieldCreator()
{
}
void PndFieldCreator::SetParm()
{
 
//  cout << "PndFieldCreator::SetParm()" <<endl;
  FairRun *Run = FairRun::Instance();
  FairRuntimeDb *RunDB = Run->GetRuntimeDb();
  
  FairBaseParSet* par=(FairBaseParSet*)(RunDB->getContainer("FairBaseParSet"));
 
  TObjArray *contList= par->GetContList();
  TObject *obj=0;
  if (contList) {
	  obj=contList->FindObject("PndMultiFieldPar");
  } 

  cout << "PndFieldCreator::SetParm() " << obj  <<endl;

  	
  if (obj) {
	 fMPar = (PndMultiFieldPar*)RunDB->getContainer("PndMultiFieldPar");
  }else if (contList->FindObject("PndFieldPar")) {
	  fFieldPar = (PndFieldPar*) RunDB->getContainer("PndFieldPar");
  }else if (contList->FindObject("PndSolenoidPar")) {
	  fSPar = (PndSolenoidPar*) RunDB->getContainer("PndSolenoidPar");
  }else if (contList->FindObject("PndDipolePar")) {
	  fDPar = (PndDipolePar*) RunDB->getContainer("PndDipolePar");
  }else if (contList->FindObject("PndTransPar")) {
	  fTPar = (PndTransPar*) RunDB->getContainer("PndTransPar");
  }else if (contList->FindObject("PndConstPar")) {
	  fCPar = (PndConstPar*) RunDB->getContainer("PndConstPar");
  }
	
 
}

FairField* PndFieldCreator::createFairField()
{       
	//cout << "PndFieldCreator::createFairField()" <<endl;
    FairField *fMagneticField=0;
	PndMultiField *MField=0;
	Int_t Type=-1;
    Bool_t multi=kFALSE;
	if (fMPar) {
	   MField = new PndMultiField(fMPar);
	   Type= fMPar->GetType();
	}
	if (Type==-1) {delete MField; MField=0;}
	
	if(MField) {
		multi=kTRUE;
		TObjArray *fParArray=fMPar->GetParArray();
		TIterator *Iter=fParArray->MakeIterator();
   		Iter->Reset();
   		PndMapPar* fPar = NULL;
   		while( (fPar = (PndMapPar*)Iter->Next() ) ) {
			fPar->Print();
			if (fPar->GetType()==0){
				FairField *fField1 = new PndConstField((PndConstPar*)fPar);
				MField->AddField(fField1);
			}
			if (fPar->GetType()==1){
				FairField *fField2 = new PndFieldMap((PndFieldPar*)fPar);
				MField->AddField(fField2);
			}
			if (fPar->GetType()==2){
				FairField *fField3 = new PndSolenoidMap((PndSolenoidPar*)fPar);
				MField->AddField(fField3);
			}
			if (fPar->GetType()==3){
				FairField *fField4 = new PndDipoleMap((PndDipolePar*)fPar);
				MField->AddField(fField4);
			}
			if (fPar->GetType()==4){
				FairField *fField5 = new PndTransMap((PndTransPar*)fPar);
				MField->AddField(fField5);
			}
		}
	}

	if (fCPar) {
	   FairField *fField1 = new PndConstField(fCPar);
	   Type= fCPar->GetType();
	   if (Type==-1) {delete fField1; fField1=0;}
	   if(fField1)fMagneticField=fField1;	
	}
	if(fFieldPar){
	   FairField *fField2 = new PndFieldMap(fFieldPar);
	   Type= fFieldPar->GetType();
	   if (Type==-1){delete fField2; fField2=0;}
	   if(fField2)fMagneticField=fField2;	
    }
	if(fSPar){
	   FairField *fField3 = new PndSolenoidMap(fSPar);
	   Type= fSPar->GetType();
	   if (Type==-1) {delete fField3; fField3=0;}
	   if(fField3)fMagneticField=fField3;
	}
	if(fDPar){
	   FairField *fField4 = new PndDipoleMap(fDPar);
	   Type= fDPar->GetType();
	   if (Type==-1) {delete fField4; fField4=0;}
	   if(fField4)fMagneticField=fField4;	
    }
	if(fTPar){
	   FairField *fField5 = new PndTransMap(fTPar);
	   Type= fTPar->GetType();
	   if (Type==-1){delete fField5; fField5=0;}
	   if(fField5)fMagneticField=fField5;	
    }
        
	if (multi) {
		MField->Init();
		return MField;
	}else{
        if(fMagneticField){
	        fMagneticField->Init();	 
		}
		return fMagneticField;
	}
}


ClassImp(PndFieldCreator)