/**
 * @file lleventpoll.cpp
 * @brief Implementation of the LLEventPoll class.
 *
 * $LicenseInfo:firstyear=2006&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 * 
 * This library 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
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 * 
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#include "llviewerprecompiledheaders.h"

#include "lleventpoll.h"
#include "llappviewer.h"
#include "llagent.h"

#include "llhttpclient.h"
#include "llhttpconstants.h"
#include "llsdserialize.h"
#include "lleventtimer.h"
#include "llviewerregion.h"
#include "message.h"
#include "lltrans.h"

namespace
{
	// We will wait RETRY_SECONDS + (errorCount * RETRY_SECONDS_INC) before retrying after an error.
	// This means we attempt to recover relatively quickly but back off giving more time to recover
	// until we finally give up after MAX_EVENT_POLL_HTTP_ERRORS attempts.
	const F32 EVENT_POLL_ERROR_RETRY_SECONDS = 15.f; // ~ half of a normal timeout.
	const F32 EVENT_POLL_ERROR_RETRY_SECONDS_INC = 5.f; // ~ half of a normal timeout.
	const S32 MAX_EVENT_POLL_HTTP_ERRORS = 10; // ~5 minutes, by the above rules.

	class LLEventPollResponder : public LLHTTPClient::Responder
	{
		LOG_CLASS(LLEventPollResponder);
	public:
		
		static LLHTTPClient::ResponderPtr start(const std::string& pollURL, const LLHost& sender);
		void stop();
		
		void makeRequest();

		/* virtual */ void completedRaw(const LLChannelDescriptors& channels,
								  const LLIOPipe::buffer_ptr_t& buffer);

	private:
		LLEventPollResponder(const std::string&	pollURL, const LLHost& sender);
		~LLEventPollResponder();

		
		void handleMessage(const LLSD& content);

		/* virtual */ void httpFailure();
		/* virtual */ void httpSuccess();

	private:

		bool	mDone;

		std::string			mPollURL;
		std::string			mSender;
		
		LLSD	mAcknowledge;
		
		// these are only here for debugging so	we can see which poller	is which
		static int sCount;
		int	mCount;
		S32 mErrorCount;
	};

	class LLEventPollEventTimer : public LLEventTimer
	{
		typedef LLPointer<LLEventPollResponder> EventPollResponderPtr;

	public:
		LLEventPollEventTimer(F32 period, EventPollResponderPtr responder)
			: LLEventTimer(period), mResponder(responder)
		{ }

		virtual BOOL tick()
		{
			mResponder->makeRequest();
			return TRUE;	// Causes this instance to be deleted.
		}

	private:
		
		EventPollResponderPtr mResponder;
	};

	//static
	LLHTTPClient::ResponderPtr LLEventPollResponder::start(
		const std::string& pollURL, const LLHost& sender)
	{
		LLHTTPClient::ResponderPtr result = new LLEventPollResponder(pollURL, sender);
		LL_INFOS()	<< "LLEventPollResponder::start <" << sCount << "> "
				<< pollURL << LL_ENDL;
		return result;
	}

	void LLEventPollResponder::stop()
	{
		LL_INFOS()	<< "LLEventPollResponder::stop	<" << mCount <<	"> "
				<< mPollURL	<< LL_ENDL;
		// there should	be a way to	stop a LLHTTPClient	request	in progress
		mDone =	true;
	}

	int	LLEventPollResponder::sCount =	0;

	LLEventPollResponder::LLEventPollResponder(const std::string& pollURL, const LLHost& sender)
		: mDone(false),
		  mPollURL(pollURL),
		  mCount(++sCount),
		  mErrorCount(0)
	{
		//extract host and port of simulator to set as sender
		LLViewerRegion *regionp = gAgent.getRegion();
		if (!regionp)
		{
			LL_ERRS() << "LLEventPoll initialized before region is added." << LL_ENDL;
		}
		mSender = sender.getIPandPort();
		LL_INFOS() << "LLEventPoll initialized with sender " << mSender << LL_ENDL;
		makeRequest();
	}

	LLEventPollResponder::~LLEventPollResponder()
	{
		stop();
		LL_DEBUGS() <<	"LLEventPollResponder::~Impl <" <<	mCount << "> "
				 <<	mPollURL <<	LL_ENDL;
	}

	// virtual 
	void LLEventPollResponder::completedRaw(const LLChannelDescriptors& channels,
											const LLIOPipe::buffer_ptr_t& buffer)
	{
		if (getStatus() == HTTP_BAD_GATEWAY)
		{
			// These errors are not parsable as LLSD, 
			// which LLHTTPClient::Responder::completedRaw will try to do.
			httpCompleted();
		}
		else
		{
			LLHTTPClient::Responder::completedRaw(channels,buffer);
		}
	}

	void LLEventPollResponder::makeRequest()
	{
		LLSD request;
		request["ack"] = mAcknowledge;
		request["done"]	= mDone;
		
		LL_DEBUGS() <<	"LLEventPollResponder::makeRequest	<" << mCount <<	"> ack = "
				 <<	LLSDXMLStreamer(mAcknowledge) << LL_ENDL;
		LLHTTPClient::post(mPollURL, request, this);
	}

	void LLEventPollResponder::handleMessage(const	LLSD& content)
	{
		std::string	msg_name	= content["message"];
		LLSD message;
		message["sender"] = mSender;
		message["body"] = content["body"];
		LLMessageSystem::dispatch(msg_name, message);
	}

	//virtual
	void LLEventPollResponder::httpFailure()
	{
		if (mDone) return;

		// A HTTP_BAD_GATEWAY (502) error is our standard timeout response
		// we get this when there are no events.
		if ( getStatus() == HTTP_BAD_GATEWAY )
		{
			mErrorCount = 0;
			makeRequest();
		}
		else if (mErrorCount < MAX_EVENT_POLL_HTTP_ERRORS)
		{
			++mErrorCount;
			
			// The 'tick' will return TRUE causing the timer to delete this.
			new LLEventPollEventTimer(EVENT_POLL_ERROR_RETRY_SECONDS
										+ mErrorCount * EVENT_POLL_ERROR_RETRY_SECONDS_INC
									, this);

			LL_WARNS() << dumpResponse() << LL_ENDL;
		}
		else
		{
			LL_WARNS() << dumpResponse()
					   << " [count:" << mCount << "] "
					   << (mDone ? " -- done" : "") << LL_ENDL;
			stop();

			// At this point we have given up and the viewer will not receive HTTP messages from the simulator.
			// IMs, teleports, about land, selecing land, region crossing and more will all fail.
			// They are essentially disconnected from the region even though some things may still work.
			// Since things won't get better until they relog we force a disconnect now.

			// *NOTE:Mani - The following condition check to see if this failing event poll
			// is attached to the Agent's main region. If so we disconnect the viewer.
			// Else... its a child region and we just leave the dead event poll stopped and 
			// continue running.
			if(gAgent.getRegion() && gAgent.getRegion()->getHost().getIPandPort() == mSender)
			{
				LL_WARNS() << "Forcing disconnect due to stalled main region event poll."  << LL_ENDL;
				LLAppViewer::instance()->forceDisconnect(LLTrans::getString("AgentLostConnection"));
			}
		}
	}

	//virtual
	void LLEventPollResponder::httpSuccess()
	{
		LL_DEBUGS() <<	"LLEventPollResponder::result <" << mCount	<< ">"
				 <<	(mDone ? " -- done"	: "") << LL_ENDL;
		
		if (mDone) return;

		mErrorCount = 0;

		const LLSD& content = getContent();
		if (!content.isMap() ||
			!content.get("events") ||
			!content.get("id"))
		{
			LL_WARNS() << "received event poll with no events or id key: " << dumpResponse() << LL_ENDL;
			makeRequest();
			return;
		}
		
		mAcknowledge = content["id"];
		LLSD events	= content["events"];

		if(mAcknowledge.isUndefined())
		{
			LL_WARNS() << "LLEventPollResponder: id undefined" << LL_ENDL;
		}
		
		// was LL_INFOS() but now that CoarseRegionUpdate is TCP @ 1/second, it'd be too verbose for viewer logs. -MG
		LL_DEBUGS()  << "LLEventPollResponder::httpSuccess <" <<	mCount << "> " << events.size() << "events (id "
					 <<	LLSDXMLStreamer(mAcknowledge) << ")" << LL_ENDL;
		
		LLSD::array_const_iterator i = events.beginArray();
		LLSD::array_const_iterator end = events.endArray();
		for	(; i !=	end; ++i)
		{
			if (i->has("message"))
			{
				handleMessage(*i);
			}
		}
		
		makeRequest();
	}	
}

LLEventPoll::LLEventPoll(const std::string&	poll_url, const LLHost& sender)
	: mImpl(LLEventPollResponder::start(poll_url, sender))
	{ }

LLEventPoll::~LLEventPoll()
{
	LLHTTPClient::Responder* responderp = mImpl.get();
	LLEventPollResponder* event_poll_responder = dynamic_cast<LLEventPollResponder*>(responderp);
	if (event_poll_responder) event_poll_responder->stop();
}
