/** 
 * @file lleventnotifier.cpp
 * @brief Viewer code for managing event notifications
 *
 * Copyright (c) 2004-$CurrentYear$, Linden Research, Inc.
 * $License$
 */

#include "llviewerprecompiledheaders.h"

#include "lleventnotifier.h"

#include "message.h"

#include "llnotify.h"
#include "lleventinfo.h"
#include "llfloaterdirectory.h"
#include "llfloaterworldmap.h"
#include "llagent.h"

LLEventNotifier gEventNotifier;

LLEventNotifier::LLEventNotifier()
{
}


LLEventNotifier::~LLEventNotifier()
{
	en_map::iterator iter;

	for (iter = mEventNotifications.begin();
		 iter != mEventNotifications.end();
		 iter++)
	{
		delete iter->second;
	}
}


void LLEventNotifier::update()
{
	if (mNotificationTimer.getElapsedTimeF32() > 30.f)
	{
		// Check our notifications again and send out updates
		// if they happen.

		U32 alert_time = time_corrected() + 5 * 60;
		en_map::iterator iter;
		for (iter = mEventNotifications.begin();
			 iter != mEventNotifications.end();)
		{
			LLEventNotification *np = iter->second;

			if (np->getEventDate() < (alert_time))
			{
				LLString::format_map_t args;
				args["[NAME]"] = np->getEventName();
				args["[DATE]"] = np->getEventDateStr();
				LLNotifyBox::showXml("EventNotification", args, 
									 notifyCallback, np);
				mEventNotifications.erase(iter++);
			}
			else
			{
				iter++;
			}
		}
		mNotificationTimer.reset();
	}
}

void LLEventNotifier::load(const LLUserAuth::options_t& event_options)
{
	LLUserAuth::options_t::const_iterator resp_it;
	for (resp_it = event_options.begin(); 
		 resp_it != event_options.end(); 
		 ++resp_it)
	{
		const LLUserAuth::response_t& response = *resp_it;

		LLEventNotification *new_enp = new LLEventNotification();

		if (!new_enp->load(response))
		{
			delete new_enp;
			continue;
		}
		
		mEventNotifications[new_enp->getEventID()] = new_enp;
	}
}


BOOL LLEventNotifier::hasNotification(const U32 event_id)
{
	if (mEventNotifications.find(event_id) != mEventNotifications.end())
	{
		return TRUE;
	}
	return FALSE;
}


void LLEventNotifier::add(LLEventInfo &event_info)
{
	// We need to tell the simulator that we want to pay attention to
	// this event, as well as add it to our list.

	if (mEventNotifications.find(event_info.mID) != mEventNotifications.end())
	{
		// We already have a notification for this event, don't bother.
		return;
	}

	// Push up a message to tell the server we have this notification.
	gMessageSystem->newMessage("EventNotificationAddRequest");
	gMessageSystem->nextBlockFast(_PREHASH_AgentData);
	gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
	gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
	gMessageSystem->nextBlock("EventData");
	gMessageSystem->addU32("EventID", event_info.mID);
	gAgent.sendReliableMessage();

	LLEventNotification *enp = new LLEventNotification;
	enp->load(event_info);
	mEventNotifications[event_info.mID] = enp;
}

void LLEventNotifier::remove(const U32 event_id)
{
	en_map::iterator iter;
	iter = mEventNotifications.find(event_id);
	if (iter == mEventNotifications.end())
	{
		// We don't have a notification for this event, don't bother.
		return;
	}

	// Push up a message to tell the server to remove this notification.
	gMessageSystem->newMessage("EventNotificationRemoveRequest");
	gMessageSystem->nextBlockFast(_PREHASH_AgentData);
	gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
	gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
	gMessageSystem->nextBlock("EventData");
	gMessageSystem->addU32("EventID", event_id);
	gAgent.sendReliableMessage();
	
	delete iter->second;
	mEventNotifications.erase(iter);
}

//static
void LLEventNotifier::notifyCallback(S32 option, void *user_data)
{
	LLEventNotification *np = (LLEventNotification *)user_data;
	if (!np)
	{
		llwarns << "Event notification callback without data!" << llendl;
		return;
	}
	switch (option)
	{
	case 0:
		gAgent.teleportViaLocation(np->getEventPosGlobal());
		gFloaterWorldMap->trackLocation(np->getEventPosGlobal());
		break;
	case 1:
		gDisplayEventHack = TRUE;
		LLFloaterDirectory::showEvents(np->getEventID());
		break;
	case 2:
		break;
	}

	// We could clean up the notification on the server now if we really wanted to.
}



LLEventNotification::LLEventNotification() :
	mEventID(0),
	mEventName("")
{
}


LLEventNotification::~LLEventNotification()
{
}


BOOL LLEventNotification::load(const LLUserAuth::response_t &response)
{

	LLUserAuth::response_t::const_iterator option_it;
	BOOL event_ok = TRUE;
	option_it = response.find("event_id");
	if (option_it != response.end())
	{
		mEventID = atoi(option_it->second.c_str());
	}
	else
	{
		event_ok = FALSE;
	}

	option_it = response.find("event_name");
	if (option_it != response.end())
	{
		llinfos << "Event: " << option_it->second << llendl;
		mEventName = option_it->second;
	}
	else
	{
		event_ok = FALSE;
	}


	option_it = response.find("event_date");
	if (option_it != response.end())
	{
		llinfos << "EventDate: " << option_it->second << llendl;
		mEventDateStr = option_it->second;
	}
	else
	{
		event_ok = FALSE;
	}

	option_it = response.find("event_date_ut");
	if (option_it != response.end())
	{
		llinfos << "EventDate: " << option_it->second << llendl;
		mEventDate = strtoul(option_it->second.c_str(), NULL, 10);
	}
	else
	{
		event_ok = FALSE;
	}

	S32 grid_x = 0;
	S32 grid_y = 0;
	S32 x_region = 0;
	S32 y_region = 0;

	option_it = response.find("grid_x");
	if (option_it != response.end())
	{
		llinfos << "GridX: " << option_it->second << llendl;
		grid_x= atoi(option_it->second.c_str());
	}
	else
	{
		event_ok = FALSE;
	}

	option_it = response.find("grid_y");
	if (option_it != response.end())
	{
		llinfos << "GridY: " << option_it->second << llendl;
		grid_y = atoi(option_it->second.c_str());
	}
	else
	{
		event_ok = FALSE;
	}

	option_it = response.find("x_region");
	if (option_it != response.end())
	{
		llinfos << "RegionX: " << option_it->second << llendl;
		x_region = atoi(option_it->second.c_str());
	}
	else
	{
		event_ok = FALSE;
	}

	option_it = response.find("y_region");
	if (option_it != response.end())
	{
		llinfos << "RegionY: " << option_it->second << llendl;
		y_region = atoi(option_it->second.c_str());
	}
	else
	{
		event_ok = FALSE;
	}

	mEventPosGlobal.mdV[VX] = grid_x * 256 + x_region;
	mEventPosGlobal.mdV[VY] = grid_y * 256 + y_region;
	mEventPosGlobal.mdV[VZ] = 0.f;

	return event_ok;
}

BOOL LLEventNotification::load(const LLEventInfo &event_info)
{

	mEventID = event_info.mID;
	mEventName = event_info.mName;
	mEventDateStr = event_info.mTimeStr;
	mEventDate = event_info.mUnixTime;
	mEventPosGlobal = event_info.mPosGlobal;
	return TRUE;
}