/** 
 * @file llfloaterbump.cpp
 * @brief Floater showing recent bumps, hits with objects, pushes, etc.
 * @author Cory Ondrejka, James Cook
 *
 * $LicenseInfo:firstyear=2003&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 "llsd.h"
#include "mean_collision_data.h"

#include "llavataractions.h"
#include "llfloaterbump.h"
#include "llfloaterreg.h"
#include "llfloaterreporter.h"
#include "llmutelist.h"
#include "llpanelblockedlist.h"
#include "llscrolllistctrl.h"
#include "lltrans.h"
#include "lluictrlfactory.h"
#include "llviewermessage.h"
#include "llviewermenu.h"
#include "llviewerobjectlist.h"

#include "llavatarnamecache.h"
#include "fsradar.h"
#include "fsscrolllistctrl.h"
#include "llclipboard.h"
#include "llfloaterreg.h"

///----------------------------------------------------------------------------
/// Class LLFloaterBump
///----------------------------------------------------------------------------

// Default constructor
LLFloaterBump::LLFloaterBump(const LLSD& key) 
:	LLFloater(key),
	// <FS:Ansariel> Instant bump list floater update
	mDirty(false),
	mList(NULL)
	// </FS:Ansariel>
{
	// <FS:Ansariel> Improved bump list
	//mCommitCallbackRegistrar.add("Avatar.SendIM", boost::bind(&LLFloaterBump::startIM, this));
	//mCommitCallbackRegistrar.add("Avatar.ReportAbuse", boost::bind(&LLFloaterBump::reportAbuse, this));
	//mCommitCallbackRegistrar.add("ShowAgentProfile", boost::bind(&LLFloaterBump::showProfile, this));
	//mCommitCallbackRegistrar.add("Avatar.InviteToGroup", boost::bind(&LLFloaterBump::inviteToGroup, this));
	//mCommitCallbackRegistrar.add("Avatar.Call", boost::bind(&LLFloaterBump::startCall, this));
	//mEnableCallbackRegistrar.add("Avatar.EnableCall", boost::bind(&LLAvatarActions::canCall));
	//mCommitCallbackRegistrar.add("Avatar.AddFriend", boost::bind(&LLFloaterBump::addFriend, this));
	//mEnableCallbackRegistrar.add("Avatar.EnableAddFriend", boost::bind(&LLFloaterBump::enableAddFriend, this));
	//mCommitCallbackRegistrar.add("Avatar.Mute", boost::bind(&LLFloaterBump::muteAvatar, this));
	//mEnableCallbackRegistrar.add("Avatar.EnableMute", boost::bind(&LLFloaterBump::enableMute, this));
	//mCommitCallbackRegistrar.add("PayObject", boost::bind(&LLFloaterBump::payAvatar, this));
	//mCommitCallbackRegistrar.add("Tools.LookAtSelection", boost::bind(&LLFloaterBump::zoomInAvatar, this));
	// </FS:Ansariel>
}


// Destroys the object
LLFloaterBump::~LLFloaterBump()
{
	// <FS:Ansariel> Improved bump list
	//auto menu = mPopupMenuHandle.get();
	//if (menu)
	//{
	//	menu->die();
	//	mPopupMenuHandle.markDead();
	//}
	// </FS:Ansariel>
}

BOOL LLFloaterBump::postBuild()
{
	// <FS:Ansariel> FIRE-13888: Add copy function to bumps list
	//mList = getChild<LLScrollListCtrl>("bump_list");
	//mList->setAllowMultipleSelection(false);
	//mList->setRightMouseDownCallback(boost::bind(&LLFloaterBump::onScrollListRightClicked, this, _1, _2, _3));

	//LLContextMenu* menu = LLUICtrlFactory::getInstance()->createFromFile<LLContextMenu>("menu_avatar_other.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
	//if (menu)
	//{
	//	mPopupMenuHandle = menu->getHandle();
	//	menu->setItemVisible(std::string("Normal"), false);
	//	menu->setItemVisible(std::string("Always use impostor"), false);
	//	menu->setItemVisible(std::string("Never use impostor"), false);
	//	menu->setItemVisible(std::string("Impostor seperator"), false);
	//}

	//return TRUE;
	mList = getChild<FSScrollListCtrl>("bump_list");
	mList->setContextMenu(&gFSBumpListMenu);

	return LLFloater::postBuild();
	// </FS:Ansariel>
}

// virtual
void LLFloaterBump::onOpen(const LLSD& key)
{
// <FS:Ansariel> Instant bump list floater update
	//if (gMeanCollisionList.empty())
	//{
	//	mNames.clear();
	//	mList->deleteAllItems();
	updateList();
}

void LLFloaterBump::draw()
{
	if (mDirty)
	{
		updateList();
		mDirty = false;
	}

	LLFloater::draw();
}

void LLFloaterBump::updateList()
{
	if (!mList)
	{
		return;
	}
	mList->deleteAllItems();

	if (gMeanCollisionList.empty())
	{
// </FS:Ansariel>
		std::string none_detected = getString("none_detected");
		LLSD row;
		row["columns"][0]["value"] = none_detected;
		row["columns"][0]["font"] = "SansSerifBold";
		mList->addElement(row);
	}
	else
	{
// <FS:Ansariel> Instant bump list floater update
//		populateCollisionList();
//	}
//}

//void LLFloaterBump::populateCollisionList()
//{
//	mNames.clear();
//	mList->deleteAllItems();
// </FS:Ansariel>

	for (mean_collision_list_t::iterator iter = gMeanCollisionList.begin();
				 iter != gMeanCollisionList.end(); ++iter)
	{
		LLMeanCollisionData *mcd = *iter;
		add(mList, mcd);
	}
	// <FS:Ansariel> Instant bump list floater update
	}
	// </FS:Ansariel>
}

void LLFloaterBump::add(LLScrollListCtrl* list, LLMeanCollisionData* mcd)
{
	if (mcd->mFullName.empty() || list->getItemCount() >= 20)
	{
		return;
	}

	std::string timeStr = getString ("timeStr");
	LLSD substitution;

	substitution["datetime"] = (S32) mcd->mTime;
	LLStringUtil::format (timeStr, substitution);

	std::string action;
	switch(mcd->mType)
	{
	case MEAN_BUMP:
		action = "bump";
		break;
	case MEAN_LLPUSHOBJECT:
		action = "llpushobject";
		break;
	case MEAN_SELECTED_OBJECT_COLLIDE:
		action = "selected_object_collide";
		break;
	case MEAN_SCRIPTED_OBJECT_COLLIDE:
		action = "scripted_object_collide";
		break;
	case MEAN_PHYSICAL_OBJECT_COLLIDE:
		action = "physical_object_collide";
		break;
	default:
		LL_INFOS() << "LLFloaterBump::add unknown mean collision type "
			<< mcd->mType << LL_ENDL;
		return;
	}

	// All above action strings are in XML file
	LLUIString text = getString(action);
	text.setArg("[TIME]", timeStr);
	text.setArg("[NAME]", mcd->mFullName);

	LLSD row;
	row["id"] = mcd->mPerp;
	row["columns"][0]["value"] = text;
	row["columns"][0]["font"] = "SansSerifBold";
	list->addElement(row);

// <FS:Ansariel> Improved bump list
}
#if 0
	mNames[mcd->mPerp] = mcd->mFullName;
}


void LLFloaterBump::onScrollListRightClicked(LLUICtrl* ctrl, S32 x, S32 y)
{
	if (!gMeanCollisionList.empty())
	{
		LLScrollListItem* item = mList->hitItem(x, y);
		auto menu = mPopupMenuHandle.get();
		if (item && menu)
		{
			mItemUUID = item->getUUID();
			menu->buildDrawLabels();
			menu->updateParent(LLMenuGL::sMenuContainer);

			std::string mute_msg = (LLMuteList::getInstance()->isMuted(mItemUUID, mNames[mItemUUID])) ? "UnmuteAvatar" : "MuteAvatar";
			menu->getChild<LLUICtrl>("Avatar Mute")->setValue(LLTrans::getString(mute_msg));
			menu->setItemEnabled(std::string("Zoom In"), bool(gObjectList.findObject(mItemUUID)));

			menu->show(x, y);
			LLMenuGL::showPopup(ctrl, menu, x, y);
		}
	}
}


void LLFloaterBump::startIM()
{
	LLAvatarActions::startIM(mItemUUID);
}

void LLFloaterBump::startCall()
{
	LLAvatarActions::startCall(mItemUUID);
}

void LLFloaterBump::reportAbuse()
{
	LLFloaterReporter::showFromAvatar(mItemUUID, "av_name");
}

void LLFloaterBump::showProfile()
{
	LLAvatarActions::showProfile(mItemUUID);
}

void LLFloaterBump::addFriend()
{
	LLAvatarActions::requestFriendshipDialog(mItemUUID);
}

bool LLFloaterBump::enableAddFriend()
{
	return !LLAvatarActions::isFriend(mItemUUID);
}

void LLFloaterBump::muteAvatar()
{
	LLMute mute(mItemUUID, mNames[mItemUUID], LLMute::AGENT);
	if (LLMuteList::getInstance()->isMuted(mute.mID))
	{
		LLMuteList::getInstance()->remove(mute);
	}
	else
	{
		LLMuteList::getInstance()->add(mute);
		LLPanelBlockedList::showPanelAndSelect(mute.mID);
	}
}

void LLFloaterBump::payAvatar()
{
	LLAvatarActions::pay(mItemUUID);
}

void LLFloaterBump::zoomInAvatar()
{
	handle_zoom_to_object(mItemUUID);
}

bool LLFloaterBump::enableMute()
{
	return LLAvatarActions::canBlock(mItemUUID);
}

void LLFloaterBump::inviteToGroup()
{
	LLAvatarActions::inviteToGroup(mItemUUID);
}

LLFloaterBump* LLFloaterBump::getInstance()
{
	return LLFloaterReg::getTypedInstance<LLFloaterBump>("bumps");
}
#endif
// </FS:Ansariel>

// <FS:Ansariel> FIRE-13888: Add copy function to bumps list
LLContextMenu* FSBumpListMenu::createMenu()
{
	LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;
	LLUICtrl::EnableCallbackRegistry::ScopedRegistrar enable_registrar;

	registrar.add("BumpList.Action", boost::bind(&FSBumpListMenu::onContextMenuItemClick, this, _2));
	enable_registrar.add("BumpList.Enable", boost::bind(&FSBumpListMenu::onContextMenuItemEnable, this, _2));

	return createFromFile("menu_fs_bump_list.xml");
}

void FSBumpListMenu::onContextMenuItemClick(const LLSD& userdata)
{
	std::string item = userdata.asString();

	if (item == "show_profile")
	{
		LLAvatarActions::showProfile(mUUIDs.front());
	}
	else if (item == "sendim")
	{
		if (mUUIDs.size() == 1)
		{
			LLAvatarActions::startIM(mUUIDs.front());
		}
		else
		{
			LLAvatarActions::startConference(mUUIDs);
		}
	}
	else if (item == "zoom")
	{
		LLAvatarActions::zoomIn(mUUIDs.front());
	}
	else if (item == "teleportto")
	{
		LLAvatarActions::teleportTo(mUUIDs.front());
	}
	else if (item == "block")
	{
		LLAvatarActions::toggleBlock(mUUIDs.front());
	}
	else if (item == "report")
	{
		LLAvatarActions::report(mUUIDs.front());
	}
	else if (item == "copy")
	{
		LLFloaterBump* floater = LLFloaterReg::findTypedInstance<LLFloaterBump>("bumps");
		if (floater && !gMeanCollisionList.empty() && !mUUIDs.empty())
		{
			std::string bumps_text;
			FSScrollListCtrl* list = floater->getChild<FSScrollListCtrl>("bump_list");

			std::vector<LLScrollListItem*> selected = list->getAllSelected();
			for (std::vector<LLScrollListItem*>::iterator it = selected.begin(); it != selected.end(); ++it)
			{
				bumps_text += ( (bumps_text.empty() ? "" : "\n") + (*it)->getColumn(0)->getValue().asString() );
			}

			if (!bumps_text.empty())
			{
				LLClipboard::instance().copyToClipboard(utf8str_to_wstring(bumps_text), 0, bumps_text.size() );
			}
		}
	}
}

bool FSBumpListMenu::onContextMenuItemEnable(const LLSD& userdata)
{
	const LLFloaterBump* floater = LLFloaterReg::findTypedInstance<LLFloaterBump>("bumps");
	const std::string item = userdata.asString();

	if (!floater)
	{
		return false;
	}

	if (item == "can_show_profile")
	{
		return (!gMeanCollisionList.empty() && mUUIDs.size() == 1);
	}
	else if (item == "can_sendim")
	{
		return (!gMeanCollisionList.empty() && mUUIDs.size() > 0);
	}
	else if (item == "can_zoom")
	{
		return (!gMeanCollisionList.empty() && mUUIDs.size() == 1 && LLAvatarActions::canZoomIn(mUUIDs.front()));
	}
	else if (item == "can_teleportto")
	{
		return (!gMeanCollisionList.empty() && mUUIDs.size() == 1 && FSRadar::getInstance()->getEntry(mUUIDs.front()) != NULL);
	}
	else if (item == "can_block")
	{
		return (!gMeanCollisionList.empty() && mUUIDs.size() == 1);
	}
	else if (item == "is_blocked")
	{
		if (!gMeanCollisionList.empty() && mUUIDs.size() == 1)
		{
			LLAvatarName av_name;
			LLAvatarNameCache::get(mUUIDs.front(), &av_name);
			std::string name = av_name.getUserName();
			return LLMuteList::getInstance()->isMuted(mUUIDs.front(), name);
		}
		else
		{
			return false;
		}
	}
	else if (item == "can_report")
	{
		return (!gMeanCollisionList.empty() && mUUIDs.size() == 1);
	}
	else if (item == "can_copy")
	{
		return (!gMeanCollisionList.empty() && !mUUIDs.empty());
	}

	return false;
}

FSBumpListMenu gFSBumpListMenu;
// </FS:Ansariel>
