/**

  * vim: set ts=4 :

  * =============================================================================

  * SourceMod

  * Copyright (C) 2004-2007 AlliedModders LLC.  All rights reserved.

  * =============================================================================

  *

  * This program is free software; you can redistribute it and/or modify it under

  * the terms of the GNU General Public License, version 3.0, as published by the

  * Free Software Foundation.

  * 

  * This program is distributed in the hope that it will be useful, but WITHOUT

  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more

  * details.

  *

  * You should have received a copy of the GNU General Public License along with

  * this program.  If not, see <http://www.gnu.org/licenses/>.

  *

  * As a special exception, AlliedModders LLC gives you permission to link the

  * code of this program (as well as its derivative works) to "Half-Life 2," the

  * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software

  * by the Valve Corporation.  You must obey the GNU General Public License in

  * all respects for all other code used.  Additionally, AlliedModders LLC grants

  * this exception to all derivative works.  AlliedModders LLC defines further

  * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),

  * or <http://www.sourcemod.net/license.php>.

  *

  * Version: $Id$

  */

 #include <time.h>

 #include "TimerSys.h"

 #include "sourcemm_api.h"

 TimerSystem g_Timers;

 ConVar sm_time_adjustment("sm_time_adjustment", "0", 0, "Adjusts the server time in seconds");

 time_t GetAdjustedTime(time_t *buf)

 {

 	time_t val = time(NULL) + sm_time_adjustment.GetInt();

 	if (buf)

 	{

 		*buf = val;

 	}

 	return val;

 }

 inline float GetSimulatedTime()

 {

 	return engine->Time();

 }

 void ITimer::Initialize(ITimedEvent *pCallbacks, float fInterval, float fToExec, void *pData, int flags)

 {

 	m_Listener = pCallbacks;

 	m_Interval = fInterval;

 	m_ToExec = fToExec;

 	m_pData = pData;

 	m_Flags = flags;

 	m_InExec = false;

 	m_KillMe = false;

 }

 TimerSystem::TimerSystem()

 {

 	m_fnTimeLeft = NULL;

 }

 TimerSystem::~TimerSystem()

 {

 	CStack<ITimer *>::iterator iter;

 	for (iter=m_FreeTimers.begin(); iter!=m_FreeTimers.end(); iter++)

 	{

 		delete (*iter);

 	}

 	m_FreeTimers.popall();

 }

 void TimerSystem::OnSourceModAllInitialized()

 {

 	g_ShareSys.AddInterface(NULL, this);

 }

 void TimerSystem::OnSourceModLevelChange(const char *mapName)

 {

 	MapChange(true);

 }

 void TimerSystem::RunFrame()

 {

 	ITimer *pTimer;

 	TimerIter iter;

 	float curtime = GetSimulatedTime();

 	for (iter=m_SingleTimers.begin(); iter!=m_SingleTimers.end(); )

 	{

 		pTimer = (*iter);

 		if (curtime >= pTimer->m_ToExec)

 		{

 			pTimer->m_InExec = true;

 			pTimer->m_Listener->OnTimer(pTimer, pTimer->m_pData);

 			pTimer->m_Listener->OnTimerEnd(pTimer, pTimer->m_pData);

 			iter = m_SingleTimers.erase(iter);

 			m_FreeTimers.push(pTimer);

 		} else {

 			break;

 		}

 	}

 	if (m_fnTimeLeft != NULL && m_MapEndTimers.size())

 	{

 		float time_left = m_fnTimeLeft();

 		for (iter=m_MapEndTimers.begin(); iter!=m_MapEndTimers.end();)

 		{

 			pTimer = (*iter);

 			if ((*iter)->m_Interval < time_left)

 			{

 				pTimer->m_InExec = true;

 				pTimer->m_Listener->OnTimer(pTimer, pTimer->m_pData);

 				pTimer->m_Listener->OnTimerEnd(pTimer, pTimer->m_pData);

 				iter = m_MapEndTimers.erase(iter);

 				m_FreeTimers.push(pTimer);

 			} else {

 				break;

 			}

 		}

 	}

 	ResultType res;

 	for (iter=m_LoopTimers.begin(); iter!=m_LoopTimers.end(); )

 	{

 		pTimer = (*iter);

 		if (curtime >= pTimer->m_ToExec)

 		{

 			pTimer->m_InExec = true;

 			res = pTimer->m_Listener->OnTimer(pTimer, pTimer->m_pData);

 			if (pTimer->m_KillMe || (res == Pl_Stop))

 			{

 				pTimer->m_Listener->OnTimerEnd(pTimer, pTimer->m_pData);

 				iter = m_LoopTimers.erase(iter);

 				m_FreeTimers.push(pTimer);

 				continue;

 			}

 			pTimer->m_InExec = false;

 			pTimer->m_ToExec = curtime + pTimer->m_Interval;

 		}

 		iter++;

 	}

 	m_LastExecTime = curtime;

 }

 ITimer *TimerSystem::CreateTimer(ITimedEvent *pCallbacks, float fInterval, void *pData, int flags)

 {

 	ITimer *pTimer;

 	TimerIter iter;

 	float to_exec = GetSimulatedTime() + fInterval;

 	if (m_FreeTimers.empty())

 	{

 		pTimer = new ITimer;

 	} else {

 		pTimer = m_FreeTimers.front();

 		m_FreeTimers.pop();

 	}

 	pTimer->Initialize(pCallbacks, fInterval, to_exec, pData, flags);

 	if (flags & TIMER_FLAG_REPEAT)

 	{

 		m_LoopTimers.push_back(pTimer);

 		goto return_timer;

 	}

 	if (flags & TIMER_FLAG_BEFORE_MAP_END)

 	{

 		for (iter=m_MapEndTimers.begin(); iter!=m_MapEndTimers.end(); iter++)

 		{

 			if (fInterval >= (*iter)->m_Interval)

 			{

 				m_MapEndTimers.insert(iter, pTimer);

 				goto return_timer;

 			}

 		}

 		m_MapEndTimers.push_back(pTimer);

 	} else {

 		if (m_SingleTimers.size() >= 1)

 		{

 			iter = --m_SingleTimers.end();

 			if ((*iter)->m_ToExec <= to_exec)

 			{

 				goto normal_insert_end;

 			}

 		}

 		for (iter=m_SingleTimers.begin(); iter!=m_SingleTimers.end(); iter++)

 		{

 			if ((*iter)->m_ToExec >= to_exec)

 			{

 				m_SingleTimers.insert(iter, pTimer);

 				goto return_timer;

 			}

 		}

 normal_insert_end:

 		m_SingleTimers.push_back(pTimer);

 	}

 return_timer:

 	return pTimer;

 }

 void TimerSystem::FireTimerOnce(ITimer *pTimer, bool delayExec)

 {

 	ResultType res;

 	if (pTimer->m_InExec)

 	{

 		return;

 	}

 	pTimer->m_InExec = true;

 	res = pTimer->m_Listener->OnTimer(pTimer, pTimer->m_pData);

 	if (!(pTimer->m_Flags & TIMER_FLAG_REPEAT))

 	{

 		pTimer->m_Listener->OnTimerEnd(pTimer, pTimer->m_pData);

 		if (pTimer->m_Flags & TIMER_FLAG_BEFORE_MAP_END)

 		{

 			m_MapEndTimers.remove(pTimer);

 		} else {

 			m_SingleTimers.remove(pTimer);

 		}

 		m_FreeTimers.push(pTimer);

 	} else {

 		if ((res != Pl_Stop) && !pTimer->m_KillMe)

 		{

 			if (delayExec)

 			{

 				pTimer->m_ToExec = GetSimulatedTime() + pTimer->m_Interval;

 			}

 			pTimer->m_InExec = false;

 			return;

 		}

 		pTimer->m_Listener->OnTimerEnd(pTimer, pTimer->m_pData);

 		m_LoopTimers.remove(pTimer);

 		m_FreeTimers.push(pTimer);

 	}

 }

 void TimerSystem::KillTimer(ITimer *pTimer)

 {

 	TimerList *pList;

 	if (pTimer->m_KillMe)

 	{

 		return;

 	}

 	if (pTimer->m_InExec)

 	{

 		pTimer->m_KillMe = true;

 		return;

 	}

 	pTimer->m_InExec = true; /* The timer it's not really executed but this check needs to be done */

 	pTimer->m_Listener->OnTimerEnd(pTimer, pTimer->m_pData);

 	if (pTimer->m_Flags & TIMER_FLAG_REPEAT)

 	{

 		m_LoopTimers.remove(pTimer);

 	} else if (pTimer->m_Flags & TIMER_FLAG_BEFORE_MAP_END) {

 		m_MapEndTimers.remove(pTimer);

 	} else {

 		m_SingleTimers.remove(pTimer);

 	}

 	pList->remove(pTimer);

 	m_FreeTimers.push(pTimer);

 }

 CStack<ITimer *> s_tokill;

 void TimerSystem::MapChange(bool real_mapchange)

 {

 	ITimer *pTimer;

 	TimerIter iter;

 	for (iter=m_SingleTimers.begin(); iter!=m_SingleTimers.end(); iter++)

 	{

 		pTimer = (*iter);

 		if (real_mapchange && (pTimer->m_Flags & TIMER_FLAG_NO_MAPCHANGE))

 		{

 			s_tokill.push(pTimer);

 		} else {

 			pTimer->m_ToExec = pTimer->m_ToExec - m_LastExecTime + GetSimulatedTime();

 		}

 	}

 	for (iter=m_LoopTimers.begin(); iter!=m_LoopTimers.end(); iter++)

 	{

 		pTimer = (*iter);

 		if (real_mapchange && (pTimer->m_Flags & TIMER_FLAG_NO_MAPCHANGE))

 		{

 			s_tokill.push(pTimer);

 		} else {

 			pTimer->m_ToExec = pTimer->m_ToExec - m_LastExecTime + GetSimulatedTime();

 		}

 	}

 	if (real_mapchange)

 	{

 		for (iter=m_MapEndTimers.begin(); iter!=m_MapEndTimers.end(); iter++)

 		{

 			pTimer = (*iter);

 			s_tokill.push(pTimer);

 		}

 	}

 	while (!s_tokill.empty())

 	{

 		KillTimer(s_tokill.front());

 		s_tokill.pop();

 	}

 	m_LastExecTime = GetSimulatedTime();

 }

 SM_TIMELEFT_FUNCTION TimerSystem::SetTimeLeftFunction(SM_TIMELEFT_FUNCTION fn)

 {

 	SM_TIMELEFT_FUNCTION old = m_fnTimeLeft;

 	m_fnTimeLeft = fn;

 	return old;

 }