/**

  * 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 "HandleSys.h"

 #include "TimerSys.h"

 #include "Logger.h"

 #define TIMER_HNDL_CLOSE	(1<<9)

 HandleType_t g_TimerType;

 struct TimerInfo 

 {

 	ITimer *Timer;

 	IPluginFunction *Hook;

 	IPluginContext *pContext;

 	Handle_t TimerHandle;

 	int UserData;

 	int Flags;

 };

 class TimerNatives :

 	public SMGlobalClass,

 	public IHandleTypeDispatch,

 	public ITimedEvent

 {

 public:

 	~TimerNatives();

 public: //ITimedEvent

 	ResultType OnTimer(ITimer *pTimer, void *pData);

 	void OnTimerEnd(ITimer *pTimer, void *pData);

 public: //IHandleTypeDispatch

 	void OnHandleDestroy(HandleType_t type, void *object);

 public: //SMGlobalClass

 	void OnSourceModAllInitialized();

 	void OnSourceModShutdown();

 public:

 	TimerInfo *CreateTimerInfo();

 	void DeleteTimerInfo(TimerInfo *pInfo);

 private:

 	CStack<TimerInfo *> m_FreeTimers;

 };

 TimerNatives::~TimerNatives()

 {

 	CStack<TimerInfo *>::iterator iter;

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

 	{

 		delete (*iter);

 	}

 	m_FreeTimers.popall();

 }

 void TimerNatives::OnSourceModAllInitialized()

 {

 	HandleAccess sec;

 	sec.access[HandleAccess_Clone] |= HANDLE_RESTRICT_IDENTITY;

 	g_TimerType = g_HandleSys.CreateType("Timer", this, 0, NULL, &sec, g_pCoreIdent, NULL);

 }

 void TimerNatives::OnSourceModShutdown()

 {

 	g_HandleSys.RemoveType(g_TimerType, g_pCoreIdent);

 	g_TimerType = 0;

 }

 void TimerNatives::OnHandleDestroy(HandleType_t type, void *object)

 {

 	TimerInfo *pTimer = reinterpret_cast<TimerInfo *>(object);

 	g_Timers.KillTimer(pTimer->Timer);

 }

 TimerInfo *TimerNatives::CreateTimerInfo()

 {

 	TimerInfo *pInfo;

 	if (m_FreeTimers.empty())

 	{

 		pInfo = new TimerInfo;

 	} else {

 		pInfo = m_FreeTimers.front();

 		m_FreeTimers.pop();

 	}

 	return pInfo;

 }

 void TimerNatives::DeleteTimerInfo(TimerInfo *pInfo)

 {

 	m_FreeTimers.push(pInfo);

 }

 ResultType TimerNatives::OnTimer(ITimer *pTimer, void *pData)

 {

 	TimerInfo *pInfo = reinterpret_cast<TimerInfo *>(pData);

 	IPluginFunction *pFunc = pInfo->Hook;

 	cell_t res = static_cast<ResultType>(Pl_Continue);

 	pFunc->PushCell(pInfo->TimerHandle);

 	pFunc->PushCell(pInfo->UserData);

 	pFunc->Execute(&res);

 	return static_cast<ResultType>(res);

 }

 void TimerNatives::OnTimerEnd(ITimer *pTimer, void *pData)

 {

 	HandleSecurity sec;

 	HandleError herr;

 	TimerInfo *pInfo = reinterpret_cast<TimerInfo *>(pData);

 	Handle_t usrhndl = static_cast<Handle_t>(pInfo->UserData);

 	sec.pOwner = pInfo->pContext->GetIdentity();

 	sec.pIdentity = g_pCoreIdent;

 	if (pInfo->Flags & TIMER_HNDL_CLOSE)

 	{

 		if ((herr=g_HandleSys.FreeHandle(usrhndl, &sec)) != HandleError_None)

 		{

 			g_Logger.LogError("Invalid data handle %x (error %d) passed during timer end", usrhndl, herr);

 		}

 	}

 	g_HandleSys.FreeHandle(pInfo->TimerHandle, &sec);

 	DeleteTimerInfo(pInfo);

 }

 /*******************************

 *                              *

 * TIMER NATIVE IMPLEMENTATIONS *

 *                              *

 ********************************/

 static TimerNatives s_TimerNatives;

 static cell_t smn_CreateTimer(IPluginContext *pCtx, const cell_t *params)

 {

 	IPluginFunction *pFunc;

 	TimerInfo *pInfo;

 	ITimer *pTimer;

 	Handle_t hndl;

 	int flags = params[4];

 	pFunc = pCtx->GetFunctionById(params[2]);

 	if (!pFunc)

 	{

 		return pCtx->ThrowNativeError("Invalid function id (%X)", params[2]);

 	}

 	pInfo = s_TimerNatives.CreateTimerInfo();

 	pTimer = g_Timers.CreateTimer(&s_TimerNatives, sp_ctof(params[1]), pInfo, flags);

 	hndl = g_HandleSys.CreateHandle(g_TimerType, pInfo, pCtx->GetIdentity(), g_pCoreIdent, NULL);

 	pInfo->UserData = params[3];

 	pInfo->Flags = flags;

 	pInfo->TimerHandle = hndl;

 	pInfo->Hook = pFunc;

 	pInfo->Timer = pTimer;

 	pInfo->pContext = pCtx;

 	return hndl;

 }

 static cell_t smn_KillTimer(IPluginContext *pCtx, const cell_t *params)

 {

 	Handle_t hndl = static_cast<Handle_t>(params[1]);

 	HandleError herr;

 	HandleSecurity sec;

 	TimerInfo *pInfo;

 	sec.pOwner = pCtx->GetIdentity();

 	sec.pIdentity = g_pCoreIdent;

 	if ((herr=g_HandleSys.ReadHandle(hndl, g_TimerType, &sec, (void **)&pInfo))

 		!= HandleError_None)

 	{

 		return pCtx->ThrowNativeError("Invalid timer handle %x (error %d)", hndl, herr);

 	}

 	g_Timers.KillTimer(pInfo->Timer);

 	if (params[2] && !(pInfo->Flags & TIMER_HNDL_CLOSE))

 	{

 		sec.pOwner = pInfo->pContext->GetIdentity();

 		sec.pIdentity = g_pCoreIdent;

 		if ((herr=g_HandleSys.FreeHandle(static_cast<Handle_t>(pInfo->UserData), &sec)) != HandleError_None)

 		{

 			return pCtx->ThrowNativeError("Invalid data handle %x (error %d)", hndl, herr);

 		}

 	}

 	return 1;

 }

 static cell_t smn_TriggerTimer(IPluginContext *pCtx, const cell_t *params)

 {

 	Handle_t hndl = static_cast<Handle_t>(params[1]);

 	HandleError herr;

 	HandleSecurity sec;

 	TimerInfo *pInfo;

 	sec.pOwner = NULL;

 	sec.pIdentity = g_pCoreIdent;

 	if ((herr=g_HandleSys.ReadHandle(hndl, g_TimerType, &sec, (void **)&pInfo))

 		!= HandleError_None)

 	{

 		return pCtx->ThrowNativeError("Invalid timer handle %x (error %d)", hndl, herr);

 	}

 	g_Timers.FireTimerOnce(pInfo->Timer, params[2] ? true : false);

 	return 1;

 }

 static cell_t smn_GetTickedTime(IPluginContext *pContext, const cell_t *params)

 {

 	cell_t *simulating;

 	pContext->LocalToPhysAddr(params[1], &simulating);

 	*simulating = g_SimTicks.ticking ? 0 : 1;

 	float t = g_SimTicks.ticking ? gpGlobals->curtime : g_SimTicks.ticktime;

 	return sp_ftoc(t);

 }

 REGISTER_NATIVES(timernatives)

 {

 	{"CreateTimer",				smn_CreateTimer},

 	{"KillTimer",				smn_KillTimer},

 	{"TriggerTimer",			smn_TriggerTimer},

 	{"GetTickedTime",			smn_GetTickedTime},

 	{NULL,						NULL}

 };