/**
 * vim: set ts=4 :
 * =============================================================================
 * SourceMod
 * Copyright (C) 2004-2008 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 "sm_globals.h"
#include <IGameConfigs.h>
#include "UserMessages.h"
#include "TimerSys.h"
#include "PlayerManager.h"
#include "HandleSys.h"
#include "logic_bridge.h"

#if SOURCE_ENGINE == SE_CSGO
#include <game/shared/csgo/protobuf/cstrike15_usermessages.pb.h>
#endif

#define MAX_HUD_CHANNELS		6

int g_HudMsgNum = -1;

struct hud_syncobj_t
{
	int player_channels[256 + 1];
};

struct player_chaninfo_t
{
	double chan_times[MAX_HUD_CHANNELS];
	hud_syncobj_t *chan_syncobjs[MAX_HUD_CHANNELS];
};

struct hud_text_parms
{
	float       x;
	float       y;
	int         effect;
	byte        r1, g1, b1, a1;
	byte        r2, g2, b2, a2;
	float       fadeinTime;
	float       fadeoutTime;
	float       holdTime;
	float       fxTime;
	int         channel;
};

class HudMsgHelpers : 
	public SMGlobalClass,
	public IHandleTypeDispatch,
	public IClientListener
{
public:
	bool IsSupported()
	{
		return (g_HudMsgNum != -1);
	}

	virtual void OnSourceModAllInitialized_Post()
	{
		const char *key;

		key = g_pGameConf->GetKeyValue("HudTextMsg");
		if (key != NULL)
		{
			g_HudMsgNum = g_UserMsgs.GetMessageIndex(key);
		}

		if (!IsSupported())
		{
			m_hHudSyncObj = 0;
			m_PlayerHuds = NULL;
			return;
		}

		m_PlayerHuds = new player_chaninfo_t[256+1];
		m_hHudSyncObj = g_HandleSys.CreateType("HudSyncObj", this, 0, NULL, NULL, g_pCoreIdent, NULL);

		g_Players.AddClientListener(this);
	}

	virtual void OnSourceModShutdown()
	{
		if (!IsSupported())
		{
			return;
		}

		delete [] m_PlayerHuds;
		g_HandleSys.RemoveType(m_hHudSyncObj, g_pCoreIdent);

		g_Players.RemoveClientListener(this);
	}

	virtual void OnHandleDestroy(HandleType_t type, void *object)
	{
		hud_syncobj_t *obj = (hud_syncobj_t *)object;

		delete obj;
	}

	virtual bool GetHandleApproxSize(HandleType_t type, void *object, unsigned int *pSize)
	{
		*pSize = sizeof(unsigned int) * g_Players.GetMaxClients();
		return true;
	}

	virtual void OnClientConnected(int client)
	{
		player_chaninfo_t *player;

		player = &m_PlayerHuds[client];
		memset(player->chan_syncobjs, 0, sizeof(player->chan_syncobjs));
		memset(player->chan_times, 0, sizeof(player->chan_times));
	}

	Handle_t CreateHudSyncObj(IdentityToken_t *pIdent)
	{
		Handle_t hndl;
		HandleError err;
		hud_syncobj_t *obj;
		HandleSecurity sec;

		obj = new hud_syncobj_t;

		memset(obj->player_channels, 0, sizeof(obj->player_channels));

		sec = HandleSecurity(pIdent, g_pCoreIdent);
		
		if ((hndl = g_HandleSys.CreateHandleEx(m_hHudSyncObj, obj, &sec, NULL, &err))
			== BAD_HANDLE)
		{
			delete obj;
		}

		return hndl;
	}

	HandleError ReadHudSyncObj(Handle_t hndl, 
		IdentityToken_t *pOwner, 
		hud_syncobj_t **pObj)
	{
		HandleSecurity sec(pOwner, g_pCoreIdent);
		return g_HandleSys.ReadHandle(hndl, m_hHudSyncObj, &sec, (void **)pObj);
	}

	unsigned int AutoSelectChannel(unsigned int client)
	{
		int last_channel;
		player_chaninfo_t *player;

		player = &m_PlayerHuds[client];

		last_channel = 0;
		for (unsigned int i = 1; i < MAX_HUD_CHANNELS; i++)
		{
			if (player->chan_times[i] < player->chan_times[last_channel])
			{
				last_channel = i;
			}
		}

		ManualSelectChannel(client, last_channel);

		return last_channel;
	}

	int TryReuseLastChannel(unsigned int client, hud_syncobj_t *obj)
	{
		int last_channel;
		player_chaninfo_t *player;

		player = &m_PlayerHuds[client];

		/* First, see if we can re-use the previous channel. */
		last_channel = obj->player_channels[client];

		if (player->chan_syncobjs[last_channel] == obj)
		{
			player->chan_times[last_channel] = *g_pUniversalTime;
			return last_channel;
		}

		return -1;
	}

	int AutoSelectChannel(unsigned int client, hud_syncobj_t *obj)
	{
		int last_channel;
		player_chaninfo_t *player;

		player = &m_PlayerHuds[client];
		
		/* First, see if we can re-use the previous channel. */
		last_channel = obj->player_channels[client];

		if (player->chan_syncobjs[last_channel] == obj)
		{
			player->chan_times[last_channel] = *g_pUniversalTime;
			return last_channel;
		}

		last_channel = 0;
		for (unsigned int i = 1; i < MAX_HUD_CHANNELS; i++)
		{
			if (player->chan_times[i] < player->chan_times[last_channel])
			{
				last_channel = i;
			}
		}

		obj->player_channels[client] = last_channel;
		player->chan_syncobjs[last_channel] = obj;
		player->chan_times[last_channel] = *g_pUniversalTime;

		return last_channel;
	}

	int ManualSelectChannel(unsigned int client, int channel)
	{
		player_chaninfo_t *player;

		player = &m_PlayerHuds[client];
		player->chan_times[channel] = *g_pUniversalTime;
		player->chan_syncobjs[channel] = NULL;

		return channel;
	}
private:
	HandleType_t m_hHudSyncObj;
	player_chaninfo_t *m_PlayerHuds;
} s_HudMsgHelpers;

hud_text_parms g_hud_params;

static cell_t CreateHudSynchronizer(IPluginContext *pContext, const cell_t *params)
{
	return s_HudMsgHelpers.CreateHudSyncObj(pContext->GetIdentity());
}

static cell_t SetHudTextParams(IPluginContext *pContext, const cell_t *params)
{
	g_hud_params.x = sp_ctof(params[1]);
	g_hud_params.y = sp_ctof(params[2]);
	g_hud_params.holdTime = sp_ctof(params[3]);
	g_hud_params.r1 = static_cast<byte>(params[4]);
	g_hud_params.g1 = static_cast<byte>(params[5]);
	g_hud_params.b1 = static_cast<byte>(params[6]);
	g_hud_params.a1 = static_cast<byte>(params[7]);
	g_hud_params.effect = params[8];
	g_hud_params.fxTime = sp_ctof(params[9]);
	g_hud_params.fadeinTime = sp_ctof(params[10]);
	g_hud_params.fadeoutTime = sp_ctof(params[11]);
	g_hud_params.r2 = 255;
	g_hud_params.g2 = 255;
	g_hud_params.b2 = 250;
	g_hud_params.a2 = 0;

	return 1;
}

static cell_t SetHudTextParamsEx(IPluginContext *pContext, const cell_t *params)
{
	cell_t *color1, *color2;

	pContext->LocalToPhysAddr(params[4], &color1);
	pContext->LocalToPhysAddr(params[5], &color2);

	g_hud_params.x = sp_ctof(params[1]);
	g_hud_params.y = sp_ctof(params[2]);
	g_hud_params.holdTime = sp_ctof(params[3]);
	g_hud_params.r1 = static_cast<byte>(color1[0]);
	g_hud_params.g1 = static_cast<byte>(color1[1]);
	g_hud_params.b1 = static_cast<byte>(color1[2]);
	g_hud_params.a1 = static_cast<byte>(color1[3]);
	g_hud_params.effect = params[6];
	g_hud_params.fxTime = sp_ctof(params[7]);
	g_hud_params.fadeinTime = sp_ctof(params[8]);
	g_hud_params.fadeoutTime = sp_ctof(params[9]);
	g_hud_params.r2 = static_cast<byte>(color2[0]);
	g_hud_params.g2 = static_cast<byte>(color2[1]);
	g_hud_params.b2 = static_cast<byte>(color2[2]);
	g_hud_params.a2 = static_cast<byte>(color2[3]);

	return 1;
}

void UTIL_SendHudText(int client, const hud_text_parms &textparms, const char *pMessage)
{
	cell_t players[1];

	players[0] = client;

#if SOURCE_ENGINE == SE_CSGO
	// If or when we need to support multiple games per engine with this, we can switch to reflection
	CCSUsrMsg_HudMsg *msg = (CCSUsrMsg_HudMsg *)g_UserMsgs.StartProtobufMessage(g_HudMsgNum, players, 1, 0);
	msg->set_channel(textparms.channel & 0xFF);

	CMsgVector2D *pos = msg->mutable_pos();
	pos->set_x(textparms.x);
	pos->set_y(textparms.y);

	CMsgRGBA *color1 = msg->mutable_clr1();
	color1->set_r(textparms.r1);
	color1->set_g(textparms.g1);
	color1->set_b(textparms.b1);
	color1->set_a(textparms.a1);

	CMsgRGBA *color2 = msg->mutable_clr2();
	color2->set_r(textparms.r2);
	color2->set_g(textparms.g2);
	color2->set_b(textparms.b2);
	color2->set_a(textparms.a2);

	msg->set_effect(textparms.effect);
	msg->set_fade_in_time(textparms.fadeinTime);
	msg->set_fade_out_time(textparms.fadeoutTime);
	msg->set_hold_time(textparms.holdTime);
	msg->set_fx_time(textparms.fxTime);
	msg->set_text(pMessage);
#else
	bf_write *bf = g_UserMsgs.StartBitBufMessage(g_HudMsgNum, players, 1, 0);
	bf->WriteByte(textparms.channel & 0xFF );
	bf->WriteFloat(textparms.x);
	bf->WriteFloat(textparms.y);
	bf->WriteByte(textparms.r1);
	bf->WriteByte(textparms.g1);
	bf->WriteByte(textparms.b1);
	bf->WriteByte(textparms.a1);
	bf->WriteByte(textparms.r2);
	bf->WriteByte(textparms.g2);
	bf->WriteByte(textparms.b2);
	bf->WriteByte(textparms.a2);
	bf->WriteByte(textparms.effect);
	bf->WriteFloat(textparms.fadeinTime);
	bf->WriteFloat(textparms.fadeoutTime);
	bf->WriteFloat(textparms.holdTime);
	bf->WriteFloat(textparms.fxTime);
	bf->WriteString(pMessage);
#endif
	g_UserMsgs.EndMessage();
}

static cell_t ShowSyncHudText(IPluginContext *pContext, const cell_t *params)
{
	int client;
	Handle_t err;
	CPlayer *pPlayer;
	hud_syncobj_t *obj;
	char message_buffer[255-36];

	if (!s_HudMsgHelpers.IsSupported())
	{
		return -1;
	}

	if ((err = s_HudMsgHelpers.ReadHudSyncObj(params[2], pContext->GetIdentity(), &obj)) != HandleError_None)
	{
		return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[2], err);
	}

	client = params[1];
	if ((pPlayer = g_Players.GetPlayerByIndex(client)) == NULL)
	{
		return pContext->ThrowNativeError("Invalid client index %d", client);
	}
	else if (!pPlayer->IsInGame())
	{
		return pContext->ThrowNativeError("Client %d is not in-game", client);
	}

	g_SourceMod.SetGlobalTarget(client);
	g_SourceMod.FormatString(message_buffer, sizeof(message_buffer), pContext, params, 3);
	if (pContext->GetLastNativeError() != SP_ERROR_NONE)
	{
		return 0;
	}

	g_hud_params.channel = s_HudMsgHelpers.AutoSelectChannel(client, obj);
	UTIL_SendHudText(client, g_hud_params, message_buffer);

	return 1;
}

static cell_t ClearSyncHud(IPluginContext *pContext, const cell_t *params)
{
	int client;
	int channel;
	Handle_t err;
	CPlayer *pPlayer;
	hud_syncobj_t *obj;

	if (!s_HudMsgHelpers.IsSupported())
	{
		return -1;
	}

	if ((err = s_HudMsgHelpers.ReadHudSyncObj(params[2], pContext->GetIdentity(), &obj)) != HandleError_None)
	{
		return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[2], err);
	}

	client = params[1];
	if ((pPlayer = g_Players.GetPlayerByIndex(client)) == NULL)
	{
		return pContext->ThrowNativeError("Invalid client index %d", client);
	}
	else if (!pPlayer->IsInGame())
	{
		return pContext->ThrowNativeError("Client %d is not in-game", client);
	}

	if ((channel = s_HudMsgHelpers.TryReuseLastChannel(client, obj)) == -1)
	{
		return -1;
	}

	g_hud_params.channel = channel;
	UTIL_SendHudText(client, g_hud_params, "");

	return g_hud_params.channel;
}

static cell_t ShowHudText(IPluginContext *pContext, const cell_t *params)
{
	int client;
	CPlayer *pPlayer;
	char message_buffer[255-36];

	if (!s_HudMsgHelpers.IsSupported())
	{
		return -1;
	}

	client = params[1];
	if ((pPlayer = g_Players.GetPlayerByIndex(client)) == NULL)
	{
		return pContext->ThrowNativeError("Invalid client index %d", client);
	}
	else if (!pPlayer->IsInGame())
	{
		return pContext->ThrowNativeError("Client %d is not in-game", client);
	}

	g_SourceMod.SetGlobalTarget(client);
	g_SourceMod.FormatString(message_buffer, sizeof(message_buffer), pContext, params, 3);
	if (pContext->GetLastNativeError() != SP_ERROR_NONE)
	{
		return 0;
	}

	if (params[2] == -1)
	{
		g_hud_params.channel = s_HudMsgHelpers.AutoSelectChannel(client);
	}
	else
	{
		g_hud_params.channel = params[2] % MAX_HUD_CHANNELS;
		s_HudMsgHelpers.ManualSelectChannel(client, g_hud_params.channel);
	}

	UTIL_SendHudText(client, g_hud_params, message_buffer);

	return g_hud_params.channel;
}

REGISTER_NATIVES(hudNatives)
{
	{"ClearSyncHud",				ClearSyncHud},
	{"CreateHudSynchronizer",		CreateHudSynchronizer},
	{"SetHudTextParams",			SetHudTextParams},
	{"SetHudTextParamsEx",			SetHudTextParamsEx},
	{"ShowHudText",					ShowHudText},
	{"ShowSyncHudText",				ShowSyncHudText},
	{NULL,							NULL},
};