/** 
 * @file llinspectobject.cpp
 *
 * $LicenseInfo:firstyear=2009&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 "llinspectobject.h"

// Viewer
#include "llagent.h"            // To standup
#include "llfloatersidepanelcontainer.h"
#include "llinspect.h"
#include "llmediaentry.h"
#include "llselectmgr.h"
#include "llslurl.h"
#include "llviewermenu.h"		// handle_object_touch(), handle_buy()
#include "llviewermedia.h"
#include "llviewermediafocus.h"
#include "llviewerobjectlist.h"	// to select the requested object
#include "llvoavatarself.h"

// Linden libraries
#include "llbutton.h"			// setLabel(), not virtual!
#include "llclickaction.h"
#include "llfloaterreg.h"
#include "llmenubutton.h"
#include "llresmgr.h"			// getMonetaryString
#include "llsafehandle.h"
#include "lltextbox.h"			// for description truncation
#include "lltoggleablemenu.h"
#include "lltrans.h"
#include "lluictrl.h"

class LLViewerObject;

//////////////////////////////////////////////////////////////////////////////
// LLInspectObject
//////////////////////////////////////////////////////////////////////////////

// Object Inspector, a small information window used when clicking
// in the ambient inspector widget for objects in the 3D world.
class LLInspectObject : public LLInspect
{
	friend class LLFloaterReg;
	
public:
	// object_id - Root object ID for which to show information
	// Inspector will be positioned relative to current mouse position
	LLInspectObject(const LLSD& object_id);
	virtual ~LLInspectObject();
	
	/*virtual*/ bool postBuild(void);
	
	// Because floater is single instance, need to re-parse data on each spawn
	// (for example, inspector about same avatar but in different position)
	/*virtual*/ void onOpen(const LLSD& avatar_id);
	
	// Release the selection and do other cleanup
	/*virtual*/ void onClose(bool app_quitting);
	
	// override the inspector mouse leave so timer is only paused if 
	// gear menu is not open
	/* virtual */ void onMouseLeave(S32 x, S32 y, MASK mask);
	
private:
	// Refresh displayed data with information from selection manager
	void update();

	void hideButtons();
	void updateButtons(LLSelectNode* nodep);
	void updateSitLabel(LLSelectNode* nodep);
	void updateTouchLabel(LLSelectNode* nodep);

	void updateName(LLSelectNode* nodep);
	void updateDescription(LLSelectNode* nodep);
	void updatePrice(LLSelectNode* nodep);
	void updateCreator(LLSelectNode* nodep);
	
	void updateMediaCurrentURL();	
	void updateSecureBrowsing();
		
	void onClickBuy();
	void onClickPay();
	void onClickTakeFreeCopy();
	void onClickTouch();
	void onClickSit();
	void onClickOpen();
	void onClickMoreInfo();
	void onClickZoomIn();  
	
private:
	LLUUID				mObjectID;
	LLUUID				mPreviousObjectID;
	S32					mObjectFace;
	viewer_media_t		mMediaImpl;
	LLMediaEntry*       mMediaEntry;
	LLSafeHandle<LLObjectSelection> mObjectSelection;
    boost::signals2::connection mSelectionUpdateSlot;
};

LLInspectObject::LLInspectObject(const LLSD& sd)
:	LLInspect( LLSD() ),	// single_instance, doesn't really need key
	mObjectID(NULL),			// set in onOpen()
	mObjectFace(0),
	mObjectSelection(NULL),
	mMediaImpl(NULL),
	mMediaEntry(NULL)
{
	// can't make the properties request until the widgets are constructed
	// as it might return immediately, so do it in postBuild.
	mCommitCallbackRegistrar.add("InspectObject.Buy",	boost::bind(&LLInspectObject::onClickBuy, this));	
	mCommitCallbackRegistrar.add("InspectObject.Pay",	boost::bind(&LLInspectObject::onClickPay, this));	
	mCommitCallbackRegistrar.add("InspectObject.TakeFreeCopy",	boost::bind(&LLInspectObject::onClickTakeFreeCopy, this));	
	mCommitCallbackRegistrar.add("InspectObject.Touch",	boost::bind(&LLInspectObject::onClickTouch, this));	
	mCommitCallbackRegistrar.add("InspectObject.Sit",	boost::bind(&LLInspectObject::onClickSit, this));	
	mCommitCallbackRegistrar.add("InspectObject.Open",	boost::bind(&LLInspectObject::onClickOpen, this));	
	mCommitCallbackRegistrar.add("InspectObject.MoreInfo",	boost::bind(&LLInspectObject::onClickMoreInfo, this));	
	mCommitCallbackRegistrar.add("InspectObject.ZoomIn", boost::bind(&LLInspectObject::onClickZoomIn, this));
}


LLInspectObject::~LLInspectObject()
{
    if (mSelectionUpdateSlot.connected())
    {
        mSelectionUpdateSlot.disconnect();
    }
}

/*virtual*/
bool LLInspectObject::postBuild(void)
{
	// The XML file has sample data in it.  Clear that out so we don't
	// flicker when data arrives off network.
	getChild<LLUICtrl>("object_name")->setValue("");
	getChild<LLUICtrl>("object_creator")->setValue("");
	getChild<LLUICtrl>("object_description")->setValue("");
	getChild<LLUICtrl>("object_media_url")->setValue("");
	// Set buttons invisible until we know what this object can do
	hideButtons();

	// Hide floater when name links clicked
	LLTextBox* textbox = getChild<LLTextBox>("object_creator");
	textbox->setURLClickedCallback(boost::bind(&LLInspectObject::closeFloater, this, false) );

	// Hook up functionality
	getChild<LLUICtrl>("buy_btn")->setCommitCallback(
		boost::bind(&LLInspectObject::onClickBuy, this));
	getChild<LLUICtrl>("pay_btn")->setCommitCallback(
		boost::bind(&LLInspectObject::onClickPay, this));
	getChild<LLUICtrl>("take_free_copy_btn")->setCommitCallback(
		boost::bind(&LLInspectObject::onClickTakeFreeCopy, this));
	getChild<LLUICtrl>("touch_btn")->setCommitCallback(
		boost::bind(&LLInspectObject::onClickTouch, this));
	getChild<LLUICtrl>("sit_btn")->setCommitCallback(
		boost::bind(&LLInspectObject::onClickSit, this));
	getChild<LLUICtrl>("open_btn")->setCommitCallback(
		boost::bind(&LLInspectObject::onClickOpen, this));
	getChild<LLUICtrl>("more_info_btn")->setCommitCallback(
		boost::bind(&LLInspectObject::onClickMoreInfo, this));

    if (!mSelectionUpdateSlot.connected())
    {
        // Watch for updates to selection properties off the network
        mSelectionUpdateSlot = LLSelectMgr::getInstance()->mUpdateSignal.connect(
            boost::bind(&LLInspectObject::update, this));
    }

	return true;
}

// Multiple calls to showInstance("inspect_avatar", foo) will provide different
// LLSD for foo, which we will catch here.
//virtual
void LLInspectObject::onOpen(const LLSD& data)
{
	// Start animation
	LLInspect::onOpen(data);

	// Extract appropriate avatar id
	mObjectID = data["object_id"];
	
	if(data.has("object_face"))
	{
		mObjectFace = data["object_face"];
	}

	LLInspect::repositionInspector(data);

	// Promote hovered object to a complete selection, which will also force
	// a request for selected object data off the network
	LLViewerObject* obj = gObjectList.findObject( mObjectID );
	if (obj)
	{
		// Media focus and this code fight over the select manager.  
		// Make sure any media is unfocused before changing the selection here.
		LLViewerMediaFocus::getInstance()->clearFocus();
		
		LLSelectMgr::instance().deselectAll();
		mObjectSelection = LLSelectMgr::instance().selectObjectAndFamily(obj,FALSE,TRUE);

		// Mark this as a transient selection
		struct SetTransient : public LLSelectedNodeFunctor
		{
			bool apply(LLSelectNode* node)
			{
				node->setTransient(TRUE);
				return true;
			}
		} functor;
		mObjectSelection->applyToNodes(&functor);
		
		// Does this face have media?
		const LLTextureEntry* tep = obj->getTE(mObjectFace);
		if (!tep)
			return;
		
		mMediaEntry = tep->hasMedia() ? tep->getMediaData() : NULL;
		if(!mMediaEntry)
			return;
		
		mMediaImpl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(mMediaEntry->getMediaID());
	}
}

// virtual
void LLInspectObject::onClose(bool app_quitting)
{
	// Release selection to deselect
	mObjectSelection = NULL;
	mPreviousObjectID = mObjectID;

	getChild<LLMenuButton>("gear_btn")->hideMenu();
}


void LLInspectObject::update()
{
	// Performance optimization, because we listen to updates from select mgr
	// but we're never destroyed.
	if (!getVisible()) return;

	LLObjectSelection* selection = LLSelectMgr::getInstance()->getSelection();
	if (!selection) return;

	LLSelectNode* nodep = selection->getFirstRootNode();
	if (!nodep) return;

	// If we don't have fresh object info yet and it's the object we inspected last time,
	// keep showing the previously retrieved data until we get the update.
	if (!nodep->mValid && nodep->getObject()->getID() == mPreviousObjectID)
	{
		return;
	}

	updateButtons(nodep);
	updateName(nodep);
	updateDescription(nodep);
	updateCreator(nodep);
	updatePrice(nodep);
	
	LLViewerObject* obj = nodep->getObject();
	if(!obj)
		return;
	
	if ( mObjectFace < 0 
		||  mObjectFace >= obj->getNumTEs() )
	{
		return;
	}
	
	// Does this face have media?
	const LLTextureEntry* tep = obj->getTE(mObjectFace);
	if (!tep)
		return;
	
	mMediaEntry = tep->hasMedia() ? tep->getMediaData() : NULL;
	if(!mMediaEntry)
		return;
	
	mMediaImpl = LLViewerMedia::getInstance()->getMediaImplFromTextureID(mMediaEntry->getMediaID());
	
	updateMediaCurrentURL();
	updateSecureBrowsing();
}

void LLInspectObject::hideButtons()
{
	getChild<LLUICtrl>("buy_btn")->setVisible(false);
	getChild<LLUICtrl>("pay_btn")->setVisible(false);
	getChild<LLUICtrl>("take_free_copy_btn")->setVisible(false);
	getChild<LLUICtrl>("touch_btn")->setVisible(false);
	getChild<LLUICtrl>("sit_btn")->setVisible(false);
	getChild<LLUICtrl>("open_btn")->setVisible(false);
}

// *TODO: Extract this method from lltoolpie.cpp and put somewhere shared
extern U8 final_click_action(LLViewerObject*);

// Choose the "most relevant" operation for this object, and show a button for
// that operation as the left-most button in the inspector.
void LLInspectObject::updateButtons(LLSelectNode* nodep)
{
	// We'll start with everyone hidden and show the ones we need
	hideButtons();
	
	LLViewerObject* object = nodep->getObject();
	LLViewerObject *parent = (LLViewerObject*)object->getParent();
	bool for_copy = anyone_copy_selection(nodep);
	bool for_sale = enable_buy_object();
	S32 price = nodep->mSaleInfo.getSalePrice();
	U8 click_action = final_click_action(object);

	if (for_copy
		|| (for_sale && price == 0))
	{
		// Free copies have priority over other operations
		getChild<LLUICtrl>("take_free_copy_btn")->setVisible(true);
	}
	else if (for_sale)
	{
		getChild<LLUICtrl>("buy_btn")->setVisible(true);
	}
	else if ( enable_pay_object() )
	{
		getChild<LLUICtrl>("pay_btn")->setVisible(true);
	}
	else if (click_action == CLICK_ACTION_SIT)
	{
		// Click-action sit must come before "open" because many objects on
		// which you can sit have scripts, and hence can be opened
		getChild<LLUICtrl>("sit_btn")->setVisible(true);
		updateSitLabel(nodep);
	}
	else if (object->flagHandleTouch()
		|| (parent && parent->flagHandleTouch()))
	{
		getChild<LLUICtrl>("touch_btn")->setVisible(true);
		updateTouchLabel(nodep);
	}
	else if ( enable_object_open() )
	{
		// Open is last because anything with a script in it can be opened
		getChild<LLUICtrl>("open_btn")->setVisible(true);
	}
	else
	{
		// By default, we can sit on anything
		getChild<LLUICtrl>("sit_btn")->setVisible(true);
		updateSitLabel(nodep);
	}

	// No flash
	focusFirstItem(FALSE, FALSE);
}

void LLInspectObject::updateSitLabel(LLSelectNode* nodep)
{
	LLButton* sit_btn = getChild<LLButton>("sit_btn");
	if (!nodep->mSitName.empty())
	{
		sit_btn->setLabel( nodep->mSitName );
	}
	else
	{
		sit_btn->setLabel( getString("Sit") );
	}
}

void LLInspectObject::updateTouchLabel(LLSelectNode* nodep)
{
	LLButton* sit_btn = getChild<LLButton>("touch_btn");
	if (!nodep->mTouchName.empty())
	{
		sit_btn->setLabel( nodep->mTouchName );
	}
	else
	{
		sit_btn->setLabel( getString("Touch") );
	}
}

void LLInspectObject::updateName(LLSelectNode* nodep)
{
	std::string name;
	if (!nodep->mName.empty())
	{
		name = nodep->mName;
	}
	else
	{
		name = LLTrans::getString("TooltipNoName");
	}
	getChild<LLUICtrl>("object_name")->setValue(name);
}

void LLInspectObject::updateDescription(LLSelectNode* nodep)
{
	const char* const DEFAULT_DESC = "(No Description)";
	std::string desc;
	if (!nodep->mDescription.empty()
		&& nodep->mDescription != DEFAULT_DESC)
	{
		desc = nodep->mDescription;
	}

	LLTextBox* textbox = getChild<LLTextBox>("object_description");
	textbox->setValue(desc);
}

void LLInspectObject::updateMediaCurrentURL()
{	
	if(!mMediaEntry)
		return;
	LLTextBox* textbox = getChild<LLTextBox>("object_media_url");
	std::string media_url = "";
	textbox->setValue(media_url);
	textbox->setToolTip(media_url);
	LLStringUtil::format_map_t args;
	
	if(mMediaImpl.notNull() && mMediaImpl->hasMedia())
	{
		
		LLPluginClassMedia* media_plugin = NULL;
		media_plugin = mMediaImpl->getMediaPlugin();
		if(media_plugin)
		{
			if(media_plugin->pluginSupportsMediaTime())
			{
				args["[CurrentURL]"] =  mMediaImpl->getMediaURL();
			}
			else
			{
				args["[CurrentURL]"] =  media_plugin->getLocation();
			}
			media_url = LLTrans::getString("CurrentURL", args);

		}
	}
	else if(mMediaEntry->getCurrentURL() != "")
	{
		args["[CurrentURL]"] = mMediaEntry->getCurrentURL();
		media_url = LLTrans::getString("CurrentURL", args);
	}

	textbox->setText(media_url);
	textbox->setToolTip(media_url);
}

void LLInspectObject::updateCreator(LLSelectNode* nodep)
{
	// final information for display
	LLStringUtil::format_map_t args;
	std::string text;
	
	// Leave text blank until data loaded
	if (nodep->mValid)
	{
		// Utilize automatic translation of SLURL into name to display 
		// a clickable link		
		// Objects cannot be created by a group, so use agent URL format
		LLUUID creator_id = nodep->mPermissions->getCreator();
		std::string creator_url =
			LLSLURL("agent", creator_id, "about").getSLURLString();
		args["[CREATOR]"] = creator_url;
				
		// created by one user but owned by another
		std::string owner_url;
		LLUUID owner_id;
		bool group_owned = nodep->mPermissions->isGroupOwned();
		if (group_owned)
		{
			owner_id = nodep->mPermissions->getGroup();
			owner_url =	LLSLURL("group", owner_id, "about").getSLURLString();
		}
		else
		{
			owner_id = nodep->mPermissions->getOwner();
			owner_url =	LLSLURL("agent", owner_id, "about").getSLURLString();
		}
		args["[OWNER]"] = owner_url;
		
		if (creator_id == owner_id)
		{
			// common case, created and owned by one user
			text = getString("Creator", args);
		}
		else
		{
			text = getString("CreatorAndOwner", args);
		}
	}
	getChild<LLUICtrl>("object_creator")->setValue(text);
}

void LLInspectObject::updatePrice(LLSelectNode* nodep)
{
	// *TODO: Only look these up once and use for both updateButtons and here
	bool for_copy = anyone_copy_selection(nodep);
	bool for_sale = enable_buy_object();
	S32 price = nodep->mSaleInfo.getSalePrice();
	
	bool show_price_icon = false;
	std::string line;
	if (for_copy
		|| (for_sale && price == 0))
	{
		line = getString("PriceFree");
		show_price_icon = true;
	}
	else if (for_sale)
	{
		LLStringUtil::format_map_t args;
		args["[AMOUNT]"] = LLResMgr::getInstance()->getMonetaryString(price);
		line = getString("Price", args);
		show_price_icon = true;
	}
	getChild<LLUICtrl>("price_text")->setValue(line);
	getChild<LLUICtrl>("price_icon")->setVisible(show_price_icon);
}

void LLInspectObject::updateSecureBrowsing()
{
	bool is_secure_browsing = false;
	
	if(mMediaImpl.notNull() 
	   && mMediaImpl->hasMedia())
	{
		LLPluginClassMedia* media_plugin = NULL;
		std::string current_url = "";
		media_plugin = mMediaImpl->getMediaPlugin();
		if(media_plugin)
		{
			if(media_plugin->pluginSupportsMediaTime())
			{
				current_url = mMediaImpl->getMediaURL();
			}
			else
			{
				current_url =  media_plugin->getLocation();
			}
		}
		
		std::string prefix =  std::string("https://");
		std::string test_prefix = current_url.substr(0, prefix.length());
		LLStringUtil::toLower(test_prefix);	
		if(test_prefix == prefix)
		{
			is_secure_browsing = true;
		}
	}
	getChild<LLUICtrl>("secure_browsing")->setVisible(is_secure_browsing);
}

// For the object inspector, only unpause the fade timer 
// if the gear menu is not open
void LLInspectObject::onMouseLeave(S32 x, S32 y, MASK mask)
{
	LLToggleableMenu* gear_menu = getChild<LLMenuButton>("gear_btn")->getMenu();
	if ( gear_menu && gear_menu->getVisible() )
	{
		return;
	}

	if(childHasVisiblePopupMenu())
	{
		return;
	}

	mOpenTimer.unpause();
}

void LLInspectObject::onClickBuy()
{
	handle_buy();
	closeFloater();
}

void LLInspectObject::onClickPay()
{
	handle_give_money_dialog();
	closeFloater();
}

void LLInspectObject::onClickTakeFreeCopy()
{
	LLObjectSelection* selection = LLSelectMgr::getInstance()->getSelection();
	if (!selection) return;

	LLSelectNode* nodep = selection->getFirstRootNode();
	if (!nodep) return;

	// Figure out if this is a "free buy" or a "take copy"
	bool for_copy = anyone_copy_selection(nodep);
	// Prefer to just take a free copy
	if (for_copy)
	{
		handle_take_copy();
	}
	else
	{
		// Buy for free (confusing, but that's how it is)
		handle_buy();
	}
	closeFloater();
}

void LLInspectObject::onClickTouch()
{
	handle_object_touch();
	closeFloater();
}

void LLInspectObject::onClickSit()
{
    bool is_sitting = false;
    if (mObjectSelection)
    {
        LLSelectNode* node = mObjectSelection->getFirstRootNode();
        if (node && node->mValid)
        {
            LLViewerObject* root_object = node->getObject();
            if (root_object
                && isAgentAvatarValid()
                && gAgentAvatarp->isSitting()
                && gAgentAvatarp->getRoot() == root_object)
            {
                is_sitting = true;
            }
        }
    }

    if (is_sitting)
    {
        gAgent.standUp();
    }
    else
    {
        handle_object_sit(mObjectID);
    }
	closeFloater();
}

void LLInspectObject::onClickOpen()
{
	LLFloaterReg::showInstance("openobject");
	closeFloater();
}

void LLInspectObject::onClickMoreInfo()
{
    LLFloaterReg::showInstance("task_properties");
	closeFloater();
}

void LLInspectObject::onClickZoomIn() 
{
	handle_look_at_selection("zoom");
	closeFloater();
}

//////////////////////////////////////////////////////////////////////////////
// LLInspectObjectUtil
//////////////////////////////////////////////////////////////////////////////
void LLInspectObjectUtil::registerFloater()
{
	LLFloaterReg::add("inspect_object", "inspect_object.xml",
					  &LLFloaterReg::build<LLInspectObject>);
}