#include "TimeManager.h"

#include <iostream>

#include <cstdio>
#include <cstring>
#include <cstdlib>

#include "cdf.h"

#include "../Common/Toolbox.h"

using namespace TREPS::Common;

namespace TREPS
{
	namespace TimeManager
	{
		TimeManagerClass::TimeManagerClass(void): app(NULL), loader(NULL), crtPattern(NULL)
		{
			this->app = ApplicationClass::getInstance();
			//create a time pattern class
			this->crtPattern = new TimePatternClass();
		}

		TimeManagerClass::~TimeManagerClass(void)
		{
			if (this->loader != NULL)
			{
				this->loader->close();
				delete this->loader;
				this->loader = NULL;
			}
			if (this->crtPattern != NULL)
			{
				delete this->crtPattern;
				this->crtPattern = NULL;
			}	
		}

		bool TimeManagerClass::init(const char *file_path)
		{
			//init loader
			if (this->loader == NULL)
				this->loader = new XMLManagerClass();

			this->loader->close();

			if (!this->loader->isExist(file_path))
			{
				LOG4CXX_ERROR(this->app->getLog()->getPtr(),"Cannot find times file : " << file_path);
				return false;
			}

			//load time formats file
			if (!this->loader->loadFile(file_path))
			{
				LOG4CXX_ERROR(this->app->getLog()->getPtr(),"Cannot load times file : " << file_path);
				return false;
			}

			//check xsd validity
			if (!this->loader->isValid(TREPS_TIMES_XSD))
			{
				LOG4CXX_ERROR(this->app->getLog()->getPtr(),"Invalid times file : " << file_path);
				return false;
			}

			return true;
                }

		NodeList TimeManagerClass::getTimeNodeList(void)
		{
			NodeList timeList;
			timeList.clear();

			if (this->loader == NULL)
				return timeList;

			if (!this->loader->isInUse())
				return timeList;

			Node *timesNode = this->loader->getChildFromRoot("times");

			if (timesNode == NULL)
				return timeList;

			timeList = this->loader->getChildrenFromNode("time",timesNode);

			return timeList;
		}

		string TimeManagerClass::getPatternFromTimeId(const char *timeId)
		{
			NodeList timeNodes = this->getTimeNodeList();

			if (timeNodes.empty())
				return "";

			for (NodeList::iterator timeNode = timeNodes.begin(); timeNode != timeNodes.end(); ++timeNode)
			{
				string id = this->loader->getAttributeFromNode("id",*timeNode);

				if (id.compare(timeId) == 0)
				{
					//try to get time pattern if exist
					Node *patternNode = this->loader->getChildFromNode("pattern",(*timeNode));

					if (patternNode == NULL)
						return "";

					return this->loader->getNodeContent(patternNode);
				}
			}

			return "";
		}

		string TimeManagerClass::getTimeIdFromPattern(const char *pattern)
		{
			//retrieve time format by time pattern
			NodeList timeNodes = this->getTimeNodeList();

			if (timeNodes.empty())
				return "";

			for (NodeList::iterator timeNode = timeNodes.begin(); timeNode != timeNodes.end(); ++timeNode)
			{
				Node *patternNode = this->loader->getChildFromNode("pattern",(*timeNode));

				if (patternNode == NULL)
					continue;

				string p = this->loader->getNodeContent(patternNode);

				if (p.compare("") == 0)
					continue;

				if (p.compare(pattern) == 0)
					return this->loader->getAttributeFromNode("id",*timeNode);
			}

			return "";
		}

		t_TimeFormat TimeManagerClass::getFormatFromTimeId(const char *timeId)
		{
			if (strcmp(timeId,"pattern") == 0)
                                return TF_PATTERN;
                        else if (strcmp(timeId,"decyear") == 0)
                                return TF_DECIMAL;
                        else if (strcmp(timeId,"epoch") == 0)
                                return TF_EPOCH;
			else if (strcmp(timeId,"tt2000") == 0)
				return TF_TT2000;
                        else if (strcmp(timeId, "ddtime") == 0)
                                return TF_DDTIME;
			else if (strcmp(timeId, "timestamp") == 0)
				return TF_TIMESTAMP;
			else
			{
				//try to get pattern
				string pattern = this->getPatternFromTimeId(timeId);
				if (pattern.compare("") != 0)
					return TF_PATTERN;

			}
                        return TF_NONE;
		}

		string TimeManagerClass::getTimeIdFromFormatAndPattern(t_TimeFormat format, const char *pattern)
		{
			switch (format)
			{
				case TF_NONE    :
					return "";
				case TF_PATTERN :
				{
					//the pattern can be already defined for a time format
					string timeId = this->getTimeIdFromPattern(pattern);
					if (timeId.compare("") != 0)
						return timeId;
					return "pattern";
				}
				case TF_DECIMAL :
					return "decyear";
				case TF_EPOCH   :
					return "epoch";
				case TF_TT2000 :
					return "tt2000";
				case TF_DDTIME :
					return "ddtime";
				case TF_TIMESTAMP :
					return "timestamp";
			}

			return "";
		}

		bool TimeManagerClass::setCurrentPattern(const char *pattern)
		{
			return this->crtPattern->init(pattern);
		}

		int TimeManagerClass::getCurrentPatternSize(void)
		{
			return this->crtPattern->getSize();
		}

		bool TimeManagerClass::from_PATTERN(const char *time, t_Time &t, bool verbose)
		{
			return this->crtPattern->load(time,t,verbose);
		}

		bool TimeManagerClass::from_TIMESTAMP(time_t tt, t_Time &t)
		{
			//unix time
			struct tm tm;
			tm = *localtime(&tt);
			tmToTime(tm, t);
			return true;
		}

		bool TimeManagerClass::from_DECIMAL(double d, t_Time &t)
		{
			//decimal time
			t.ye = (long int)d;

			double part = d - (double)t.ye;

			int totalDay = isLeapYear(t.ye) ? 366 : 365;

			long long int mls = (part * ((long long int)totalDay * 24 * 60 * 60 * 1000));

			t.se = (long int)((double)mls/1000.);
			t.ml = mls - (t.se * 1000);

			t.mi = (long int)((double)t.se/60.);
			t.se -= (t.mi * 60);

			t.ho = (long int)((double)t.mi/60.);
			t.mi -= (t.ho * 60);

			long int doy = 1 + (long int)((double)t.ho/24.);
			t.ho -= ((doy -1) * 24);

			setDOY(t,doy);

			return true;
		}

		bool TimeManagerClass::from_EPOCH(double e, t_Time &t)
		{
			//epoch time (CDF)
			EPOCHbreakdown(e,&t.ye,&t.mo,&t.da,&t.ho,&t.mi,&t.se,&t.ml);
			return true;
		}

		bool TimeManagerClass::from_TT2000(long long int tt, t_Time &t)
		{
			//tt 2000 time (CDF)
			double ye, mo, da, ho, mi, se, ml, mic, nan, pic;
			CDF_TT2000_to_UTC_parts(tt,&ye,&mo,&da,&ho,&mi,&se,&ml,&mic,&nan,&pic);

			t.ye = ye;
			t.mo = mo;
			t.da = da;
			t.ho = ho;
			t.mi = mi;
			t.se = se;
			t.ml = ml;
			t.mic = mic;
			t.nan = nan;
			t.pic = pic;

			return true;
		}

		bool TimeManagerClass::from_DDTIME(const char *dd_time, t_Time &t)
		{
			//DDTime (CDPP/DDServer)
			long int yday;

			int n = sscanf(dd_time, "%04ld%03ld%02ld%02ld%02ld%03ld", &t.ye, &yday, &t.ho, &t.mi, &t.se, &t.ml);

			if (n != 6)
				return false;

			setDOY(t,yday+1);

			return true;
		}

		string TimeManagerClass::to_PATTERN(t_Time t)
		{
			//pattern time
			string time = "";
			this->crtPattern->write(t,time);
			return time;
		}

		time_t TimeManagerClass::to_TIMESTAMP(t_Time t)
		{
			//unix time
			//note : we lost milliseconds during this conversion

			struct tm tt;
			memset(&tt,0,sizeof(struct tm));

			tt.tm_hour = t.ho;
			tt.tm_min  = t.mi;
			tt.tm_sec  = t.se;
			tt.tm_year = t.ye-1900;
			tt.tm_mon  = t.mo-1;
			tt.tm_mday = t.da;

			return mktime(&tt);
			
		}

		double TimeManagerClass::to_DECIMAL(t_Time t)
		{
			//decimal time
			long int totalDay = isLeapYear(t.ye) ? 366 : 365;

			long long int total = (long long int)totalDay * 60 * 60 * 24 * 1000;

			long int doy = getDOY(t);

			long long int part = (long long int)t.ml;
			part += (long long int)t.se * 1000;
			part += (long long int)t.mi * 60 * 1000;
			part += (long long int)t.ho * 60 * 60 * 1000;
			part += (long long int)(doy - 1) * 24 * 60 * 60 * 1000;

			double d = (double)t.ye + (double)((double)part / (double)total);

			return d;
		}

		double TimeManagerClass::to_EPOCH(t_Time t)
		{
			//epoch time (CDF)
			return computeEPOCH(t.ye,t.mo,t.da,t.ho,t.mi,t.se,t.ml);
		}

		long long int TimeManagerClass::to_TT2000(t_Time t)
		{
			//tt 2000 time (CDF)
			return CDF_TT2000_from_UTC_parts((double)t.ye,(double)t.mo,(double)t.da,(double)t.ho,
							(double)t.mi,(double)t.se,(double)t.ml,(double)t.mic,
							(double)t.nan,(double)t.pic);
		}

		string TimeManagerClass::to_DDTIME(t_Time t)
		{
			//DDTime (CDPP/DDServer)
			long int doy = getDOY(t);
			char buf[17];
			sprintf(buf, "%04ld%03ld%02ld%02ld%02ld%03ld", t.ye, (doy-1), t.ho, t.mi, t.se, t.ml);
			buf[16] = '\0';
			return buf;
		}

		string TimeManagerClass::to_string(t_Time t, t_TimeFormat format, const char *pattern)
		{
			//time to string function
			switch (format)
			{
				case TF_NONE :
					return "";
				case TF_PATTERN :
					this->setCurrentPattern(pattern);
					return this->to_PATTERN(t);
				case TF_TIMESTAMP :
				{
					time_t time =  this->to_TIMESTAMP(t);
					return longToStr(time);
				}
				case TF_DECIMAL :
				{
					double time = this->to_DECIMAL(t);
					return doubleToStr(time);
				}
				case TF_EPOCH :
				{
					double time = this->to_EPOCH(t);
					return doubleToStr(time);
				}
				case TF_TT2000 :
				{
					long long int time = this->to_TT2000(t);
					return longlongToStr(time);
				}
				case TF_DDTIME :
					return this->to_DDTIME(t);
			}
			return "";
		}

		string TimeManagerClass::detectPattern(const char *value)
		{
			//try to detect the time pattern of a value
			NodeList timeNodes = this->getTimeNodeList();

			t_StringList patternList;
			patternList.clear();

			for (NodeList::iterator timeNode = timeNodes.begin(); timeNode != timeNodes.end(); ++timeNode)
			{
				//string id = this->loader->getAttributeFromNode("id",*timeNode);

				Node *patternNode = this->loader->getChildFromNode("pattern",(*timeNode));

				if (patternNode == NULL)
					continue;

				string p = this->loader->getNodeContent(patternNode);

				if (p.compare("") == 0)
					continue;

				if (!this->setCurrentPattern(p.c_str()))
					continue;

				t_Time time;

				if (this->from_PATTERN(value,time,false))
					patternList.push_back(p);
			}

			if (patternList.empty())
				return "";

			//get the longer one
			string pattern = "";
			for (t_StringList::iterator p = patternList.begin(); p != patternList.end(); ++p)
			{
				if ((*p).length() > pattern.length())
					pattern = (*p);
			}

			return pattern;
		}
	}
}