/*
 * FairMultiLinkedData_Interface.cxx
 *
 *  Created on: Dec 7, 2009
 *      Author: stockman
 */

#include "FairMultiLinkedData_Interface.h"
#include "TClonesArray.h"

#include<algorithm>
#include <set>

ClassImp(FairMultiLinkedData_Interface);

FairMultiLinkedData_Interface::FairMultiLinkedData_Interface()
  :TObject(),
   fFairMultiLinkedDataExists(kFALSE),
   fPointerToData(0),
   fLinkBranchName(),
   fVerbose(0)
{
}


FairMultiLinkedData_Interface::FairMultiLinkedData_Interface(TString& branchName)
  :TObject(),
   fFairMultiLinkedDataExists(kFALSE),
   fPointerToData(0),
   fLinkBranchName(),
   fVerbose(0)
{
	CreateLinkBranchName(branchName);
}

FairMultiLinkedData_Interface::FairMultiLinkedData_Interface(TString& branchName, std::set<FairLink> links, Bool_t persistanceCheck)
  :TObject(),
   fFairMultiLinkedDataExists(kFALSE),
   fPointerToData(0),
   fLinkBranchName(),
   fVerbose(0)
{

	CreateLinkBranchName(branchName);
	CreateFairMultiLinkedData();
	SetLinks(links);
}

FairMultiLinkedData_Interface::FairMultiLinkedData_Interface(TString& branchName, TString dataType, std::vector<Int_t> links, Int_t fileId, Int_t evtId, Bool_t persistanceCheck, Bool_t bypass, Float_t mult)
  :TObject(),
   fFairMultiLinkedDataExists(kFALSE),
   fVerbose(0)

{
	CreateLinkBranchName(branchName);
}

FairMultiLinkedData_Interface::FairMultiLinkedData_Interface(TString& branchName, Int_t dataType, std::vector<Int_t> links, Int_t fileId, Int_t evtId, Bool_t persistanceCheck, Bool_t bypass, Float_t mult)
  :TObject(),
   fFairMultiLinkedDataExists(kFALSE),
   fVerbose(0)

{

	CreateLinkBranchName(branchName);
	FairMultiLinkedData data(dataType, links, fileId, evtId, persistanceCheck, bypass, mult);
	SetLinks(data);
}

FairMultiLinkedData* FairMultiLinkedData_Interface::CreateFairMultiLinkedData()
{
//	FairMultiLinkedData* storedLinkData;
	if (fFairMultiLinkedDataExists == kTRUE){
		std::cout << "-Warning- FairMultiLinkedData_Interface::CreateFairMultiLinkedData: Container exists already!" << std::endl;
	}
	else if(fLinkBranchName != ""){
		FairRootManager* ioman = FairRootManager::Instance();
		TClonesArray* container = ioman->GetTClonesArray(fLinkBranchName);
		fReferencePointerToData = new ((*container)[container->GetEntriesFast()]) FairMultiLinkedData();
		fPointerToData = (FairMultiLinkedData*)fReferencePointerToData.GetObject();
//		fLinkToFairMultiLinkedData.SetLink(-1, ioman->GetOutTreeEntryNr(), ioman->GetBranchId(fLinkBranchName), container->GetEntriesFast() - 1);
//		std::cout << "MultiLinkedData created at: " << fLinkToFairMultiLinkedData << std::endl;
		fFairMultiLinkedDataExists = kTRUE;
	}
	return fPointerToData;
}

void FairMultiLinkedData_Interface::SetLinks(FairMultiLinkedData links)
{
	SetPointerToData();
	std::cout << "SetLinks for Data: " << links << std::endl;
	if (fPointerToData != 0){
		std::cout << "PointerToData before Set: " << *fPointerToData << std::endl;
		fPointerToData->SetLinks(links);
		std::cout << "PointerToData after Set: " << *fPointerToData << std::endl;
	}
}

void FairMultiLinkedData_Interface::SetLink(FairLink link)
{
	SetPointerToData();
	if (fPointerToData != 0){
		fPointerToData->SetLink(link);
	}
}

void FairMultiLinkedData_Interface::AddLinks(FairMultiLinkedData links)
{
	SetPointerToData();
	if (fPointerToData != 0){
		fPointerToData->AddLinks(links);
	}
}

void FairMultiLinkedData_Interface::AddLink(FairLink link)
{
	SetPointerToData();
	if (fPointerToData != 0){
		fPointerToData->AddLink(link);
	}

}


//std::set<FairLink> FairMultiLinkedData_Interface::GetLinks() const
//{
//	FairMultiLinkedData* myData = (FairMultiLinkedData*)(FairRootManager::Instance()->GetLinkData(fLinkToFairMultiLinkedData));
//	return myData->GetLinks();
//}

FairMultiLinkedData* FairMultiLinkedData_Interface::GetMultiLinks() const
{
//	std::cout << "LinkToFairMultiLinkedData: " << fLinkToFairMultiLinkedData << std::endl;
//	FairMultiLinkedData* myData = (FairMultiLinkedData*)(FairRootManager::Instance()->GetCloneOfLinkData(fLinkToFairMultiLinkedData));
//	std::cout << "myDataPointer " << myData << std::endl;
//	if (myData > 0)
//		myData->Print();

	return fPointerToData;
}

std::set<FairLink> FairMultiLinkedData_Interface::GetLinks()
{
	SetPointerToData();
	if (fPointerToData != 0){
		return fPointerToData->GetLinks();
	}
	std::set<FairLink> myData;
	return myData;
}

Int_t FairMultiLinkedData_Interface::GetNLinks()
{
	SetPointerToData();
	if (fPointerToData != 0){
		return fPointerToData->GetNLinks();
	}
	return 0;
}

FairLink FairMultiLinkedData_Interface::GetLink(Int_t pos)
{
	SetPointerToData();
	if (fPointerToData != 0){
		return fPointerToData->GetLink(pos);
	}
	return FairLink();
}


void FairMultiLinkedData_Interface::ResetLinks()
{
	SetPointerToData();
	if (fPointerToData != 0){
		fPointerToData->ResetLinks();
	}
}				                                    ///< Clears fLinks

void FairMultiLinkedData_Interface::SetPointerToData()
{
	if (fPointerToData != 0){
		return;
	}
	if (fLinkBranchName == ""){
		return;
	}
	if (fFairMultiLinkedDataExists == kFALSE){
		fPointerToData = CreateFairMultiLinkedData();
	}
}