/**
 * @file llavataractions.cpp
 * @brief Friend-related actions (add, remove, offer teleport, etc)
 *
 * $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 "llavataractions.h"

#include "boost/lambda/lambda.hpp"  // for lambda::constant

#include "llavatarnamecache.h"  // IDEVO
#include "llsd.h"
#include "llnotifications.h"
#include "llnotificationsutil.h"
#include "roles_constants.h"    // for GP_MEMBER_INVITE

#include "llagent.h"
#include "llappviewer.h"        // for gLastVersionChannel
#include "llcachename.h"
#include "llcallingcard.h"      // for LLAvatarTracker
#include "llconversationlog.h"
#include "llfloateravatarpicker.h"  // for LLFloaterAvatarPicker
#include "llfloaterconversationpreview.h"
#include "llfloatergroupinvite.h"
#include "llfloatergroups.h"
#include "llfloaterreg.h"
#include "llfloaterpay.h"
#include "llfloaterprofile.h"
#include "llfloatersidepanelcontainer.h"
#include "llfloaterwebcontent.h"
#include "llfloaterworldmap.h"
#include "llfolderview.h"
#include "llgiveinventory.h"
#include "llinventorybridge.h"
#include "llinventorymodel.h"   // for gInventory.findCategoryUUIDForType
#include "llinventorypanel.h"
#include "llfloaterimcontainer.h"
#include "llimview.h"           // for gIMMgr
#include "llmutelist.h"
#include "llnotificationsutil.h"    // for LLNotificationsUtil
#include "llpaneloutfitedit.h"
#include "llpanelprofile.h"
#include "llparcel.h"
#include "llrecentpeople.h"
#include "lltrans.h"
#include "llviewercontrol.h"
#include "llviewerobjectlist.h"
#include "llviewermessage.h"    // for handle_lure
#include "llviewernetwork.h" //LLGridManager
#include "llviewerparcelmgr.h"
#include "llviewerregion.h"
#include "lltrans.h"
#include "llcallingcard.h"
#include "llslurl.h"            // IDEVO
#include "llsidepanelinventory.h"
#include "llavatarname.h"
#include "llagentui.h"
#include "lluiusage.h"

// Flags for kick message
const U32 KICK_FLAGS_DEFAULT    = 0x0;
const U32 KICK_FLAGS_FREEZE     = 1 << 0;
const U32 KICK_FLAGS_UNFREEZE   = 1 << 1;


std::string getProfileURL(const std::string& agent_name, bool feed_only)
{
    std::string url = "[WEB_PROFILE_URL][AGENT_NAME][FEED_ONLY]";
    LLSD subs;
    subs["WEB_PROFILE_URL"] = LLGridManager::getInstance()->getWebProfileURL();
    subs["AGENT_NAME"] = agent_name;
    subs["FEED_ONLY"] = feed_only ? "/?feed_only=true" : "";
    url = LLWeb::expandURLSubstitutions(url, subs);
    LLStringUtil::toLower(url);
    return url;
}


// static
void LLAvatarActions::requestFriendshipDialog(const LLUUID& id, const std::string& name)
{
    if(id == gAgentID)
    {
        LLNotificationsUtil::add("AddSelfFriend");
        return;
    }

    LLSD args;
    args["NAME"] = LLSLURL("agent", id, "completename").getSLURLString();
    LLSD payload;
    payload["id"] = id;
    payload["name"] = name;

    LLNotificationsUtil::add("AddFriendWithMessage", args, payload, &callbackAddFriendWithMessage);

    // add friend to recent people list
    LLRecentPeople::instance().add(id);
}

static void on_avatar_name_friendship(const LLUUID& id, const LLAvatarName av_name)
{
    LLAvatarActions::requestFriendshipDialog(id, av_name.getCompleteName());
}

// static
void LLAvatarActions::requestFriendshipDialog(const LLUUID& id)
{
    if(id.isNull())
    {
        return;
    }

    LLAvatarNameCache::get(id, boost::bind(&on_avatar_name_friendship, _1, _2));
}

// static
void LLAvatarActions::removeFriendDialog(const LLUUID& id)
{
    if (id.isNull())
        return;

    uuid_vec_t ids;
    ids.push_back(id);
    removeFriendsDialog(ids);
}

// static
void LLAvatarActions::removeFriendsDialog(const uuid_vec_t& ids)
{
    if(ids.size() == 0)
        return;

    LLSD args;
    std::string msgType;
    if(ids.size() == 1)
    {
        LLUUID agent_id = ids[0];
        LLAvatarName av_name;
        if(LLAvatarNameCache::get(agent_id, &av_name))
        {
            args["NAME"] = av_name.getCompleteName();
        }

        msgType = "RemoveFromFriends";
    }
    else
    {
        msgType = "RemoveMultipleFromFriends";
    }

    LLSD payload;
    for (uuid_vec_t::const_iterator it = ids.begin(); it != ids.end(); ++it)
    {
        payload["ids"].append(*it);
    }

    LLNotificationsUtil::add(msgType,
        args,
        payload,
        &handleRemove);
}

// static
void LLAvatarActions::offerTeleport(const LLUUID& invitee)
{
    if (invitee.isNull())
        return;

    std::vector<LLUUID> ids;
    ids.push_back(invitee);
    offerTeleport(ids);
}

// static
void LLAvatarActions::offerTeleport(const uuid_vec_t& ids)
{
    if (ids.size() == 0)
        return;

    handle_lure(ids);
}

static void on_avatar_name_cache_start_im(const LLUUID& agent_id,
                                          const LLAvatarName& av_name)
{
    std::string name = av_name.getDisplayName();
    LLUUID session_id = gIMMgr->addSession(name, IM_NOTHING_SPECIAL, agent_id);
    if (session_id != LLUUID::null)
    {
        LLFloaterIMContainer::getInstance()->showConversation(session_id);
    }
    make_ui_sound("UISndStartIM");
}

// static
void LLAvatarActions::startIM(const LLUUID& id)
{
    if (id.isNull() || gAgent.getID() == id)
        return;

    LLAvatarNameCache::get(id, boost::bind(&on_avatar_name_cache_start_im, _1, _2));
}

// static
void LLAvatarActions::endIM(const LLUUID& id)
{
    if (id.isNull())
        return;

    LLUUID session_id = gIMMgr->computeSessionID(IM_NOTHING_SPECIAL, id);
    if (session_id != LLUUID::null)
    {
        gIMMgr->leaveSession(session_id);
    }
}

static void on_avatar_name_cache_start_call(const LLUUID& agent_id,
                                            const LLAvatarName& av_name)
{
    std::string name = av_name.getDisplayName();
    LLUUID session_id = gIMMgr->addSession(name, IM_NOTHING_SPECIAL, agent_id, LLSD());
    if (session_id != LLUUID::null)
    {
        gIMMgr->startCall(session_id);
    }
    make_ui_sound("UISndStartIM");
}

// static
void LLAvatarActions::startCall(const LLUUID& id)
{
    if (id.isNull())
    {
        return;
    }
    LLAvatarNameCache::get(id, boost::bind(&on_avatar_name_cache_start_call, _1, _2));
}

// static
void LLAvatarActions::startAdhocCall(const uuid_vec_t& ids, const LLUUID& floater_id)
{
    if (ids.size() == 0)
    {
        return;
    }

    // convert vector into std::vector for addSession
    std::vector<LLUUID> id_array;
    id_array.reserve(ids.size());
    for (uuid_vec_t::const_iterator it = ids.begin(); it != ids.end(); ++it)
    {
        id_array.push_back(*it);
    }

    // create the new ad hoc voice session
    const std::string title = LLTrans::getString("conference-title");
    LLUUID session_id = gIMMgr->addSession(title, IM_SESSION_CONFERENCE_START, ids[0], id_array, LLSD(), floater_id);
    if (session_id == LLUUID::null)
    {
        return;
    }

    gIMMgr->autoStartCallOnStartup(session_id);

    make_ui_sound("UISndStartIM");
}

/* AD *TODO: Is this function needed any more?
    I fixed it a bit(added check for canCall), but it appears that it is not used
    anywhere. Maybe it should be removed?
// static
bool LLAvatarActions::isCalling(const LLUUID &id)
{
    if (id.isNull() || !canCall())
    {
        return false;
    }

    LLUUID session_id = gIMMgr->computeSessionID(IM_NOTHING_SPECIAL, id);
    return (LLIMModel::getInstance()->findIMSession(session_id) != NULL);
}*/

//static
bool LLAvatarActions::canCall()
{
    return LLVoiceClient::getInstance()->voiceEnabled() && LLVoiceClient::getInstance()->isVoiceWorking();
}

// static
void LLAvatarActions::startConference(const uuid_vec_t& ids, const LLUUID& floater_id)
{
    // *HACK: Copy into dynamic array
    std::vector<LLUUID> id_array;

    id_array.reserve(ids.size());
    for (uuid_vec_t::const_iterator it = ids.begin(); it != ids.end(); ++it)
    {
        id_array.push_back(*it);
    }
    const std::string title = LLTrans::getString("conference-title");
    LLUUID  session_id = gIMMgr->addSession(title, IM_SESSION_CONFERENCE_START, ids[0], id_array, LLSD(), floater_id);

    if (session_id == LLUUID::null)
    {
        return;
    }

    LLFloaterIMContainer::getInstance()->showConversation(session_id);

    make_ui_sound("UISndStartIM");
}

// static
void LLAvatarActions::showProfile(const LLUUID& avatar_id)
{
    if (avatar_id.notNull())
    {
        LLFloaterReg::showInstance("profile", LLSD().with("id", avatar_id));
    }
}

// static
void LLAvatarActions::showPicks(const LLUUID& avatar_id)
{
    if (avatar_id.notNull())
    {
        LLFloaterProfile* profilefloater = dynamic_cast<LLFloaterProfile*>(LLFloaterReg::showInstance("profile", LLSD().with("id", avatar_id)));
        if (profilefloater)
        {
            profilefloater->showPick();
        }
    }
}

// static
void LLAvatarActions::showPick(const LLUUID& avatar_id, const LLUUID& pick_id)
{
    if (avatar_id.notNull())
    {
        LLFloaterProfile* profilefloater = dynamic_cast<LLFloaterProfile*>(LLFloaterReg::showInstance("profile", LLSD().with("id", avatar_id)));
        if (profilefloater)
        {
            profilefloater->showPick(pick_id);
        }
    }
}

// static
void LLAvatarActions::createPick()
{
    LLFloaterProfile* profilefloater = dynamic_cast<LLFloaterProfile*>(LLFloaterReg::showInstance("profile", LLSD().with("id", gAgent.getID())));
    LLViewerRegion* region = gAgent.getRegion();
    if (profilefloater && region)
    {
        LLPickData data;
        data.pos_global = gAgent.getPositionGlobal();
        data.sim_name = region->getName();

        LLParcel* parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
        if (parcel)
        {
            data.name = parcel->getName();
            data.desc = parcel->getDesc();
            data.snapshot_id = parcel->getSnapshotID();
            data.parcel_id = parcel->getID();
        }
        else
        {
            data.name = region->getName();
        }

        profilefloater->createPick(data);
    }
}

// static
bool LLAvatarActions::isPickTabSelected(const LLUUID& avatar_id)
{
    if (avatar_id.notNull())
    {
        LLFloaterProfile* profilefloater = LLFloaterReg::findTypedInstance<LLFloaterProfile>("profile", LLSD().with("id", avatar_id));
        if (profilefloater)
        {
            return profilefloater->isPickTabSelected();
        }
    }
    return false;
}

// static
void LLAvatarActions::showClassifieds(const LLUUID& avatar_id)
{
    if (avatar_id.notNull())
    {
        LLFloaterProfile* profilefloater = dynamic_cast<LLFloaterProfile*>(LLFloaterReg::showInstance("profile", LLSD().with("id", avatar_id)));
        if (profilefloater)
        {
            profilefloater->showClassified();
        }
    }
}

// static
void LLAvatarActions::showClassified(const LLUUID& avatar_id, const LLUUID& classified_id, bool edit)
{
    if (avatar_id.notNull())
    {
        LLFloaterProfile* profilefloater = dynamic_cast<LLFloaterProfile*>(LLFloaterReg::showInstance("profile", LLSD().with("id", avatar_id)));
        if (profilefloater)
        {
            profilefloater->showClassified(classified_id, edit);
        }
    }
}

// static
void LLAvatarActions::createClassified()
{
    LLFloaterProfile* profilefloater = dynamic_cast<LLFloaterProfile*>(LLFloaterReg::showInstance("profile", LLSD().with("id", gAgent.getID())));
    if (profilefloater)
    {
        profilefloater->createClassified();
    }
}

//static
bool LLAvatarActions::profileVisible(const LLUUID& avatar_id)
{
    LLSD sd;
    sd["id"] = avatar_id;
    LLFloater* floater = getProfileFloater(avatar_id);
    return floater && floater->isShown();
}

//static
LLFloater* LLAvatarActions::getProfileFloater(const LLUUID& avatar_id)
{
    LLFloaterProfile* floater = LLFloaterReg::findTypedInstance<LLFloaterProfile>("profile", LLSD().with("id", avatar_id));
    return floater;
}

//static
void LLAvatarActions::hideProfile(const LLUUID& avatar_id)
{
    LLSD sd;
    sd["id"] = avatar_id;
    LLFloater* floater = getProfileFloater(avatar_id);
    if (floater)
    {
        floater->closeFloater();
    }
}

// static
void LLAvatarActions::showOnMap(const LLUUID& id)
{
    LLAvatarName av_name;
    if (!LLAvatarNameCache::get(id, &av_name))
    {
        LLAvatarNameCache::get(id, boost::bind(&LLAvatarActions::showOnMap, id));
        return;
    }

    gFloaterWorldMap->trackAvatar(id, av_name.getDisplayName());
    LLFloaterReg::showInstance("world_map", "center");
}

// static
void LLAvatarActions::pay(const LLUUID& id)
{
    LLNotification::Params params("DoNotDisturbModePay");
    params.functor.function(boost::bind(&LLAvatarActions::handlePay, _1, _2, id));

    if (gAgent.isDoNotDisturb())
    {
        // warn users of being in do not disturb mode during a transaction
        LLNotifications::instance().add(params);
    }
    else
    {
        LLNotifications::instance().forceResponse(params, 1);
    }
}

void LLAvatarActions::teleport_request_callback(const LLSD& notification, const LLSD& response)
{
    S32 option;
    if (response.isInteger())
    {
        option = response.asInteger();
    }
    else
    {
        option = LLNotificationsUtil::getSelectedOption(notification, response);
    }

    if (0 == option)
    {
        LLMessageSystem* msg = gMessageSystem;

        msg->newMessageFast(_PREHASH_ImprovedInstantMessage);
        msg->nextBlockFast(_PREHASH_AgentData);
        msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
        msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());

        msg->nextBlockFast(_PREHASH_MessageBlock);
        msg->addBOOLFast(_PREHASH_FromGroup, FALSE);
        msg->addUUIDFast(_PREHASH_ToAgentID, notification["substitutions"]["uuid"] );
        msg->addU8Fast(_PREHASH_Offline, IM_ONLINE);
        msg->addU8Fast(_PREHASH_Dialog, IM_TELEPORT_REQUEST);
        msg->addUUIDFast(_PREHASH_ID, LLUUID::null);
        msg->addU32Fast(_PREHASH_Timestamp, NO_TIMESTAMP); // no timestamp necessary

        std::string name;
        LLAgentUI::buildFullname(name);

        msg->addStringFast(_PREHASH_FromAgentName, name);
        msg->addStringFast(_PREHASH_Message, response["message"]);
        msg->addU32Fast(_PREHASH_ParentEstateID, 0);
        msg->addUUIDFast(_PREHASH_RegionID, LLUUID::null);
        msg->addVector3Fast(_PREHASH_Position, gAgent.getPositionAgent());

        gMessageSystem->addBinaryDataFast(
                _PREHASH_BinaryBucket,
                EMPTY_BINARY_BUCKET,
                EMPTY_BINARY_BUCKET_SIZE);

        gAgent.sendReliableMessage();
    }
}

// static
void LLAvatarActions::teleportRequest(const LLUUID& id)
{
    LLSD notification;
    notification["uuid"] = id;
    LLAvatarName av_name;
    if (!LLAvatarNameCache::get(id, &av_name))
    {
        // unlikely ... they just picked this name from somewhere...
        LLAvatarNameCache::get(id, boost::bind(&LLAvatarActions::teleportRequest, id));
        return; // reinvoke this when the name resolves
    }
    notification["NAME"] = av_name.getCompleteName();

    LLSD payload;

    LLNotificationsUtil::add("TeleportRequestPrompt", notification, payload, teleport_request_callback);
}

// static
void LLAvatarActions::kick(const LLUUID& id)
{
    LLSD payload;
    payload["avatar_id"] = id;
    LLNotifications::instance().add("KickUser", LLSD(), payload, handleKick);
}

// static
void LLAvatarActions::freezeAvatar(const LLUUID& id)
{
    LLAvatarName av_name;
    LLSD payload;
    payload["avatar_id"] = id;

    if (LLAvatarNameCache::get(id, &av_name))
    {
        LLSD args;
        args["AVATAR_NAME"] = av_name.getUserName();
        LLNotificationsUtil::add("FreezeAvatarFullname", args, payload, handleFreezeAvatar);
    }
    else
    {
        LLNotificationsUtil::add("FreezeAvatar", LLSD(), payload, handleFreezeAvatar);
    }
}

// static
void LLAvatarActions::ejectAvatar(const LLUUID& id, bool ban_enabled)
{
    LLAvatarName av_name;
    LLSD payload;
    payload["avatar_id"] = id;
    payload["ban_enabled"] = ban_enabled;
    LLSD args;
    bool has_name = LLAvatarNameCache::get(id, &av_name);
    if (has_name)
    {
        args["AVATAR_NAME"] = av_name.getUserName();
    }

    if (ban_enabled)
    {
            LLNotificationsUtil::add("EjectAvatarFullname", args, payload, handleEjectAvatar);
    }
    else
    {
        if (has_name)
        {
            LLNotificationsUtil::add("EjectAvatarFullnameNoBan", args, payload, handleEjectAvatar);
        }
        else
        {
            LLNotificationsUtil::add("EjectAvatarNoBan", LLSD(), payload, handleEjectAvatar);
        }
    }
}

// static
void LLAvatarActions::freeze(const LLUUID& id)
{
    LLSD payload;
    payload["avatar_id"] = id;
    LLNotifications::instance().add("FreezeUser", LLSD(), payload, handleFreeze);
}
// static
void LLAvatarActions::unfreeze(const LLUUID& id)
{
    LLSD payload;
    payload["avatar_id"] = id;
    LLNotifications::instance().add("UnFreezeUser", LLSD(), payload, handleUnfreeze);
}

//static
void LLAvatarActions::csr(const LLUUID& id, std::string name)
{
    if (name.empty()) return;

    std::string url = "http://csr.lindenlab.com/agent/";

    // slow and stupid, but it's late
    S32 len = name.length();
    for (S32 i = 0; i < len; i++)
    {
        if (name[i] == ' ')
        {
            url += "%20";
        }
        else
        {
            url += name[i];
        }
    }

    LLWeb::loadURL(url);
}

//static
void LLAvatarActions::share(const LLUUID& id)
{
    LLSD key;
    LLFloaterSidePanelContainer::showPanel("inventory", key);
    LLFloaterReg::showInstance("im_container");

    LLUUID session_id = gIMMgr->computeSessionID(IM_NOTHING_SPECIAL,id);

    if (!gIMMgr->hasSession(session_id))
    {
        startIM(id);
    }

    if (gIMMgr->hasSession(session_id))
    {
        // we should always get here, but check to verify anyways
        LLIMModel::getInstance()->addMessage(session_id, SYSTEM_FROM, LLUUID::null, LLTrans::getString("share_alert"), false);

        LLFloaterIMSessionTab* session_floater = LLFloaterIMSessionTab::findConversation(session_id);
        if (session_floater && session_floater->isMinimized())
        {
            session_floater->setMinimized(false);
        }
        LLFloaterIMContainer *im_container = LLFloaterReg::getTypedInstance<LLFloaterIMContainer>("im_container");
        im_container->selectConversationPair(session_id, true);
    }
}

namespace action_give_inventory
{
    /**
     * Returns a pointer to 'Add More' inventory panel of Edit Outfit SP.
     */
    static LLInventoryPanel* get_outfit_editor_inventory_panel()
    {
        LLPanelOutfitEdit* panel_outfit_edit = dynamic_cast<LLPanelOutfitEdit*>(LLFloaterSidePanelContainer::getPanel("appearance", "panel_outfit_edit"));
        if (NULL == panel_outfit_edit) return NULL;

        LLInventoryPanel* inventory_panel = panel_outfit_edit->findChild<LLInventoryPanel>("folder_view");
        return inventory_panel;
    }

    /**
     * @return active inventory panel, or NULL if there's no such panel
     */
    static LLInventoryPanel* get_active_inventory_panel()
    {
        LLInventoryPanel* active_panel = LLInventoryPanel::getActiveInventoryPanel(FALSE);
        LLFloater* floater_appearance = LLFloaterReg::findInstance("appearance");
        if (!active_panel || (floater_appearance && floater_appearance->hasFocus()))
        {
            active_panel = get_outfit_editor_inventory_panel();
        }

        return active_panel;
    }

    /**
     * Checks My Inventory visibility.
     */
    static bool is_give_inventory_acceptable_ids(const std::set<LLUUID> inventory_selected_uuids)
    {
        if (inventory_selected_uuids.empty()) return false; // nothing selected

        bool acceptable = false;
        std::set<LLUUID>::const_iterator it = inventory_selected_uuids.begin();
        const std::set<LLUUID>::const_iterator it_end = inventory_selected_uuids.end();
        for (; it != it_end; ++it)
        {
            LLViewerInventoryCategory* inv_cat = gInventory.getCategory(*it);
            // any category can be offered.
            if (inv_cat)
            {
                acceptable = true;
                continue;
            }

            LLViewerInventoryItem* inv_item = gInventory.getItem(*it);
            // check if inventory item can be given
            if (LLGiveInventory::isInventoryGiveAcceptable(inv_item))
            {
                acceptable = true;
                continue;
            }

            // there are neither item nor category in inventory
            acceptable = false;
            break;
        }
    return acceptable;
    }

    static bool is_give_inventory_acceptable(LLInventoryPanel* panel = NULL)
    {
        // check selection in the panel
        std::set<LLUUID> inventory_selected_uuids = LLAvatarActions::getInventorySelectedUUIDs(panel);
        if (inventory_selected_uuids.empty())
        {
            if(panel && panel->getRootFolder() && panel->getRootFolder()->isSingleFolderMode())
            {
                inventory_selected_uuids.insert(panel->getRootFolderID());
            }
            else
            {
                return false; // nothing selected
            }
        }

        return is_give_inventory_acceptable_ids(inventory_selected_uuids);
    }

    static void build_items_string(const std::set<LLUUID>& inventory_selected_uuids , std::string& items_string)
    {
        llassert(inventory_selected_uuids.size() > 0);

        const std::string& separator = LLTrans::getString("words_separator");
        for (std::set<LLUUID>::const_iterator it = inventory_selected_uuids.begin(); ; )
        {
            LLViewerInventoryCategory* inv_cat = gInventory.getCategory(*it);
            if (NULL != inv_cat)
            {
                items_string = inv_cat->getName();
                break;
            }
            LLViewerInventoryItem* inv_item = gInventory.getItem(*it);
            if (NULL != inv_item)
            {
                items_string.append(inv_item->getName());
            }
            if(++it == inventory_selected_uuids.end())
            {
                break;
            }
            items_string.append(separator);
        }
    }

    struct LLShareInfo : public LLSingleton<LLShareInfo>
    {
        LLSINGLETON_EMPTY_CTOR(LLShareInfo);
    public:
        std::vector<LLAvatarName> mAvatarNames;
        uuid_vec_t mAvatarUuids;
    };

    static void give_inventory_cb(const LLSD& notification, const LLSD& response, std::set<LLUUID> inventory_selected_uuids)
    {
        S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
        // if Cancel pressed
        if (option == 1)
        {
            return;
        }

        if (inventory_selected_uuids.empty())
        {
            return;
        }

        S32 count = LLShareInfo::instance().mAvatarNames.size();
        bool shared = count && !inventory_selected_uuids.empty();

        // iterate through avatars
        for(S32 i = 0; i < count; ++i)
        {
            const LLUUID& avatar_uuid = LLShareInfo::instance().mAvatarUuids[i];

            // We souldn't open IM session, just calculate session ID for logging purpose. See EXT-6710
            const LLUUID session_id = gIMMgr->computeSessionID(IM_NOTHING_SPECIAL, avatar_uuid);

            std::set<LLUUID>::const_iterator it = inventory_selected_uuids.begin();
            const std::set<LLUUID>::const_iterator it_end = inventory_selected_uuids.end();

            const std::string& separator = LLTrans::getString("words_separator");
            std::string noncopy_item_names;
            LLSD noncopy_items = LLSD::emptyArray();
            // iterate through selected inventory objects
            for (; it != it_end; ++it)
            {
                LLViewerInventoryCategory* inv_cat = gInventory.getCategory(*it);
                if (inv_cat)
                {
                    if (!LLGiveInventory::doGiveInventoryCategory(avatar_uuid, inv_cat, session_id, "ItemsShared"))
                    {
                        shared = false;
                    }
                    break;
                }
                LLViewerInventoryItem* inv_item = gInventory.getItem(*it);
                if (!inv_item->getPermissions().allowCopyBy(gAgentID))
                {
                    if (!noncopy_item_names.empty())
                    {
                        noncopy_item_names.append(separator);
                    }
                    noncopy_item_names.append(inv_item->getName());
                    noncopy_items.append(*it);
                }
                else
                {
                    if (!LLGiveInventory::doGiveInventoryItem(avatar_uuid, inv_item, session_id))
                    {
                        shared = false;
                    }
                }
            }
            if (noncopy_items.beginArray() != noncopy_items.endArray())
            {
                LLSD substitutions;
                substitutions["ITEMS"] = noncopy_item_names;
                LLSD payload;
                payload["agent_id"] = avatar_uuid;
                payload["items"] = noncopy_items;
                payload["success_notification"] = "ItemsShared";
                LLNotificationsUtil::add("CannotCopyWarning", substitutions, payload,
                    &LLGiveInventory::handleCopyProtectedItem);
                shared = false;
                break;
            }
        }
        if (shared)
        {
            LLFloaterReg::hideInstance("avatar_picker");
            LLNotificationsUtil::add("ItemsShared");
        }
    }

    /**
     * Performs "give inventory" operations for provided avatars.
     *
     * Sends one requests to give all selected inventory items for each passed avatar.
     * Avatars are represent by two vectors: names and UUIDs which must be sychronized with each other.
     *
     * @param avatar_names - avatar names request to be sent.
     * @param avatar_uuids - avatar names request to be sent.
     */

    static void give_inventory_ids(const uuid_vec_t& avatar_uuids, const std::vector<LLAvatarName> avatar_names, const uuid_set_t inventory_selected_uuids)
    {
        llassert(avatar_names.size() == avatar_uuids.size());

        if (inventory_selected_uuids.empty())
        {
            return;
        }

        std::string residents;
        LLAvatarActions::buildResidentsString(avatar_names, residents, true);

        std::string items;
        build_items_string(inventory_selected_uuids, items);

        int folders_count = 0;
        std::set<LLUUID>::const_iterator it = inventory_selected_uuids.begin();

        //traverse through selected inventory items and count folders among them
        for ( ; it != inventory_selected_uuids.end() && folders_count <=1 ; ++it)
        {
            LLViewerInventoryCategory* inv_cat = gInventory.getCategory(*it);
            if (NULL != inv_cat)
            {
                folders_count++;
            }
        }

        // EXP-1599
        // In case of sharing multiple folders, make the confirmation
        // dialog contain a warning that only one folder can be shared at a time.
        std::string notification = (folders_count > 1) ? "ShareFolderConfirmation" : "ShareItemsConfirmation";
        LLSD substitutions;
        substitutions["RESIDENTS"] = residents;
        substitutions["ITEMS"] = items;
        LLShareInfo::instance().mAvatarNames = avatar_names;
        LLShareInfo::instance().mAvatarUuids = avatar_uuids;
        LLNotificationsUtil::add(notification, substitutions, LLSD(), boost::bind(&give_inventory_cb, _1, _2, inventory_selected_uuids));
    }

    static void give_inventory(const uuid_vec_t& avatar_uuids, const std::vector<LLAvatarName> avatar_names, LLInventoryPanel* panel = NULL)
    {
        llassert(avatar_names.size() == avatar_uuids.size());
        std::set<LLUUID> inventory_selected_uuids = LLAvatarActions::getInventorySelectedUUIDs(panel);;

        if (inventory_selected_uuids.empty())
        {
            if(panel && panel->getRootFolder() && panel->getRootFolder()->isSingleFolderMode())
            {
                inventory_selected_uuids.insert(panel->getRootFolderID());
            }
            else
            {
                return;
            }
        }
        give_inventory_ids(avatar_uuids, avatar_names, inventory_selected_uuids);
    }
}

// static
void LLAvatarActions::buildResidentsString(std::vector<LLAvatarName> avatar_names, std::string& residents_string, bool complete_name)
{
    llassert(avatar_names.size() > 0);

    std::sort(avatar_names.begin(), avatar_names.end());
    const std::string& separator = LLTrans::getString("words_separator");
    for (std::vector<LLAvatarName>::const_iterator it = avatar_names.begin(); ; )
    {
        if(complete_name)
        {
            residents_string.append((*it).getCompleteName());
        }
        else
        {
            residents_string.append((*it).getDisplayName());
        }

        if  (++it == avatar_names.end())
        {
            break;
        }
        residents_string.append(separator);
    }
}

// static
void LLAvatarActions::buildResidentsString(const uuid_vec_t& avatar_uuids, std::string& residents_string)
{
    std::vector<LLAvatarName> avatar_names;
    uuid_vec_t::const_iterator it = avatar_uuids.begin();
    for (; it != avatar_uuids.end(); ++it)
    {
        LLAvatarName av_name;
        if (LLAvatarNameCache::get(*it, &av_name))
        {
            avatar_names.push_back(av_name);
        }
    }

    // We should check whether the vector is not empty to pass the assertion
    // that avatar_names.size() > 0 in LLAvatarActions::buildResidentsString.
    if (!avatar_names.empty())
    {
        LLAvatarActions::buildResidentsString(avatar_names, residents_string);
    }
}

//static
std::set<LLUUID> LLAvatarActions::getInventorySelectedUUIDs(LLInventoryPanel* active_panel)
{
    std::set<LLFolderViewItem*> inventory_selected;

    if (!active_panel)
    {
        active_panel = action_give_inventory::get_active_inventory_panel();
    }
    if (active_panel)
    {
        inventory_selected= active_panel->getRootFolder()->getSelectionList();
    }

    if (inventory_selected.empty())
    {
        LLSidepanelInventory *sidepanel_inventory = LLFloaterSidePanelContainer::getPanel<LLSidepanelInventory>("inventory");
        if (sidepanel_inventory)
        {
            inventory_selected= sidepanel_inventory->getInboxSelectionList();
        }
    }

    std::set<LLUUID> inventory_selected_uuids;
    for (std::set<LLFolderViewItem*>::iterator it = inventory_selected.begin(), end_it = inventory_selected.end();
        it != end_it;
        ++it)
    {
        inventory_selected_uuids.insert(static_cast<LLFolderViewModelItemInventory*>((*it)->getViewModelItem())->getUUID());
    }
    return inventory_selected_uuids;
}

//static
void LLAvatarActions::shareWithAvatars(LLView * panel)
{
    using namespace action_give_inventory;

    LLFloater* root_floater = gFloaterView->getParentFloater(panel);
    LLInventoryPanel* inv_panel = dynamic_cast<LLInventoryPanel*>(panel);
    LLFloaterAvatarPicker* picker =
        LLFloaterAvatarPicker::show(boost::bind(give_inventory, _1, _2, inv_panel), TRUE, FALSE, FALSE, root_floater->getName());
    if (!picker)
    {
        return;
    }

    picker->setOkBtnEnableCb(boost::bind(is_give_inventory_acceptable, inv_panel));
    picker->openFriendsTab();

    if (root_floater)
    {
        root_floater->addDependentFloater(picker);
    }
    LLNotificationsUtil::add("ShareNotification");
}

//static
void LLAvatarActions::shareWithAvatars(const uuid_set_t inventory_selected_uuids, LLFloater* root_floater)
{
    using namespace action_give_inventory;

    LLFloaterAvatarPicker* picker =
        LLFloaterAvatarPicker::show(boost::bind(give_inventory_ids, _1, _2, inventory_selected_uuids), TRUE, FALSE, FALSE, root_floater->getName());
    if (!picker)
    {
        return;
    }

    picker->setOkBtnEnableCb(boost::bind(is_give_inventory_acceptable_ids, inventory_selected_uuids));
    picker->openFriendsTab();

    if (root_floater)
    {
        root_floater->addDependentFloater(picker);
    }
    LLNotificationsUtil::add("ShareNotification");
}

// static
bool LLAvatarActions::canShareSelectedItems(LLInventoryPanel* inv_panel /* = NULL*/)
{
    using namespace action_give_inventory;

    if (!inv_panel)
    {
        LLInventoryPanel* active_panel = get_active_inventory_panel();
        if (!active_panel) return false;
        inv_panel = active_panel;
    }

    // check selection in the panel
    LLFolderView* root_folder = inv_panel->getRootFolder();
    if (!root_folder)
    {
        return false;
    }
    const std::set<LLFolderViewItem*> inventory_selected = root_folder->getSelectionList();
    if (inventory_selected.empty()) return false; // nothing selected

    const LLUUID trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);
    bool can_share = true;
    std::set<LLFolderViewItem*>::const_iterator it = inventory_selected.begin();
    const std::set<LLFolderViewItem*>::const_iterator it_end = inventory_selected.end();
    for (; it != it_end; ++it)
    {
        LLUUID cat_id = static_cast<LLFolderViewModelItemInventory*>((*it)->getViewModelItem())->getUUID();
        LLViewerInventoryCategory* inv_cat = gInventory.getCategory(cat_id);
        // any category can be offered if it's not in trash.
        if (inv_cat)
        {
            if ((cat_id == trash_id) || gInventory.isObjectDescendentOf(cat_id, trash_id))
            {
                can_share = false;
                break;
            }
            continue;
        }

        // check if inventory item can be given
        LLFolderViewItem* item = *it;
        if (!item) return false;
        LLInvFVBridge* bridge = dynamic_cast<LLInvFVBridge*>(item->getViewModelItem());
        if (bridge && bridge->canShare())
        {
            continue;
        }

        // there are neither item nor category in inventory
        can_share = false;
        break;
    }

    return can_share;
}

// static
bool LLAvatarActions::toggleBlock(const LLUUID& id)
{
    LLAvatarName av_name;
    LLAvatarNameCache::get(id, &av_name);

    LLMute mute(id, av_name.getUserName(), LLMute::AGENT);

    if (LLMuteList::getInstance()->isMuted(mute.mID, mute.mName))
    {
        LLMuteList::getInstance()->remove(mute);
        return false;
    }
    else
    {
        LLMuteList::getInstance()->add(mute);
        return true;
    }
}

// static
void LLAvatarActions::toggleMute(const LLUUID& id, U32 flags)
{
    LLAvatarName av_name;
    LLAvatarNameCache::get(id, &av_name);

    LLMuteList* mute_list = LLMuteList::getInstance();
    bool is_muted = mute_list->isMuted(id, flags);

    LLMute mute(id, av_name.getUserName(), LLMute::AGENT);
    if (!is_muted)
    {
        mute_list->add(mute, flags);
    }
    else
    {
        mute_list->remove(mute, flags);
    }
}

// static
void LLAvatarActions::toggleMuteVoice(const LLUUID& id)
{
    toggleMute(id, LLMute::flagVoiceChat);
}

// static
bool LLAvatarActions::canOfferTeleport(const LLUUID& id)
{
    // First use LLAvatarTracker::isBuddy()
    // If LLAvatarTracker::instance().isBuddyOnline function only is used
    // then for avatars that are online and not a friend it will return false.
    // But we should give an ability to offer a teleport for such avatars.
    if(LLAvatarTracker::instance().isBuddy(id))
    {
        return LLAvatarTracker::instance().isBuddyOnline(id);
    }

    return true;
}

// static
bool LLAvatarActions::canOfferTeleport(const uuid_vec_t& ids)
{
    // We can't send more than 250 lures in a single message, so disable this
    // button when there are too many id's selected.
    if(ids.size() > 250) return false;

    bool result = true;
    for (uuid_vec_t::const_iterator it = ids.begin(); it != ids.end(); ++it)
    {
        if(!canOfferTeleport(*it))
        {
            result = false;
            break;
        }
    }
    return result;
}

void LLAvatarActions::inviteToGroup(const LLUUID& id)
{
    LLFloaterGroupPicker* widget = LLFloaterReg::showTypedInstance<LLFloaterGroupPicker>("group_picker", LLSD(id));
    if (widget)
    {
        widget->center();
        widget->setPowersMask(GP_MEMBER_INVITE);
        widget->removeNoneOption();
        widget->setSelectGroupCallback(boost::bind(callback_invite_to_group, _1, id));
    }
}

// static
void LLAvatarActions::viewChatHistory(const LLUUID& id)
{
    const std::vector<LLConversation>& conversations = LLConversationLog::instance().getConversations();
    std::vector<LLConversation>::const_iterator iter = conversations.begin();

    for (; iter != conversations.end(); ++iter)
    {
        if (iter->getParticipantID() == id)
        {
            LLFloaterReg::showInstance("preview_conversation", iter->getSessionID(), true);
            return;
        }
    }

    if (LLLogChat::isTranscriptExist(id))
    {
        LLAvatarName avatar_name;
        LLSD extended_id(id);

        LLAvatarNameCache::get(id, &avatar_name);
        extended_id[LL_FCP_COMPLETE_NAME] = avatar_name.getCompleteName();
        extended_id[LL_FCP_ACCOUNT_NAME] = avatar_name.getAccountName();
        LLFloaterReg::showInstance("preview_conversation", extended_id, true);
    }
}

//== private methods ========================================================================================

// static
bool LLAvatarActions::handleRemove(const LLSD& notification, const LLSD& response)
{
    S32 option = LLNotificationsUtil::getSelectedOption(notification, response);

    const LLSD& ids = notification["payload"]["ids"];
    for (LLSD::array_const_iterator itr = ids.beginArray(); itr != ids.endArray(); ++itr)
    {
        LLUUID id = itr->asUUID();
        const LLRelationship* ip = LLAvatarTracker::instance().getBuddyInfo(id);
        if (ip)
        {
            switch (option)
            {
            case 0: // YES
                if( ip->isRightGrantedTo(LLRelationship::GRANT_MODIFY_OBJECTS))
                {
                    LLAvatarTracker::instance().empower(id, FALSE);
                    LLAvatarTracker::instance().notifyObservers();
                }
                LLAvatarTracker::instance().terminateBuddy(id);
                LLAvatarTracker::instance().notifyObservers();
                break;

            case 1: // NO
            default:
                LL_INFOS() << "No removal performed." << LL_ENDL;
                break;
            }
        }
    }
    return false;
}

// static
bool LLAvatarActions::handlePay(const LLSD& notification, const LLSD& response, LLUUID avatar_id)
{
    S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
    if (option == 0)
    {
        gAgent.setDoNotDisturb(false);
    }

    LLFloaterPayUtil::payDirectly(&give_money, avatar_id, /*is_group=*/false);
    return false;
}

// static
void LLAvatarActions::callback_invite_to_group(LLUUID group_id, LLUUID id)
{
    uuid_vec_t agent_ids;
    agent_ids.push_back(id);

    LLFloaterGroupInvite::showForGroup(group_id, &agent_ids);
}


// static
bool LLAvatarActions::callbackAddFriendWithMessage(const LLSD& notification, const LLSD& response)
{
    S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
    if (option == 0)
    {
        requestFriendship(notification["payload"]["id"].asUUID(),
            notification["payload"]["name"].asString(),
            response["message"].asString());
    }
    return false;
}

// static
bool LLAvatarActions::handleKick(const LLSD& notification, const LLSD& response)
{
    S32 option = LLNotification::getSelectedOption(notification, response);

    if (option == 0)
    {
        LLUUID avatar_id = notification["payload"]["avatar_id"].asUUID();
        LLMessageSystem* msg = gMessageSystem;

        msg->newMessageFast(_PREHASH_GodKickUser);
        msg->nextBlockFast(_PREHASH_UserInfo);
        msg->addUUIDFast(_PREHASH_GodID,        gAgent.getID() );
        msg->addUUIDFast(_PREHASH_GodSessionID, gAgent.getSessionID());
        msg->addUUIDFast(_PREHASH_AgentID,   avatar_id );
        msg->addU32("KickFlags", KICK_FLAGS_DEFAULT );
        msg->addStringFast(_PREHASH_Reason,    response["message"].asString() );
        gAgent.sendReliableMessage();
    }
    return false;
}

bool LLAvatarActions::handleFreezeAvatar(const LLSD& notification, const LLSD& response)
{
    S32 option = LLNotification::getSelectedOption(notification, response);

    if (0 == option || 1 == option)
    {
        U32 flags = 0x0;
        if (1 == option)
        {
            // unfreeze
            flags |= 0x1;
        }
        LLUUID avatar_id = notification["payload"]["avatar_id"].asUUID();
        LLMessageSystem* msg = gMessageSystem;

        msg->newMessage("FreezeUser");
        msg->nextBlock("AgentData");
        msg->addUUID("AgentID", gAgent.getID());
        msg->addUUID("SessionID", gAgent.getSessionID());
        msg->nextBlock("Data");
        msg->addUUID("TargetID", avatar_id );
        msg->addU32("Flags", flags );
        gAgent.sendReliableMessage();
    }
    return false;
}

bool LLAvatarActions::handleEjectAvatar(const LLSD& notification, const LLSD& response)
{
    S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
    if (2 == option)
    {
        return false;
    }
    LLUUID avatar_id = notification["payload"]["avatar_id"].asUUID();
    bool ban_enabled = notification["payload"]["ban_enabled"].asBoolean();

    if (0 == option)
    {
        LLMessageSystem* msg = gMessageSystem;
        U32 flags = 0x0;
        msg->newMessage("EjectUser");
        msg->nextBlock("AgentData");
        msg->addUUID("AgentID", gAgent.getID() );
        msg->addUUID("SessionID", gAgent.getSessionID() );
        msg->nextBlock("Data");
        msg->addUUID("TargetID", avatar_id );
        msg->addU32("Flags", flags );
        gAgent.sendReliableMessage();
    }
    else if (ban_enabled)
    {
        LLMessageSystem* msg = gMessageSystem;

        U32 flags = 0x1;
        msg->newMessage("EjectUser");
        msg->nextBlock("AgentData");
        msg->addUUID("AgentID", gAgent.getID() );
        msg->addUUID("SessionID", gAgent.getSessionID() );
        msg->nextBlock("Data");
        msg->addUUID("TargetID", avatar_id );
        msg->addU32("Flags", flags );
        gAgent.sendReliableMessage();
    }
    return false;
}

bool LLAvatarActions::handleFreeze(const LLSD& notification, const LLSD& response)
{
    S32 option = LLNotification::getSelectedOption(notification, response);
    if (option == 0)
    {
        LLUUID avatar_id = notification["payload"]["avatar_id"].asUUID();
        LLMessageSystem* msg = gMessageSystem;

        msg->newMessageFast(_PREHASH_GodKickUser);
        msg->nextBlockFast(_PREHASH_UserInfo);
        msg->addUUIDFast(_PREHASH_GodID,        gAgent.getID() );
        msg->addUUIDFast(_PREHASH_GodSessionID, gAgent.getSessionID());
        msg->addUUIDFast(_PREHASH_AgentID,   avatar_id );
        msg->addU32("KickFlags", KICK_FLAGS_FREEZE );
        msg->addStringFast(_PREHASH_Reason, response["message"].asString() );
        gAgent.sendReliableMessage();
    }
    return false;
}

bool LLAvatarActions::handleUnfreeze(const LLSD& notification, const LLSD& response)
{
    S32 option = LLNotification::getSelectedOption(notification, response);
    std::string text = response["message"].asString();
    if (option == 0)
    {
        LLUUID avatar_id = notification["payload"]["avatar_id"].asUUID();
        LLMessageSystem* msg = gMessageSystem;

        msg->newMessageFast(_PREHASH_GodKickUser);
        msg->nextBlockFast(_PREHASH_UserInfo);
        msg->addUUIDFast(_PREHASH_GodID,        gAgent.getID() );
        msg->addUUIDFast(_PREHASH_GodSessionID, gAgent.getSessionID());
        msg->addUUIDFast(_PREHASH_AgentID,   avatar_id );
        msg->addU32("KickFlags", KICK_FLAGS_UNFREEZE );
        msg->addStringFast(_PREHASH_Reason,    text );
        gAgent.sendReliableMessage();
    }
    return false;
}

// static
void LLAvatarActions::requestFriendship(const LLUUID& target_id, const std::string& target_name, const std::string& message)
{
    const LLUUID calling_card_folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_CALLINGCARD);
    LLUIUsage::instance().logCommand("Agent.SendFriendRequest");

    send_improved_im(target_id,
                     target_name,
                     message,
                     IM_ONLINE,
                     IM_FRIENDSHIP_OFFERED,
                     calling_card_folder_id);

    LLSD args;
    args["TO_NAME"] = target_name;

    LLSD payload;
    payload["from_id"] = target_id;
    LLNotificationsUtil::add("FriendshipOffered", args, payload);
}

//static
bool LLAvatarActions::isFriend(const LLUUID& id)
{
    return ( NULL != LLAvatarTracker::instance().getBuddyInfo(id) );
}

// static
bool LLAvatarActions::isBlocked(const LLUUID& id)
{
    LLAvatarName av_name;
    LLAvatarNameCache::get(id, &av_name);
    return LLMuteList::getInstance()->isMuted(id, av_name.getUserName());
}

// static
bool LLAvatarActions::isVoiceMuted(const LLUUID& id)
{
    return LLMuteList::getInstance()->isMuted(id, LLMute::flagVoiceChat);
}

// static
bool LLAvatarActions::canBlock(const LLUUID& id)
{
    LLAvatarName av_name;
    LLAvatarNameCache::get(id, &av_name);

    std::string full_name = av_name.getUserName();
    bool is_linden = (full_name.find("Linden") != std::string::npos);
    bool is_self = id == gAgentID;
    return !is_self && !is_linden;
}