#include <boost/thread/locks.hpp>

 #include <algorithm>

 #include "trackertalker.h"

 #include "macros.h"

 #include "metafield.h"

 #include "httprequest.h"

 #include "exceptions.h"

 #include "tracer.h"

 using namespace std;

 using namespace boost;

 using namespace Tortilla;

 #define TRACER (getTracer())

 AnnounceTier::AnnounceTier(TrackerTalker* tt, const MetaList* ml)

 {

 	talker = tt;

 	for (list<MetaField*>::const_iterator it = ml->getList().begin();

 		   it != ml->getList().end(); it++) {

 		MetaString* ms = dynamic_cast<MetaString*>(*it);

 		if (ms == NULL)

 			throw TrackerException("announce tear list doesn't contain a string");

 		string trackerURL = ms->getString();

 		trackers.push_back(trackerURL);

 		TRACE(TRACKER, "added tracker: %s", trackerURL.c_str());

 	}

 	random_shuffle(trackers.begin(), trackers.end());

 }

 AnnounceTier::AnnounceTier(TrackerTalker* tt, std::string url)

 {

 	talker = tt;

 	trackers.push_back(url);

 }

 void

 AnnounceTier::resetCurrentTracker()

 {

 	currentTracker = 0;

 }

 string

 AnnounceTier::getNextTracker()

 {

 	if (currentTracker >= trackers.size())

 		return "";

 	return trackers[currentTracker++];

 }

 void

 AnnounceTier::demoteCurrentTracker()

 {

 	TRACE(TRACKER, "TODO: demote");

 }

 void

 AnnounceTier::promoteCurrentTracker()

 {

 	TRACE(TRACKER, "TODO: promote");

 }

 Tracer*

 AnnounceTier::getTracer() {

 	return talker->getTorrent()->getTracer();

 }

 TrackerTalker::TrackerTalker(Torrent* t, MetaDictionary* dictionary)

 {

 	torrent = t; httpRequest = NULL;

 	const MetaList* mlList = dynamic_cast<const MetaList*>((*dictionary)["announce-list"]);

 	if (mlList != NULL) {

 		/*

 		 * An announce-list is made up of lists of sublists. Each sublist is an

 		 * announcement tier, and contains a list of strings which must be shuffeled

 		 * and stored. Each of the tiers must be tried in-order.

 		 */

 		try {

 			for (list<MetaField*>::const_iterator it = mlList->getList().begin();

 					 it != mlList->getList().end(); it++) {

 					MetaList* tierList = dynamic_cast<MetaList*>(*it);

 					if (tierList == NULL)

 						throw TorrentException("announce list doesn't contain a list element");

 					tiers.push_back(new AnnounceTier(this, tierList));

 			}

 		} catch (TortillaException) {

 			/*

 			 * Something went wrong while adding tiers; throw them all away and

 			 * attempt to add the old-style single URL.

 			 */

 			for (vector<AnnounceTier*>::iterator it = tiers.begin();

 					 it != tiers.end(); it++) {

 				delete (*it);

 			}

 			tiers.clear();

 		}

 	}

 	/* If we have an announce list, we're good to go */

 	if (!tiers.empty())

 		return;

 	/* New-style announce list unavailable or corrupt; revert to old single URL */

 	const MetaString* msAnnounce = dynamic_cast<const MetaString*>((*dictionary)["announce"]);

 	if (msAnnounce == NULL)

 		throw TrackerException("metadata doesn't contain an announce URL or list");

 	string url = msAnnounce->getString();

 	TRACE(TRACKER, "added old-style tracker: %s", url.c_str());

 	tiers.push_back(new AnnounceTier(this, url));

 }

 TrackerTalker::~TrackerTalker()

 {

 	for (vector<AnnounceTier*>::iterator it = tiers.begin();

 	     it != tiers.end(); it++) {

 		delete (*it);

 	}

 }

 void

 TrackerTalker::request(map<string, string> req)

 {

 	/* Always start at the first tier with this request */

 	currentTier = 0; currentRequest = req;

 	for (vector<AnnounceTier*>::iterator it = tiers.begin();

 	     it != tiers.end(); it++) {

 		(*it)->resetCurrentTracker();

 	}

 	/* Give it a spin */

 	if (!tryRequest()) {

 		/* Wow, this failed extremely quickly - talk to the torrent */

 		torrent->callbackTrackerReply("", true);

 	}

 }

 bool

 TrackerTalker::tryRequest()

 {

 	unique_lock<mutex> lock(mtx_data);

 	while (true) {

 		/* Find the next announcer to use */

 		if (currentTier >= tiers.size())

 			break;

 		AnnounceTier* at = tiers[currentTier];

 		string url = at->getNextTracker();

 		if (url == "") {

 			currentTier++;

 			continue;

 		}

 		/* OK, we got an URL - try to chat with it */

 		lock.unlock(); /* drop data lock while talking to tracker */

 		try {

 			TRACE(TRACKER, "attempting to contact tracker '%s'", url.c_str());

 			httpRequest = new HTTPRequest(this, url, currentRequest);

 			torrent->addRequest(httpRequest);

 			return true;

 		} catch (HTTPException e) {

 			TRACE(TRACKER, "unable to communicate with tracker '%s': %s", url.c_str(), e.what());

 		}

 		/* Fallthrough to the next tracker - reacquire lock */

 		lock.lock();

 	}

 	return false;

 }

 void 

 TrackerTalker::callbackTrackerRequest(std::string result, bool error)

 {

 	TRACE(TRACKER, "tracker callback: error=%u", error ? 1 : 0);

 	/* Get rid of the request ASAP - the receiver will clean it up */

 	{

 		unique_lock<mutex> lock(mtx_data);

 		httpRequest = NULL;

 	}

 	AnnounceTier* at = tiers[currentTier];

 	if (error) {

 		at->demoteCurrentTracker();

 		if (!tryRequest()) {

 			/* Give up... */

 			torrent->callbackTrackerReply(result, true);

 		}

 		return;

 	}

 	at->promoteCurrentTracker();

 	torrent->callbackTrackerReply(result, false);

 }

 /* vim:set ts=2 sw=2: */