#include "TransformationCDPP3DView.h"

#include <vector>
#include <iterator>
// 9639
#include <algorithm>

#include "../../CDPP3DViewSOAPClient/cdppBinder.nsmap"

#include "../Common/Toolbox.h"
#include "../DataRetriever/DataRetriever.h"
#include "../File/FileLoaderManager.h"
#include "../TimeManager/TimeManager.h"

using namespace TREPS::Common;
using namespace TREPS::DataRetriever;
using namespace TREPS::File;
using namespace TREPS::TimeManager;

namespace TREPS
{
	namespace Transformation
	{
		TransformationCDPP3DViewClass::TransformationCDPP3DViewClass(RequestAbstractClass *trepsRequest):TransformationAbstractClass(trepsRequest),
						client(NULL)
		{
			//init SOAP client for 3DView Web Service
			this->client = new cdppBinderProxy(SOAP_IO_KEEPALIVE);
			soap_ssl_init();
			if (soap_ssl_client_context(this->client,
				SOAP_SSL_NO_AUTHENTICATION,
				NULL, // keyfile: required only when client must authenticate to server
				NULL, // password to read the key file (not used with GNUTLS)
				NULL, // cacert file to store trusted certificates
				NULL, // capath to directory with trusted certificates
				NULL  // if randfile!=NULL: use a file with random data to seed randomness
			)) {
				this->errorMsg = "Error during the SOAP SSL init: ";
				if (this->client->soap_fault_string() != NULL)
				{
					this->errorMsg += this->client->soap_fault_string();
				}
				LOG4CXX_ERROR(this->app->getLog()->getPtr(),this->errorMsg);
			}
			//
			this->availableFrames.clear();
		}

		TransformationCDPP3DViewClass::~TransformationCDPP3DViewClass(void)
		{
			if (this->client != NULL)
			{
				delete this->client;
				this->client = NULL;
			}
		}

		bool TransformationCDPP3DViewClass::run(const char *workingDir)
		{
			this->errorMsg = "";

			//when source frame == destination frame => no frame transformation to do
			bool noTrans = (this->request->getSrcFrame().compare(this->request->getDstFrame()) == 0);

			//FOr a frame transformation, we need a source vectors list
			if (!noTrans && this->request->getSrcVectors()->empty())
			{
				this->errorMsg = "Empty source vector list";
				LOG4CXX_ERROR(this->app->getLog()->getPtr(),this->errorMsg);
				return false;
			}

			int nbSrcVectors = this->request->getSrcVectors()->size();

			if (noTrans)
			{
				if (nbSrcVectors == 0)
				{
					string status = "Clone source data";
                                	this->trepsRequest->setStatus(status.c_str());
					//if no fame transformation and no vector , content of result file == content of source file, except for the time field
					
					// 9639 if « pattern - TF_PATTERN - user defined pattern » and no transformation
					//this->result->clone(this->request->getSrcFields(), this->request->getSrcDataRecordList(),
					// 			this->request->getTimeFieldId().c_str());
					string startingIdxToCopy = "";
					if(this->request->getTimeFormat()==TF_PATTERN){
						// in case "t_TimeFormat pattern 1"
						// count how many time field []
						string lPattern = this->request->getTimePattern();
						int lCnt = std::count(lPattern.begin(), lPattern.end(), ']') - 1;
						startingIdxToCopy = intToStr(lCnt);

					}else{
						startingIdxToCopy = this->request->getTimeFieldId().c_str();
					}
					this->result->clone(this->request->getSrcFields(), this->request->getSrcDataRecordList(),
							startingIdxToCopy.c_str());

				}
				else
				{
					//no frame transformation, add selected source vectors in result file
					for (t_VectorList::iterator it=this->request->getSrcVectors()->begin(); it != this->request->getSrcVectors()->end(); ++it)
					{
						int crtIndex = distance(this->request->getSrcVectors()->begin(),it);
						string status = "Copy source vector ";
						status += intToStr(crtIndex + 1);
						status += " / ";
						status += intToStr(nbSrcVectors);
						this->trepsRequest->setStatus(status.c_str());

						string fieldId = (*it).id;
						if (!this->result->addFieldVector(fieldId.c_str(), this->request->getSrcDataRecordList(),
									(*it).fieldId[0].c_str(), (*it).fieldId[1].c_str(), (*it).fieldId[2].c_str(),
									this->request->getSrcFrame().c_str()))
						{
							this->errorMsg = "Cannot add vector";
							LOG4CXX_ERROR(this->app->getLog()->getPtr(),this->errorMsg);
							return false;
						}
					}
				}
				return true;
			}

			//for each vector
			for (t_VectorList::iterator it=this->request->getSrcVectors()->begin(); it != this->request->getSrcVectors()->end(); ++it)
			{
				//Init current transformation
				int crtIndex = distance(this->request->getSrcVectors()->begin(),it);

				string vectorStatus = "Current vector : ";
				vectorStatus += intToStr(crtIndex + 1);
				vectorStatus += " / ";
				vectorStatus += intToStr(nbSrcVectors);
				
				//if RTN/RTP, get files
				vector<ns4__TimeFile*> timeFiles;
				//get time manager instance
				TimeManagerClass *timeMgr = TimeManagerClass::getInstance();
				time_t lStart = timeMgr->to_TIMESTAMP(request->getStartTime());
				time_t lStop = timeMgr->to_TIMESTAMP(request->getStopTime());

				LOG4CXX_INFO(this->app->getLog()->getPtr(),"Search for RTN/RTP " << request->getSrcFrame().c_str()<< "/"<<request->getDstFrame().c_str());


				if(request->getSrcFrame().compare("RTN")==0||request->getSrcFrame().compare("RTP")==0){
					LOG4CXX_INFO(this->app->getLog()->getPtr(),"Search for src timeFile for RTN/RTP "<<request->getSrcCenter().c_str());
					istringstream iss(request->getSrcCenter());
					vector<string> splitStr((istream_iterator<string>(iss)),istream_iterator<string>());

					// 11165 : transfo RTN - update parameter checking                
					//if(splitStr.size()!=4) {
         			if(splitStr.size()<4) {                        
						this->errorMsg = "Source frame center should be 4 elements: ";
						this->errorMsg += request->getSrcCenter().c_str();
						LOG4CXX_ERROR(this->app->getLog()->getPtr(),this->errorMsg);
						return false;
					}
					LOG4CXX_INFO(this->app->getLog()->getPtr(),"Found src sc: "<<splitStr.at(2).c_str());
					timeFiles.push_back(callListFilesRequest(atoi(splitStr.at(2).c_str()),lStart,lStop ));
				}
				if(request->getDstFrame().compare("RTN")==0||request->getDstFrame().compare("RTP")==0){
					LOG4CXX_INFO(this->app->getLog()->getPtr(),"Search for dst timeFile for RTN/RTP "<<request->getDstCenter().c_str());
					istringstream iss(request->getDstCenter());
					vector<string> splitStr((istream_iterator<string>(iss)),istream_iterator<string>());
                             
          			// 11165 : transfo RTN - update parameter checking               
					//if(splitStr.size()!=4) {
			        if(splitStr.size()<4) {
						this->errorMsg = "Dest frame center should be 4 elements: ";
						this->errorMsg += request->getDstCenter().c_str();
						LOG4CXX_ERROR(this->app->getLog()->getPtr(),this->errorMsg);
						return false;
					}
					LOG4CXX_INFO(this->app->getLog()->getPtr(),"Found dst sc: "<<splitStr.at(2).c_str());
					timeFiles.push_back(callListFilesRequest(atoi(splitStr.at(2).c_str()),lStart,lStop ));
				}
				
				

				#ifdef WITH_GETORBURL
				//call getOrbUrl to generate a VOTable
				string generalStatus = vectorStatus;
				generalStatus += " - Running step : Send data for transformation";
				this->trepsRequest->setStatus(generalStatus.c_str());
				string url = this->callGetOrbUrlRequest(&(*it));

				if (url.compare("") == 0)
					return false;

				LOG4CXX_INFO(this->app->getLog()->getPtr(),"getOrbUrl result : " << url);

				//call transformation request
				generalStatus = vectorStatus;
                                generalStatus += " - Running step : Compute transformation";
                                this->trepsRequest->setStatus(generalStatus.c_str());
				url = this->callNewFrameRequest(&(*it), url.c_str(),timeFiles);

				#else
				string generalStatus = vectorStatus;
				generalStatus += " - Running step : Compute transformation";
				this->trepsRequest->setStatus(generalStatus.c_str());
				string url = this->callNewFrameRequest(&(*it),timeFiles);
				#endif


				if (url.compare("") == 0)
					return false;

				LOG4CXX_INFO(this->app->getLog()->getPtr(),"listNewFrame result : " << url);

				//copy result VOTable in op workspace
				generalStatus = vectorStatus;
                                generalStatus += " - Running step : Save transformation result";
				this->trepsRequest->setStatus(generalStatus.c_str());
				string filePath = this->copyFileInWorkingDir(url.c_str(),workingDir);

				if (filePath.compare("") == 0)
					return false;

				//add result
				generalStatus = vectorStatus;
                                generalStatus += " - Running step : Merge results";
				this->trepsRequest->setStatus(generalStatus.c_str());
				if (!this->addResultFileInResultVec(filePath.c_str(), &(*it)))
					return false;
			}

			return true;
		}

		t_VectorTuple3d TransformationCDPP3DViewClass::createVectorTuple3d(const t_Vector *vector)
		{
			t_VectorTuple3d vT;

			DataRecordClass *crtRecord = this->request->getSrcDataRecordList()->getFirstRecord();

			while (crtRecord != NULL)
			{
				ns4__Tuple3d *tup = new ns4__Tuple3d();
				tup->x = crtRecord->getDoubleValue(vector->fieldId[0].c_str())*vector->scale;
				tup->y = crtRecord->getDoubleValue(vector->fieldId[1].c_str())*vector->scale;
				tup->z = crtRecord->getDoubleValue(vector->fieldId[2].c_str())*vector->scale;

				vT.push_back(tup);
				crtRecord = crtRecord->getNextRecord();
			}

			return vT;
		}

		void TransformationCDPP3DViewClass::deleteVectorTuple3d(t_VectorTuple3d &vT)
		{
			for (t_VectorTuple3d::iterator it=vT.begin(); it != vT.end(); ++it)
			{
				ns4__Tuple3d *tup = (*it);
				delete tup;
			}
			vT.clear();
		}

		t_VectorTime TransformationCDPP3DViewClass::createTimeList(void)
		{
			t_VectorTime vT;
			vT.clear();

			//get time manager instance
			TimeManagerClass *timeMgr = TimeManagerClass::getInstance();

			t_Time t;
			time_t tt;

			DataRecordClass *crtRecord = this->request->getSrcDataRecordList()->getFirstRecord();

			while (crtRecord != NULL)
			{
				if (this->request->getTimeFormat() == TF_NONE)
					tt = 0;
				else
				{
					t = crtRecord->getTime();
					tt = timeMgr->to_TIMESTAMP(t);
				}
				vT.push_back(tt);
				crtRecord = crtRecord->getNextRecord();
			}

			return vT;
		}

		void TransformationCDPP3DViewClass::deleteTimeList(t_VectorTime &vT)
		{
			vT.clear();
		}

		bool TransformationCDPP3DViewClass::checkFrame(const char *frame)
		{
			this->errorMsg = "";

			if (!this->updateAvailableFrameList())
				return false;

			for (t_StringList::iterator it = this->availableFrames.begin(); it != this->availableFrames.end(); ++it)
			{
				if ((*it).compare(frame) == 0)
					return true;
			}

			this->errorMsg = "Frame not available in 3DView Web Service : ";
			this->errorMsg += frame;
			LOG4CXX_ERROR(this->app->getLog()->getPtr(),this->errorMsg);

			return false;
		}

		t_StringList TransformationCDPP3DViewClass::getAvailableFrameList(void)
		{
			this->updateAvailableFrameList();
			return this->availableFrames;
		}

		bool TransformationCDPP3DViewClass::updateAvailableFrameList(void)
		{
			this->errorMsg = "";

			if (this->availableFrames.empty())
			{
				//get frames list
				_ns3__listFrames2 listFrames2Request;

				_ns3__listFrames2Response listFrames2Response;

        //compilAndInstall.sh pb compilation Ubuntu
        // error: no matching function for call to ‘cdppBinderProxy::listFrames2(_ns3__listFrames2*, _ns3__listFrames2Response*)
        bool res = (this->client->listFrames2(&listFrames2Request,&listFrames2Response) == SOAP_OK);
		//bool res = (this->client->listFrames2(&listFrames2Request,listFrames2Response) == SOAP_OK);

				if (!res)
				{
					this->errorMsg = "Error during the call of listFrames2 of 3DView Web Service";
					LOG4CXX_ERROR(this->app->getLog()->getPtr(),this->errorMsg);
					return false;
				}

				for (std::vector<ns4__Frame*>::iterator it=listFrames2Response.return_.begin(); it!=listFrames2Response.return_.end(); ++it)
				{
					this->availableFrames.push_back((*it)->name);
				}
				//add dynamic frames
				this->availableFrames.push_back("RTN");
				this->availableFrames.push_back("RTP");
			}

			return true;
		}

		ns4__TimeFile* TransformationCDPP3DViewClass::callListFilesRequest(int bodyId, time_t startTime, time_t stopTime)
		{
			bool res = false;
			
			
			string method = "listFiles";

			//Init 3DView listBodies request
			_ns3__listFiles listFilesRequest;
			//_ns3__listNewFrameOrb listNewFrameOrbRequest;
			//listNewFrameOrbRequest.pUrlInput = NULL;
			//listNewFrameOrbRequest.pDateTimeInput  = this->createTimeList();
			//listNewFrameOrbRequest.pInFrame  = this->request->getSrcFrame();
			//listNewFrameOrbRequest.pOutFrame  = this->request->getDstFrame();
			ns4__TimeFileType type = ns4__TimeFileType__ORBIT;
			listFilesRequest.type = &type;
			listFilesRequest.pBodyId = bodyId;
			listFilesRequest.pStartTime = startTime;
			listFilesRequest.pStopTime = stopTime;

			//run listNewFrameOrb to perform transformation (rotation + translation)
			//_ns3__listNewFrameOrbResponse listNewFrameOrbResponse;
			ns4__TimeFileArray listFilesResponse;
      
      //compilAndInstall.sh pb compilation Ubuntu
      // error: no matching function for call to ‘cdppBinderProxy::listFrames2(_ns3__listFrames2*, _ns3__listFrames2Response*)
			res = (this->client->listFiles(&listFilesRequest,&listFilesResponse) == SOAP_OK);
      		//res = (this->client->listFiles(&listFilesRequest,listFilesResponse) == SOAP_OK);      
      
      
			LOG4CXX_INFO(this->app->getLog()->getPtr(),"found timefiles" << listFilesResponse.timeFile.size());
			if(res && listFilesResponse.timeFile.size()>0) {
				return listFilesResponse.timeFile.at(0);
			} else {
				res = false;
			}
			

			if (!res)
			{
				this->errorMsg = "Error during the call of ";
				this->errorMsg += method;
				this->errorMsg += " of 3DView Web Service";
				if (this->client->soap_fault_string() != NULL)
				{
					this->errorMsg += " (";
                                        this->errorMsg += this->client->soap_fault_string();
                                        this->errorMsg += ")";
				}
				LOG4CXX_ERROR(this->app->getLog()->getPtr(),this->errorMsg);
				
			}

			return NULL;
		}





		#ifdef WITH_GETORBURL
		string TransformationCDPP3DViewClass::callGetOrbUrlRequest(const t_Vector *crtSrcVec)
		{
			//Init 3DView getOrbUrl request
			_ns3__getOrbUrl getOrbUrlRequest;

			//make Tuple3D list
			getOrbUrlRequest.pDataInput = this->createVectorTuple3d(crtSrcVec);

			if (getOrbUrlRequest.pDataInput.empty())
				return "";

                        //make time list
                        getOrbUrlRequest.pDateTimeInput = this->createTimeList();

			//run getOrbUrl to build a VOTable than contains current vector datas
			_ns3__getOrbUrlResponse getOrbUrlResponse;

			bool res = (this->client->getOrbUrl(&getOrbUrlRequest,&getOrbUrlResponse) == SOAP_OK);

			this->deleteTimeList(getOrbUrlRequest.pDateTimeInput);
			this->deleteVectorTuple3d(getOrbUrlRequest.pDataInput);

			if (!res)
			{
				this->errorMsg = "Error during the call of getOrbUrl of 3DView Web Service";
				if (this->client->soap_fault_string() != NULL)
				{
					this->errorMsg += " (";
					this->errorMsg += this->client->soap_fault_string();
					this->errorMsg += ")";
				}
				LOG4CXX_ERROR(this->app->getLog()->getPtr(),this->errorMsg);
				return "";
			}

			return this->getURLResponse(getOrbUrlResponse.return_.c_str());
		}
		#endif

		#ifdef WITH_GETORBURL
		string TransformationCDPP3DViewClass::callNewFrameRequest(const t_Vector *crtSrcVec, const char *dataURL, vector<ns4__TimeFile*> timeFiles)
		#else
		string TransformationCDPP3DViewClass::callNewFrameRequest(const t_Vector *crtSrcVec, vector<ns4__TimeFile*> timeFiles)
		#endif
		{
			bool res = false;
			string response = "";

			string method = "";

			if (crtSrcVec->ispos)
			{
				method = "listNewFrameOrb";
				//Init 3DView listNewFrameOrb request
				_ns3__listNewFrameOrb listNewFrameOrbRequest;
				#ifdef WITH_GETORBURL
				string url = dataURL;
				listNewFrameOrbRequest.pUrlInput = &url;
				#else
				listNewFrameOrbRequest.pUrlInput = NULL;
				listNewFrameOrbRequest.pDataInput = this->createVectorTuple3d(crtSrcVec);

				if (listNewFrameOrbRequest.pDataInput.empty())
					return "";

				listNewFrameOrbRequest.pDateTimeInput  = this->createTimeList();
				#endif
				listNewFrameOrbRequest.pInFrame  = this->request->getSrcFrame();
				listNewFrameOrbRequest.pOutFrame  = this->request->getDstFrame();
				//for RTN/RTP
				listNewFrameOrbRequest.pInCenter  = this->request->getSrcCenter();
				listNewFrameOrbRequest.pOutCenter  = this->request->getDstCenter();
				listNewFrameOrbRequest.pTimeFiles  = timeFiles;

				//run listNewFrameOrb to perform transformation (rotation + translation)
				_ns3__listNewFrameOrbResponse listNewFrameOrbResponse;


        //compilAndInstall.sh pb compilation ubuntu
        // error: no matching function for call 
			  	res = (this->client->listNewFrameOrb(&listNewFrameOrbRequest,&listNewFrameOrbResponse) == SOAP_OK);
        		//res = (this->client->listNewFrameOrb(&listNewFrameOrbRequest,listNewFrameOrbResponse) == SOAP_OK);


				#ifndef WITH_GETORBURL
				this->deleteTimeList(listNewFrameOrbRequest.pDateTimeInput);
				this->deleteVectorTuple3d(listNewFrameOrbRequest.pDataInput);
				#endif

				response = listNewFrameOrbResponse.return_;
			}
			else
			{
				method = "listNewFrameAtt";
				//Init 3DView listNewFrameAtt request
				_ns3__listNewFrameAtt listNewFrameAttRequest;
				#ifdef WITH_GETORBURL
				string url = dataURL;
				listNewFrameAttRequest.pUrlInput = &url;
				#else
				listNewFrameAttRequest.pUrlInput = NULL;
				listNewFrameAttRequest.pDataInput = this->createVectorTuple3d(crtSrcVec);

				if (listNewFrameAttRequest.pDataInput.empty())
					return "";

				listNewFrameAttRequest.pDateTimeInput  = this->createTimeList();
				#endif
				listNewFrameAttRequest.pInFrame  = this->request->getSrcFrame();
				listNewFrameAttRequest.pOutFrame  = this->request->getDstFrame();
				//for RTN/RTP
				listNewFrameAttRequest.pInCenter  = this->request->getSrcCenter();
				listNewFrameAttRequest.pOutCenter  = this->request->getDstCenter();
				listNewFrameAttRequest.pTimeFiles  = timeFiles;

				//run listNewFrameAtt to perform transformation (rotation)
				_ns3__listNewFrameAttResponse listNewFrameAttResponse;



        //compilAndInstall.sh pb compilation ubuntu
        // error: no matching function for call 
				res = (this->client->listNewFrameAtt(&listNewFrameAttRequest,&listNewFrameAttResponse) == SOAP_OK);
        		//res = (this->client->listNewFrameAtt(&listNewFrameAttRequest,listNewFrameAttResponse) == SOAP_OK);


				#ifndef WITH_GETORBURL
				this->deleteTimeList(listNewFrameAttRequest.pDateTimeInput);
				this->deleteVectorTuple3d(listNewFrameAttRequest.pDataInput);
				#endif

				response = listNewFrameAttResponse.return_;
			}

			if (!res)
			{
				this->errorMsg = "Error during the call of ";
				this->errorMsg += method;
				this->errorMsg += " of 3DView Web Service";
				if (this->client->soap_fault_string() != NULL)
				{
					this->errorMsg += " (";
                                        this->errorMsg += this->client->soap_fault_string();
                                        this->errorMsg += ")";
				}
				LOG4CXX_ERROR(this->app->getLog()->getPtr(),this->errorMsg);
				return "";
			}

			return this->getURLResponse(response.c_str());	
		}

		string TransformationCDPP3DViewClass::getURLResponse(const char *response)
		{
			string res = response;

			if (res.compare("Error No file generated.") == 0)
			{
				this->errorMsg = "3DView Web Service return an error";
				LOG4CXX_ERROR(this->app->getLog()->getPtr(),this->errorMsg);
				return "";
			}

			//make full URL
			string fullURL = this->app->getConf()->get3DViewWSBaseURL();
			fullURL += response;

			return fullURL;
		}

		string TransformationCDPP3DViewClass::copyFileInWorkingDir(const char *fullURL, const char *workingDir)
		{
			//Init data retriever
			DataRetrieverClass *dataRet = new DataRetrieverClass();

			//extract file name
			string fileName = getFileNameStr(fullURL);

			bool res = dataRet->copyWebFile(fullURL,workingDir,fileName.c_str());

			if (!res)
			{
				this->errorMsg = "Cannot copy result file in workind dir";
				LOG4CXX_ERROR(this->app->getLog()->getPtr(),this->errorMsg);
				return "";
			}

			delete dataRet;

			string filePath = getPathCorrection(workingDir);
			filePath += fileName;

			return filePath;
		}

		bool TransformationCDPP3DViewClass::addResultFileInResultVec(const char *resultFile, const t_Vector *crtSrcVec)
		{
			//Init file loader manager
			FileLoaderManagerClass *fileLoaderMgr = new FileLoaderManagerClass();

			bool res = false;

			//Get result data
			DataRecordListClass crtResData;
			crtResData.clear();

			if (fileLoaderMgr->init(resultFile))
			{
				int crtTotal = 0;
				res = fileLoaderMgr->getData(0,0,&crtResData,crtTotal);
			}

			delete fileLoaderMgr;

			if (!res)
			{
				crtResData.clear();
				this->errorMsg = "Cannot open result file";
				LOG4CXX_ERROR(this->app->getLog()->getPtr(),this->errorMsg);
				return false;
			}

			if (this->request->getTimeFormat() != TF_NONE)
			{
				//update time in result data
				if (!crtResData.loadTimes(CDPP3DVIEW_TIME_ID,TF_PATTERN,CDPP3DVIEW_TIME_PATTERN))
				{
					crtResData.clear();

					this->errorMsg = "Cannot load times in result file";

					LOG4CXX_ERROR(this->app->getLog()->getPtr(),this->errorMsg);
					return false;
				}
			}

			//make a unique field id
			string fieldId = crtSrcVec->id;

			return this->result->addFieldVector(fieldId.c_str(), &crtResData,
								CDPP3DVIEW_COMP1_ID, CDPP3DVIEW_COMP2_ID, CDPP3DVIEW_COMP3_ID,
								this->request->getDstFrame().c_str());
		}
	}
}