/**
* @file llpanelgroupbulk.cpp
* @brief Implementation of llpanelgroupbulk
* @author Baker@lindenlab.com
*
* $LicenseInfo:firstyear=2013&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2013, 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 "llpanelgroupbulk.h"
#include "llpanelgroupbulkimpl.h"

#include "llagent.h"
#include "llavatarnamecache.h"
#include "llfloateravatarpicker.h"
#include "llbutton.h"
#include "llcallingcard.h"
#include "llcombobox.h"
#include "llgroupactions.h"
#include "llgroupmgr.h"
#include "llnamelistctrl.h"
#include "llnotificationsutil.h"
#include "llscrolllistitem.h"
#include "llspinctrl.h"
#include "lltextbox.h"
#include "llviewerobject.h"
#include "llviewerobjectlist.h"
#include "lluictrlfactory.h"
#include "llviewerwindow.h"


//////////////////////////////////////////////////////////////////////////
// Implementation of llpanelgroupbulkimpl.h functions
//////////////////////////////////////////////////////////////////////////
LLPanelGroupBulkImpl::LLPanelGroupBulkImpl(const LLUUID& group_id) :
    mGroupID(group_id),
    mBulkAgentList(NULL),
    mOKButton(NULL),
    mRemoveButton(NULL),
    mGroupName(NULL),
    mLoadingText(),
    mTooManySelected(),
    mCloseCallback(NULL),
    mCloseCallbackUserData(NULL),
    mAvatarNameCacheConnection(),
    mRoleNames(NULL),
    mOwnerWarning(),
    mAlreadyInGroup(),
    mConfirmedOwnerInvite(false),
    mListFullNotificationSent(false)
{}

LLPanelGroupBulkImpl::~LLPanelGroupBulkImpl()
{
    if(mAvatarNameCacheConnection.connected())
    {
        mAvatarNameCacheConnection.disconnect();
    }
}

void LLPanelGroupBulkImpl::callbackClickAdd(void* userdata)
{
    LLPanelGroupBulk* panelp = (LLPanelGroupBulk*)userdata;

    if(panelp)
    {
        //Right now this is hard coded with some knowledge that it is part
        //of a floater since the avatar picker needs to be added as a dependent
        //floater to the parent floater.
        //Soon the avatar picker will be embedded into this panel
        //instead of being it's own separate floater.  But that is next week.
        //This will do for now. -jwolk May 10, 2006
        LLView* button = panelp->findChild<LLButton>("add_button");
        LLFloater* root_floater = gFloaterView->getParentFloater(panelp);
        LLFloaterAvatarPicker* picker = LLFloaterAvatarPicker::show(
            boost::bind(callbackAddUsers, _1, panelp->mImplementation), true, false, false, root_floater->getName(), button);
        if(picker)
        {
            root_floater->addDependentFloater(picker);
            LLGroupMgr::getInstance()->sendCapGroupMembersRequest(panelp->mImplementation->mGroupID);
        }
    }
}

void LLPanelGroupBulkImpl::callbackClickRemove(void* userdata)
{
    LLPanelGroupBulkImpl* selfp = (LLPanelGroupBulkImpl*)userdata;
    if (selfp)
        selfp->handleRemove();
}

void LLPanelGroupBulkImpl::callbackClickCancel(void* userdata)
{
    LLPanelGroupBulkImpl* selfp = (LLPanelGroupBulkImpl*)userdata;
    if(selfp)
        (*(selfp->mCloseCallback))(selfp->mCloseCallbackUserData);
}

void LLPanelGroupBulkImpl::callbackSelect(LLUICtrl* ctrl, void* userdata)
{
    LLPanelGroupBulkImpl* selfp = (LLPanelGroupBulkImpl*)userdata;
    if (selfp)
        selfp->handleSelection();
}

void LLPanelGroupBulkImpl::callbackAddUsers(const uuid_vec_t& agent_ids, void* user_data)
{
    std::vector<std::string> names;
    for (S32 i = 0; i < (S32)agent_ids.size(); i++)
    {
        LLAvatarName av_name;
        if (LLAvatarNameCache::get(agent_ids[i], &av_name))
        {
            onAvatarNameCache(agent_ids[i], av_name, user_data);
        }
        else
        {
            LLPanelGroupBulkImpl* selfp = (LLPanelGroupBulkImpl*) user_data;
            if (selfp)
            {
                if (selfp->mAvatarNameCacheConnection.connected())
                {
                    selfp->mAvatarNameCacheConnection.disconnect();
                }
                // *TODO : Add a callback per avatar name being fetched.
                selfp->mAvatarNameCacheConnection = LLAvatarNameCache::get(agent_ids[i],boost::bind(onAvatarNameCache, _1, _2, user_data));
            }
        }
    }
}

void LLPanelGroupBulkImpl::onAvatarNameCache(const LLUUID& agent_id, const LLAvatarName& av_name, void* user_data)
{
    LLPanelGroupBulkImpl* selfp = (LLPanelGroupBulkImpl*) user_data;

    if (selfp)
    {
        if (selfp->mAvatarNameCacheConnection.connected())
        {
            selfp->mAvatarNameCacheConnection.disconnect();
        }
        std::vector<std::string> names;
        uuid_vec_t agent_ids;
        agent_ids.push_back(agent_id);
        names.push_back(av_name.getCompleteName());

        selfp->addUsers(names, agent_ids);
    }
}

void LLPanelGroupBulkImpl::handleRemove()
{
    std::vector<LLScrollListItem*> selection = mBulkAgentList->getAllSelected();
    if (selection.empty())
        return;

    std::vector<LLScrollListItem*>::iterator iter;
    for(iter = selection.begin(); iter != selection.end(); ++iter)
    {
        mInviteeIDs.erase((*iter)->getUUID());
    }

    mBulkAgentList->deleteSelectedItems();
    mRemoveButton->setEnabled(false);

    if( mOKButton && mOKButton->getEnabled() &&
        mBulkAgentList->isEmpty())
    {
        mOKButton->setEnabled(false);
    }
}

void LLPanelGroupBulkImpl::handleSelection()
{
    std::vector<LLScrollListItem*> selection = mBulkAgentList->getAllSelected();
    if (selection.empty())
        mRemoveButton->setEnabled(false);
    else
        mRemoveButton->setEnabled(true);
}

void LLPanelGroupBulkImpl::addUsers(const std::vector<std::string>& names, const uuid_vec_t& agent_ids)
{
    std::string name;
    LLUUID id;

    if(mListFullNotificationSent)
    {
        return;
    }

    if( !mListFullNotificationSent &&
        (names.size() + mInviteeIDs.size() > MAX_GROUP_INVITES))
    {
        mListFullNotificationSent = true;

        // Fail! Show a warning and don't add any names.
        LLSD msg;
        msg["MESSAGE"] = mTooManySelected;
        LLNotificationsUtil::add("GenericAlert", msg);
        return;
    }

    for (S32 i = 0; i < (S32)names.size(); ++i)
    {
        name = names[i];
        id = agent_ids[i];

        if(mInviteeIDs.find(id) != mInviteeIDs.end())
        {
            continue;
        }

        //add the name to the names list
        LLSD row;
        row["id"] = id;
        row["columns"][0]["value"] = name;

        mBulkAgentList->addElement(row);
        mInviteeIDs.insert(id);

        // We've successfully added someone to the list.
        if(mOKButton && !mOKButton->getEnabled())
            mOKButton->setEnabled(true);
    }
}

void LLPanelGroupBulkImpl::setGroupName(std::string name)
{
    if(mGroupName)
        mGroupName->setText(name);
}


LLPanelGroupBulk::LLPanelGroupBulk(const LLUUID& group_id) :
    LLPanel(),
    mImplementation(new LLPanelGroupBulkImpl(group_id)),
    mPendingGroupPropertiesUpdate(false),
    mPendingRoleDataUpdate(false),
    mPendingMemberDataUpdate(false)
{}

LLPanelGroupBulk::~LLPanelGroupBulk()
{
    delete mImplementation;
}

void LLPanelGroupBulk::clear()
{
    mImplementation->mInviteeIDs.clear();

    if(mImplementation->mBulkAgentList)
        mImplementation->mBulkAgentList->deleteAllItems();

    if(mImplementation->mOKButton)
        mImplementation->mOKButton->setEnabled(false);
}

void LLPanelGroupBulk::update()
{
    updateGroupName();
    updateGroupData();
}

void LLPanelGroupBulk::draw()
{
    LLPanel::draw();
    update();
}

void LLPanelGroupBulk::updateGroupName()
{
    LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mImplementation->mGroupID);

    if( gdatap &&
        gdatap->isGroupPropertiesDataComplete())
    {
        // Only do work if the current group name differs
        if(mImplementation->mGroupName->getText().compare(gdatap->mName) != 0)
            mImplementation->setGroupName(gdatap->mName);
    }
    else
    {
        mImplementation->setGroupName(mImplementation->mLoadingText);
    }
}

void LLPanelGroupBulk::updateGroupData()
{
    LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mImplementation->mGroupID);
    if(gdatap && gdatap->isGroupPropertiesDataComplete())
    {
        mPendingGroupPropertiesUpdate = false;
    }
    else
    {
        if(!mPendingGroupPropertiesUpdate)
        {
            mPendingGroupPropertiesUpdate = true;
            LLGroupMgr::getInstance()->sendGroupPropertiesRequest(mImplementation->mGroupID);
        }
    }

    if(gdatap && gdatap->isRoleDataComplete())
    {
        mPendingRoleDataUpdate = false;
    }
    else
    {
        if(!mPendingRoleDataUpdate)
        {
            mPendingRoleDataUpdate = true;
            LLGroupMgr::getInstance()->sendGroupRoleDataRequest(mImplementation->mGroupID);
        }
    }

    if(gdatap && gdatap->isMemberDataComplete())
    {
        mPendingMemberDataUpdate = false;
    }
    else
    {
        if(!mPendingMemberDataUpdate)
        {
            mPendingMemberDataUpdate = true;
            LLGroupMgr::getInstance()->sendCapGroupMembersRequest(mImplementation->mGroupID);
        }
    }
}

void LLPanelGroupBulk::addUserCallback(const LLUUID& id, const LLAvatarName& av_name)
{
    std::vector<std::string> names;
    uuid_vec_t agent_ids;
    agent_ids.push_back(id);
    names.push_back(av_name.getAccountName());

    mImplementation->addUsers(names, agent_ids);
}

void LLPanelGroupBulk::setCloseCallback(void (*close_callback)(void*), void* data)
{
    mImplementation->mCloseCallback         = close_callback;
    mImplementation->mCloseCallbackUserData = data;
}

void LLPanelGroupBulk::addUsers(uuid_vec_t& agent_ids)
{
    std::vector<std::string> names;
    for (S32 i = 0; i < (S32)agent_ids.size(); i++)
    {
        std::string fullname;
        LLUUID agent_id = agent_ids[i];
        LLViewerObject* dest = gObjectList.findObject(agent_id);
        if(dest && dest->isAvatar())
        {
            LLNameValue* nvfirst = dest->getNVPair("FirstName");
            LLNameValue* nvlast = dest->getNVPair("LastName");
            if(nvfirst && nvlast)
            {
                fullname = LLCacheName::buildFullName(
                    nvfirst->getString(), nvlast->getString());

            }
            if (!fullname.empty())
            {
                names.push_back(fullname);
            }
            else
            {
                LL_WARNS() << "llPanelGroupBulk: Selected avatar has no name: " << dest->getID() << LL_ENDL;
                names.push_back("(Unknown)");
            }
        }
        else
        {
            //looks like user try to invite offline friend
            //for offline avatar_id gObjectList.findObject() will return null
            //so we need to do this additional search in avatar tracker, see EXT-4732
            if (LLAvatarTracker::instance().isBuddy(agent_id))
            {
                LLAvatarName av_name;
                if (!LLAvatarNameCache::get(agent_id, &av_name))
                {
                    // actually it should happen, just in case
                    LLAvatarNameCache::get(LLUUID(agent_id), boost::bind(&LLPanelGroupBulk::addUserCallback, this, _1, _2));
                    // for this special case!
                    //when there is no cached name we should remove resident from agent_ids list to avoid breaking of sequence
                    // removed id will be added in callback
                    agent_ids.erase(agent_ids.begin() + i);
                }
                else
                {
                    names.push_back(av_name.getAccountName());
                }
            }
        }
    }
    mImplementation->mListFullNotificationSent = false;
    mImplementation->addUsers(names, agent_ids);
}