/**
 * @file llgesturemgr.cpp
 * @brief Manager for playing gestures on the viewer
 *
 * $LicenseInfo:firstyear=2004&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 "llgesturemgr.h"

// system
#include <functional>
#include <algorithm>

// library
#include "llaudioengine.h"
#include "lldatapacker.h"
#include "llfloaterreg.h"
#include "llinventory.h"
#include "llkeyframemotion.h"
#include "llmultigesture.h"
#include "llnotificationsutil.h"
#include "llstl.h"
#include "llstring.h"   // todo: remove
#include "llfilesystem.h"
#include "message.h"

// newview
#include "llagent.h"
#include "lldelayedgestureerror.h"
#include "llinventorymodel.h"
#include "llviewermessage.h"
#include "llvoavatarself.h"
#include "llviewerstats.h"
#include "llfloaterimnearbychat.h"
#include "llappearancemgr.h"
#include "llgesturelistener.h"

// Longest time, in seconds, to wait for all animations to stop playing
const F32 MAX_WAIT_ANIM_SECS = 30.f;
// Longest time, in seconds, to wait for a key release.
// This should be relatively long, but not too long. 10 minutes is enough
const F32 MAX_WAIT_KEY_SECS = 60.f * 10.f;

// Lightweight constructor.
// init() does the heavy lifting.
LLGestureMgr::LLGestureMgr()
:   mValid(false),
    mPlaying(),
    mActive(),
    mLoadingCount(0)
{
    gInventory.addObserver(this);
    mListener.reset(new LLGestureListener());
}


// We own the data for gestures, so clean them up.
LLGestureMgr::~LLGestureMgr()
{
    item_map_t::iterator it;
    for (it = mActive.begin(); it != mActive.end(); ++it)
    {
        LLMultiGesture* gesture = (*it).second;

        delete gesture;
        gesture = NULL;
    }
    gInventory.removeObserver(this);
}


void LLGestureMgr::init()
{
    // TODO
}

void LLGestureMgr::changed(U32 mask)
{
    LLInventoryFetchItemsObserver::changed(mask);

    if (mask & LLInventoryObserver::GESTURE)
    {
        // If there was a gesture label changed, update all the names in the
        // active gestures and then notify observers
        if (mask & LLInventoryObserver::LABEL)
        {
            for(item_map_t::iterator it = mActive.begin(); it != mActive.end(); ++it)
            {
                if(it->second)
                {
                    LLViewerInventoryItem* item = gInventory.getItem(it->first);
                    if(item)
                    {
                        it->second->mName = item->getName();
                    }
                }
            }
            notifyObservers();
        }
        // If there was a gesture added or removed notify observers
        // STRUCTURE denotes that the inventory item has been moved
        // In the case of deleting gesture, it is moved to the trash
        else if(mask & LLInventoryObserver::ADD ||
                mask & LLInventoryObserver::REMOVE ||
                mask & LLInventoryObserver::STRUCTURE)
        {
            notifyObservers();
        }
    }
}


// Use this version when you have the item_id but not the asset_id,
// and you KNOW the inventory is loaded.
void LLGestureMgr::activateGesture(const LLUUID& item_id)
{
    LLViewerInventoryItem* item = gInventory.getItem(item_id);
    if (!item) return;
    if (item->getType() != LLAssetType::AT_GESTURE)
        return;

    LLUUID asset_id = item->getAssetUUID();

    mLoadingCount = 1;
    mDeactivateSimilarNames.clear();

    const bool inform_server = true;
    const bool deactivate_similar = false;
    activateGestureWithAsset(item_id, asset_id, inform_server, deactivate_similar);
}


void LLGestureMgr::activateGestures(LLViewerInventoryItem::item_array_t& items)
{
    // Load up the assets
    S32 count = 0;
    LLViewerInventoryItem::item_array_t::const_iterator it;
    for (it = items.begin(); it != items.end(); ++it)
    {
        LLViewerInventoryItem* item = *it;

        if (isGestureActive(item->getUUID()))
        {
            continue;
        }
        else
        { // Make gesture active and persistent through login sessions.  -Aura 07-12-06
            activateGesture(item->getUUID());
        }

        count++;
    }

    mLoadingCount = count;
    mDeactivateSimilarNames.clear();

    for (it = items.begin(); it != items.end(); ++it)
    {
        LLViewerInventoryItem* item = *it;

        if (isGestureActive(item->getUUID()))
        {
            continue;
        }

        // Don't inform server, we'll do that in bulk
        const bool no_inform_server = false;
        const bool deactivate_similar = true;
        activateGestureWithAsset(item->getUUID(), item->getAssetUUID(),
                                 no_inform_server,
                                 deactivate_similar);
    }

    // Inform the database of this change
    LLMessageSystem* msg = gMessageSystem;

    bool start_message = true;

    for (it = items.begin(); it != items.end(); ++it)
    {
        LLViewerInventoryItem* item = *it;

        if (isGestureActive(item->getUUID()))
        {
            continue;
        }

        if (start_message)
        {
            msg->newMessage("ActivateGestures");
            msg->nextBlock("AgentData");
            msg->addUUID("AgentID", gAgent.getID());
            msg->addUUID("SessionID", gAgent.getSessionID());
            msg->addU32("Flags", 0x0);
            start_message = false;
        }

        msg->nextBlock("Data");
        msg->addUUID("ItemID", item->getUUID());
        msg->addUUID("AssetID", item->getAssetUUID());
        msg->addU32("GestureFlags", 0x0);

        if (msg->getCurrentSendTotal() > MTUBYTES)
        {
            gAgent.sendReliableMessage();
            start_message = true;
        }
    }

    if (!start_message)
    {
        gAgent.sendReliableMessage();
    }
}


struct LLLoadInfo
{
    LLUUID mItemID;
    bool mInformServer;
    bool mDeactivateSimilar;
};

// If inform_server is true, will send a message upstream to update
// the user_gesture_active table.
/**
 * It will load a gesture from remote storage
 */
void LLGestureMgr::activateGestureWithAsset(const LLUUID& item_id,
                                                const LLUUID& asset_id,
                                                bool inform_server,
                                                bool deactivate_similar)
{
    const LLUUID& base_item_id = gInventory.getLinkedItemID(item_id);

    if( !gAssetStorage )
    {
        LL_WARNS() << "LLGestureMgr::activateGestureWithAsset without valid gAssetStorage" << LL_ENDL;
        return;
    }
    // If gesture is already active, nothing to do.
    if (isGestureActive(item_id))
    {
        LL_WARNS() << "Tried to loadGesture twice " << item_id << LL_ENDL;
        return;
    }

//  if (asset_id.isNull())
//  {
//      LL_WARNS() << "loadGesture() - gesture has no asset" << LL_ENDL;
//      return;
//  }

    // For now, put NULL into the item map.  We'll build a gesture
    // class object when the asset data arrives.
    mActive[base_item_id] = NULL;

    // Copy the UUID
    if (asset_id.notNull())
    {
        LLLoadInfo* info = new LLLoadInfo;
        info->mItemID = base_item_id;
        info->mInformServer = inform_server;
        info->mDeactivateSimilar = deactivate_similar;

        const bool high_priority = true;
        gAssetStorage->getAssetData(asset_id,
                                    LLAssetType::AT_GESTURE,
                                    onLoadComplete,
                                    (void*)info,
                                    high_priority);
    }
    else
    {
        notifyObservers();
    }
}


void notify_update_label(const LLUUID& base_item_id)
{
    gInventory.addChangedMask(LLInventoryObserver::LABEL, base_item_id);
    LLGestureMgr::instance().notifyObservers();
}

void LLGestureMgr::deactivateGesture(const LLUUID& item_id)
{
    const LLUUID& base_item_id = gInventory.getLinkedItemID(item_id);
    item_map_t::iterator it = mActive.find(base_item_id);
    if (it == mActive.end())
    {
        LL_WARNS() << "deactivateGesture for inactive gesture " << item_id << LL_ENDL;
        return;
    }

    // mActive owns this gesture pointer, so clean up memory.
    LLMultiGesture* gesture = (*it).second;

    // Can be NULL gestures in the map
    if (gesture)
    {
        stopGesture(gesture);

        delete gesture;
        gesture = NULL;
    }

    mActive.erase(it);

    // Inform the database of this change
    LLMessageSystem* msg = gMessageSystem;
    msg->newMessage("DeactivateGestures");
    msg->nextBlock("AgentData");
    msg->addUUID("AgentID", gAgent.getID());
    msg->addUUID("SessionID", gAgent.getSessionID());
    msg->addU32("Flags", 0x0);

    msg->nextBlock("Data");
    msg->addUUID("ItemID", item_id);
    msg->addU32("GestureFlags", 0x0);

    gAgent.sendReliableMessage();

    LLPointer<LLInventoryCallback> cb =
        new LLBoostFuncInventoryCallback(no_op_inventory_func,
                                         boost::bind(notify_update_label,base_item_id));

    LLAppearanceMgr::instance().removeCOFItemLinks(base_item_id, cb);
}


void LLGestureMgr::deactivateSimilarGestures(LLMultiGesture* in, const LLUUID& in_item_id)
{
    const LLUUID& base_in_item_id = gInventory.getLinkedItemID(in_item_id);
    uuid_vec_t gest_item_ids;

    // Deactivate all gestures that match
    item_map_t::iterator it;
    for (it = mActive.begin(); it != mActive.end(); )
    {
        const LLUUID& item_id = (*it).first;
        LLMultiGesture* gest = (*it).second;

        // Don't deactivate the gesture we are looking for duplicates of
        // (for replaceGesture)
        if (!gest || item_id == base_in_item_id)
        {
            // legal, can have null pointers in list
            ++it;
        }
        else if ((!gest->mTrigger.empty() && gest->mTrigger == in->mTrigger)
                 || (gest->mKey != KEY_NONE && gest->mKey == in->mKey && gest->mMask == in->mMask))
        {
            gest_item_ids.push_back(item_id);

            stopGesture(gest);

            delete gest;
            gest = NULL;

            mActive.erase(it++);
            gInventory.addChangedMask(LLInventoryObserver::LABEL, item_id);

        }
        else
        {
            ++it;
        }
    }

    // Inform database of the change
    LLMessageSystem* msg = gMessageSystem;
    bool start_message = true;
    uuid_vec_t::const_iterator vit = gest_item_ids.begin();
    while (vit != gest_item_ids.end())
    {
        if (start_message)
        {
            msg->newMessage("DeactivateGestures");
            msg->nextBlock("AgentData");
            msg->addUUID("AgentID", gAgent.getID());
            msg->addUUID("SessionID", gAgent.getSessionID());
            msg->addU32("Flags", 0x0);
            start_message = false;
        }

        msg->nextBlock("Data");
        msg->addUUID("ItemID", *vit);
        msg->addU32("GestureFlags", 0x0);

        if (msg->getCurrentSendTotal() > MTUBYTES)
        {
            gAgent.sendReliableMessage();
            start_message = true;
        }

        ++vit;
    }

    if (!start_message)
    {
        gAgent.sendReliableMessage();
    }

    // Add to the list of names for the user.
    for (vit = gest_item_ids.begin(); vit != gest_item_ids.end(); ++vit)
    {
        LLViewerInventoryItem* item = gInventory.getItem(*vit);
        if (!item) continue;

        mDeactivateSimilarNames.append(item->getName());
        mDeactivateSimilarNames.append("\n");
    }

    notifyObservers();
}


bool LLGestureMgr::isGestureActive(const LLUUID& item_id)
{
    const LLUUID& base_item_id = gInventory.getLinkedItemID(item_id);
    item_map_t::iterator it = mActive.find(base_item_id);
    return (it != mActive.end());
}


bool LLGestureMgr::isGesturePlaying(const LLUUID& item_id)
{
    const LLUUID& base_item_id = gInventory.getLinkedItemID(item_id);

    item_map_t::iterator it = mActive.find(base_item_id);
    if (it == mActive.end()) return false;

    LLMultiGesture* gesture = (*it).second;
    if (!gesture) return false;

    return gesture->mPlaying;
}

bool LLGestureMgr::isGesturePlaying(LLMultiGesture* gesture)
{
    if(!gesture)
    {
        return false;
    }

    return gesture->mPlaying;
}

void LLGestureMgr::replaceGesture(const LLUUID& item_id, LLMultiGesture* new_gesture, const LLUUID& asset_id)
{
    const LLUUID& base_item_id = gInventory.getLinkedItemID(item_id);

    item_map_t::iterator it = mActive.find(base_item_id);
    if (it == mActive.end())
    {
        LL_WARNS() << "replaceGesture for inactive gesture " << base_item_id << LL_ENDL;
        return;
    }

    LLMultiGesture* old_gesture = (*it).second;
    stopGesture(old_gesture);

    mActive.erase(base_item_id);

    mActive[base_item_id] = new_gesture;

    // replaceGesture(const LLUUID& item_id, const LLUUID& new_asset_id)
    // replaces ids without repalcing gesture
    if (old_gesture != new_gesture)
    {
        delete old_gesture;
        old_gesture = NULL;
    }

    if (asset_id.notNull())
    {
        mLoadingCount = 1;
        mDeactivateSimilarNames.clear();

        LLLoadInfo* info = new LLLoadInfo;
        info->mItemID = base_item_id;
        info->mInformServer = true;
        info->mDeactivateSimilar = false;

        const bool high_priority = true;
        gAssetStorage->getAssetData(asset_id,
                                    LLAssetType::AT_GESTURE,
                                    onLoadComplete,
                                    (void*)info,
                                    high_priority);
    }

    notifyObservers();
}

void LLGestureMgr::replaceGesture(const LLUUID& item_id, const LLUUID& new_asset_id)
{
    const LLUUID& base_item_id = gInventory.getLinkedItemID(item_id);

    item_map_t::iterator it = LLGestureMgr::instance().mActive.find(base_item_id);
    if (it == mActive.end())
    {
        LL_WARNS() << "replaceGesture for inactive gesture " << base_item_id << LL_ENDL;
        return;
    }

    // mActive owns this gesture pointer, so clean up memory.
    LLMultiGesture* gesture = (*it).second;
    LLGestureMgr::instance().replaceGesture(base_item_id, gesture, new_asset_id);
}

void LLGestureMgr::playGesture(LLMultiGesture* gesture, bool fromKeyPress)
{
    if (!gesture) return;

    // Reset gesture to first step
    gesture->reset();
    gesture->mTriggeredByKey = fromKeyPress;

    // Add to list of playing
    gesture->mPlaying = true;
    mPlaying.push_back(gesture);

    // Load all needed assets to minimize the delays
    // when gesture is playing.
    for (std::vector<LLGestureStep*>::iterator steps_it = gesture->mSteps.begin();
         steps_it != gesture->mSteps.end();
         ++steps_it)
    {
        LLGestureStep* step = *steps_it;
        switch(step->getType())
        {
        case STEP_ANIMATION:
            {
                LLGestureStepAnimation* anim_step = (LLGestureStepAnimation*)step;
                const LLUUID& anim_id = anim_step->mAnimAssetID;

                // Don't request the animation if this step stops it or if it is already in the cache
                if (!(anim_id.isNull()
                      || anim_step->mFlags & ANIM_FLAG_STOP
                      || gAssetStorage->hasLocalAsset(anim_id, LLAssetType::AT_ANIMATION)))
                {
                    mLoadingAssets.insert(anim_id);

                    LLUUID* id = new LLUUID(gAgentID);
                    gAssetStorage->getAssetData(anim_id,
                                    LLAssetType::AT_ANIMATION,
                                    onAssetLoadComplete,
                                    (void *)id,
                                    true);
                }
                break;
            }
        case STEP_SOUND:
            {
                LLGestureStepSound* sound_step = (LLGestureStepSound*)step;
                const LLUUID& sound_id = sound_step->mSoundAssetID;
                if (!(sound_id.isNull()
                      || gAssetStorage->hasLocalAsset(sound_id, LLAssetType::AT_SOUND)))
                {
                    mLoadingAssets.insert(sound_id);

                    gAssetStorage->getAssetData(sound_id,
                                    LLAssetType::AT_SOUND,
                                    onAssetLoadComplete,
                                    NULL,
                                    true);
                }
                break;
            }
        case STEP_CHAT:
        case STEP_WAIT:
        case STEP_EOF:
            {
                break;
            }
        default:
            {
                LL_WARNS() << "Unknown gesture step type: " << step->getType() << LL_ENDL;
            }
        }
    }

    // And get it going
    stepGesture(gesture);

    notifyObservers();
}


// Convenience function that looks up the item_id for you.
void LLGestureMgr::playGesture(const LLUUID& item_id)
{
    const LLUUID& base_item_id = gInventory.getLinkedItemID(item_id);

    item_map_t::iterator it = mActive.find(base_item_id);
    if (it == mActive.end()) return;

    LLMultiGesture* gesture = (*it).second;
    if (!gesture) return;

    playGesture(gesture);
}


// Iterates through space delimited tokens in string, triggering any gestures found.
// Generates a revised string that has the found tokens replaced by their replacement strings
// and (as a minor side effect) has multiple spaces in a row replaced by single spaces.
bool LLGestureMgr::triggerAndReviseString(const std::string &utf8str, std::string* revised_string)
{
    std::string tokenized = utf8str;

    bool found_gestures = false;
    bool first_token = true;

    typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
    boost::char_separator<char> sep(" ");
    tokenizer tokens(tokenized, sep);
    tokenizer::iterator token_iter;

    for( token_iter = tokens.begin(); token_iter != tokens.end(); ++token_iter)
    {
        const char* cur_token = token_iter->c_str();
        LLMultiGesture* gesture = NULL;

        // Only pay attention to the first gesture in the string.
        if( !found_gestures )
        {
            // collect gestures that match
            std::vector <LLMultiGesture *> matching;
            item_map_t::iterator it;
            for (it = mActive.begin(); it != mActive.end(); ++it)
            {
                gesture = (*it).second;

                // Gesture asset data might not have arrived yet
                if (!gesture) continue;

                if (LLStringUtil::compareInsensitive(gesture->mTrigger, cur_token) == 0)
                {
                    matching.push_back(gesture);
                }

                gesture = NULL;
            }


            if (matching.size() > 0)
            {
                // choose one at random
                {
                    S32 random = ll_rand(static_cast<S32>(matching.size()));

                    gesture = matching[random];

                    playGesture(gesture);

                    if (!gesture->mReplaceText.empty())
                    {
                        if( !first_token )
                        {
                            if (revised_string)
                                revised_string->append( " " );
                        }

                        // Don't muck with the user's capitalization if we don't have to.
                        if( LLStringUtil::compareInsensitive(cur_token, gesture->mReplaceText) == 0)
                        {
                            if (revised_string)
                                revised_string->append( cur_token );
                        }
                        else
                        {
                            if (revised_string)
                                revised_string->append( gesture->mReplaceText );
                        }
                    }
                    found_gestures = true;
                }
            }
        }

        if(!gesture)
        {
            // This token doesn't match a gesture.  Pass it through to the output.
            if( !first_token )
            {
                if (revised_string)
                    revised_string->append( " " );
            }
            if (revised_string)
                revised_string->append( cur_token );
        }

        first_token = false;
        gesture = NULL;
    }
    return found_gestures;
}


bool LLGestureMgr::triggerGesture(KEY key, MASK mask)
{
    std::vector <LLMultiGesture *> matching;
    item_map_t::iterator it;

    // collect matching gestures
    for (it = mActive.begin(); it != mActive.end(); ++it)
    {
        LLMultiGesture* gesture = (*it).second;

        // asset data might not have arrived yet
        if (!gesture) continue;

        if (gesture->mKey == key
            && gesture->mMask == mask
            && gesture->mWaitingKeyRelease == false)
        {
            matching.push_back(gesture);
        }
    }

    // choose one and play it
    if (matching.size() > 0)
    {
        U32 random = ll_rand(static_cast<S32>(matching.size()));

        LLMultiGesture* gesture = matching[random];

        playGesture(gesture, true);
        return true;
    }
    return false;
}


bool LLGestureMgr::triggerGestureRelease(KEY key, MASK mask)
{
    std::vector <LLMultiGesture *> matching;
    item_map_t::iterator it;

    // collect matching gestures
    for (it = mActive.begin(); it != mActive.end(); ++it)
    {
        LLMultiGesture* gesture = (*it).second;

        // asset data might not have arrived yet
        if (!gesture) continue;

        if (gesture->mKey == key
            && gesture->mMask == mask)
        {
            gesture->mKeyReleased = true;
        }
    }

    //If we found one, block. Otherwise tell them it's free to go.
    return matching.size() > 0;
}


S32 LLGestureMgr::getPlayingCount() const
{
    return static_cast<S32>(mPlaying.size());
}


struct IsGesturePlaying
{
    bool operator()(const LLMultiGesture* gesture) const
    {
        return bool(gesture->mPlaying);
    }
};

void LLGestureMgr::update()
{
    S32 i;
    for (i = 0; i < (S32)mPlaying.size(); ++i)
    {
        stepGesture(mPlaying[i]);
    }

    // Clear out gestures that are done, by moving all the
    // ones that are still playing to the front.
    std::vector<LLMultiGesture*>::iterator new_end;
    new_end = std::partition(mPlaying.begin(),
                             mPlaying.end(),
                             IsGesturePlaying());

    // Something finished playing
    if (new_end != mPlaying.end())
    {
        // Delete the completed gestures that want deletion
        std::vector<LLMultiGesture*>::iterator it;
        for (it = new_end; it != mPlaying.end(); ++it)
        {
            LLMultiGesture* gesture = *it;

            if (gesture->mDoneCallback)
            {
                gesture->mDoneCallback(gesture, gesture->mCallbackData);

                // callback might have deleted gesture, can't
                // rely on this pointer any more
                gesture = NULL;
            }
        }

        // And take done gestures out of the playing list
        mPlaying.erase(new_end, mPlaying.end());

        notifyObservers();
    }
}


// Run all steps until you're either done or hit a wait.
void LLGestureMgr::stepGesture(LLMultiGesture* gesture)
{
    if (!gesture)
    {
        return;
    }
    if (!isAgentAvatarValid() || hasLoadingAssets(gesture)) return;

    // Of the ones that started playing, have any stopped?

    std::set<LLUUID>::iterator gest_it;
    for (gest_it = gesture->mPlayingAnimIDs.begin();
         gest_it != gesture->mPlayingAnimIDs.end();
         )
    {
        // look in signaled animations (simulator's view of what is
        // currently playing.
        LLVOAvatar::AnimIterator play_it = gAgentAvatarp->mSignaledAnimations.find(*gest_it);
        if (play_it != gAgentAvatarp->mSignaledAnimations.end())
        {
            ++gest_it;
        }
        else
        {
            // not found, so not currently playing or scheduled to play
            // delete from the triggered set
            gesture->mPlayingAnimIDs.erase(gest_it++);
        }
    }

    // Of all the animations that we asked the sim to start for us,
    // pick up the ones that have actually started.
    for (gest_it = gesture->mRequestedAnimIDs.begin();
         gest_it != gesture->mRequestedAnimIDs.end();
         )
    {
     LLVOAvatar::AnimIterator play_it = gAgentAvatarp->mSignaledAnimations.find(*gest_it);
        if (play_it != gAgentAvatarp->mSignaledAnimations.end())
        {
            // Hooray, this animation has started playing!
            // Copy into playing.
            gesture->mPlayingAnimIDs.insert(*gest_it);
            gesture->mRequestedAnimIDs.erase(gest_it++);
        }
        else
        {
            // nope, not playing yet
            ++gest_it;
        }
    }

    // Run the current steps
    bool waiting = false;
    while (!waiting && gesture->mPlaying)
    {
        // Get the current step, if there is one.
        // Otherwise enter the waiting at end state.
        LLGestureStep* step = NULL;
        if (gesture->mCurrentStep < (S32)gesture->mSteps.size())
        {
            step = gesture->mSteps[gesture->mCurrentStep];
            llassert(step != NULL);
        }
        else
        {
            // step stays null, we're off the end
            gesture->mWaitingAtEnd = true;
        }


        // If we're waiting at the end, wait for all gestures to stop
        // playing.
        // TODO: Wait for all sounds to complete as well.
        if (gesture->mWaitingAtEnd)
        {
            // Neither do we have any pending requests, nor are they
            // still playing.
            if ((gesture->mRequestedAnimIDs.empty()
                && gesture->mPlayingAnimIDs.empty()))
            {
                // all animations are done playing
                gesture->mWaitingAtEnd = false;
                gesture->mPlaying = false;
            }
            else
            {
                waiting = true;
            }
            continue;
        }

        // If we're waiting a fixed amount of time, check for timer
        // expiration.
        if (gesture->mWaitingKeyRelease)
        {
            // We're waiting for a certain amount of time to pass
            if (gesture->mKeyReleased)
            {
                // wait is done, continue execution
                gesture->mWaitingKeyRelease = false;
                gesture->mCurrentStep++;
            }
            else if (gesture->mWaitTimer.getElapsedTimeF32() > MAX_WAIT_KEY_SECS)
            {
                LL_INFOS("GestureMgr") << "Waited too long for key release, continuing gesture."
                    << LL_ENDL;
                gesture->mWaitingKeyRelease = false;
                gesture->mCurrentStep++;
            }
            else
            {
                // we're waiting, so execution is done for now
                waiting = true;
            }
            continue;
        }

        // If we're waiting on our animations to stop, poll for
        // completion.
        if (gesture->mWaitingAnimations)
        {
            // Neither do we have any pending requests, nor are they
            // still playing.
            if ((gesture->mRequestedAnimIDs.empty()
                && gesture->mPlayingAnimIDs.empty()))
            {
                // all animations are done playing
                gesture->mWaitingAnimations = false;
                gesture->mCurrentStep++;
            }
            else if (gesture->mWaitTimer.getElapsedTimeF32() > MAX_WAIT_ANIM_SECS)
            {
                // we've waited too long for an animation
                LL_INFOS("GestureMgr") << "Waited too long for animations to stop, continuing gesture."
                    << LL_ENDL;
                gesture->mWaitingAnimations = false;
                gesture->mCurrentStep++;
            }
            else
            {
                waiting = true;
            }
            continue;
        }

        // If we're waiting a fixed amount of time, check for timer
        // expiration.
        if (gesture->mWaitingTimer)
        {
            // We're waiting for a certain amount of time to pass
            LLGestureStepWait* wait_step = (LLGestureStepWait*)step;

            F32 elapsed = gesture->mWaitTimer.getElapsedTimeF32();
            if (elapsed > wait_step->mWaitSeconds)
            {
                // wait is done, continue execution
                gesture->mWaitingTimer = false;
                gesture->mCurrentStep++;
            }
            else
            {
                // we're waiting, so execution is done for now
                waiting = true;
            }
            continue;
        }

        // Not waiting, do normal execution
        runStep(gesture, step);
    }
}


void LLGestureMgr::runStep(LLMultiGesture* gesture, LLGestureStep* step)
{
    switch(step->getType())
    {
    case STEP_ANIMATION:
        {
            LLGestureStepAnimation* anim_step = (LLGestureStepAnimation*)step;
            if (anim_step->mAnimAssetID.isNull())
            {
                gesture->mCurrentStep++;
            }

            if (anim_step->mFlags & ANIM_FLAG_STOP)
            {
                gAgent.sendAnimationRequest(anim_step->mAnimAssetID, ANIM_REQUEST_STOP);
                // remove it from our request set in case we just requested it
                std::set<LLUUID>::iterator set_it = gesture->mRequestedAnimIDs.find(anim_step->mAnimAssetID);
                if (set_it != gesture->mRequestedAnimIDs.end())
                {
                    gesture->mRequestedAnimIDs.erase(set_it);
                }
            }
            else
            {
                gAgent.sendAnimationRequest(anim_step->mAnimAssetID, ANIM_REQUEST_START);
                // Indicate that we've requested this animation to play as
                // part of this gesture (but it won't start playing for at
                // least one round-trip to simulator).
                gesture->mRequestedAnimIDs.insert(anim_step->mAnimAssetID);
            }
            gesture->mCurrentStep++;
            break;
        }
    case STEP_SOUND:
        {
            LLGestureStepSound* sound_step = (LLGestureStepSound*)step;
            const LLUUID& sound_id = sound_step->mSoundAssetID;
            const F32 volume = 1.f;
            send_sound_trigger(sound_id, volume);
            gesture->mCurrentStep++;
            break;
        }
    case STEP_CHAT:
        {
            LLGestureStepChat* chat_step = (LLGestureStepChat*)step;
            std::string chat_text = chat_step->mChatText;
            // Don't animate the nodding, as this might not blend with
            // other playing animations.

            const bool animate = false;

            (LLFloaterReg::getTypedInstance<LLFloaterIMNearbyChat>("nearby_chat"))->
                    sendChatFromViewer(chat_text, CHAT_TYPE_NORMAL, animate);

            gesture->mCurrentStep++;
            break;
        }
    case STEP_WAIT:
        {
            LLGestureStepWait* wait_step = (LLGestureStepWait*)step;
            if (gesture->mTriggeredByKey // Only wait here IF we were triggered by a key!
                && gesture->mWaitingKeyRelease == false // We can only do this once! Prevent gestures infinitely running
                && wait_step->mFlags & WAIT_FLAG_KEY_RELEASE)
            {
                // Lets wait for the key release first so we don't hold up re-presses
                gesture->mWaitingKeyRelease = true;
                gesture->mKeyReleased = false;
                // Use the wait timer as a deadlock breaker for key release waits.
                gesture->mWaitTimer.reset();
            }
            else if (wait_step->mFlags & WAIT_FLAG_TIME)
            {
                gesture->mWaitingTimer = true;
                gesture->mWaitTimer.reset();
            }
            else if (wait_step->mFlags & WAIT_FLAG_ALL_ANIM)
            {
                gesture->mWaitingAnimations = true;
                // Use the wait timer as a deadlock breaker for animation waits.
                gesture->mWaitTimer.reset();
            }
            else
            {
                gesture->mCurrentStep++;
            }
            // Don't increment instruction pointer until wait is complete.
            break;
        }
    default:
        {
            break;
        }
    }
}


// static
void LLGestureMgr::onLoadComplete(const LLUUID& asset_uuid,
                                  LLAssetType::EType type,
                                  void* user_data, S32 status, LLExtStat ext_status)
{
    LLLoadInfo* info = (LLLoadInfo*)user_data;

    LLUUID item_id = info->mItemID;
    bool inform_server = info->mInformServer;
    bool deactivate_similar = info->mDeactivateSimilar;

    delete info;
    info = NULL;
    LLGestureMgr& self = LLGestureMgr::instance();
    self.mLoadingCount--;

    if (0 == status)
    {
        LLFileSystem file(asset_uuid, type, LLFileSystem::READ);
        S32 size = file.getSize();

        std::vector<char> buffer(size+1);

        file.read((U8*)&buffer[0], size);
        // ensure there's a trailing NULL so strlen will work.
        buffer[size] = '\0';

        LLMultiGesture* gesture = new LLMultiGesture();

        LLDataPackerAsciiBuffer dp(&buffer[0], size+1);
        bool ok = gesture->deserialize(dp);

        if (ok)
        {
            if (deactivate_similar)
            {
                self.deactivateSimilarGestures(gesture, item_id);

                // Display deactivation message if this was the last of the bunch.
                if (self.mLoadingCount == 0
                    && self.mDeactivateSimilarNames.length() > 0)
                {
                    // we're done with this set of deactivations
                    LLSD args;
                    args["NAMES"] = self.mDeactivateSimilarNames;
                    LLNotificationsUtil::add("DeactivatedGesturesTrigger", args);
                }
            }

            LLViewerInventoryItem* item = gInventory.getItem(item_id);
            if(item)
            {
                gesture->mName = item->getName();
            }
            else
            {
                // Watch this item and set gesture name when item exists in inventory
                self.setFetchID(item_id);
                self.startFetch();
            }

            item_map_t::iterator it = self.mActive.find(item_id);
            if (it == self.mActive.end())
            {
                // Gesture is supposed to be present, active, but NULL
                LL_DEBUGS("GestureMgr") << "Gesture " << item_id << " not found in active list" << LL_ENDL;
            }
            else
            {
                LLMultiGesture* old_gesture = (*it).second;
                if (old_gesture && old_gesture != gesture)
                {
                    LL_DEBUGS("GestureMgr") << "Received dupplicate " << item_id << " callback" << LL_ENDL;
                    // In case somebody managest to activate, deactivate and
                    // then activate gesture again, before asset finishes loading.
                    // LLLoadInfo will have a different pointer, asset storage will
                    // see it as a different request, resulting in two callbacks.

                    // deactivateSimilarGestures() did not turn this one off
                    // because of matching item_id
                    self.stopGesture(old_gesture);

                    self.mActive.erase(item_id);
                    delete old_gesture;
                    old_gesture = NULL;
                }
            }

            self.mActive[item_id] = gesture;

            // Everything has been successful.  Add to the active list.
            gInventory.addChangedMask(LLInventoryObserver::LABEL, item_id);

            if (inform_server)
            {
                // Inform the database of this change
                LLMessageSystem* msg = gMessageSystem;
                msg->newMessage("ActivateGestures");
                msg->nextBlock("AgentData");
                msg->addUUID("AgentID", gAgent.getID());
                msg->addUUID("SessionID", gAgent.getSessionID());
                msg->addU32("Flags", 0x0);

                msg->nextBlock("Data");
                msg->addUUID("ItemID", item_id);
                msg->addUUID("AssetID", asset_uuid);
                msg->addU32("GestureFlags", 0x0);

                gAgent.sendReliableMessage();
            }
            callback_map_t::iterator i_cb = self.mCallbackMap.find(item_id);

            if(i_cb != self.mCallbackMap.end())
            {
                i_cb->second(gesture);
                self.mCallbackMap.erase(i_cb);
            }

            self.notifyObservers();
        }
        else
        {
            LL_WARNS("GestureMgr") << "Unable to load gesture" << LL_ENDL;

            item_map_t::iterator it = self.mActive.find(item_id);
            if (it != self.mActive.end())
            {
                LLMultiGesture* old_gesture = (*it).second;
                if (old_gesture)
                {
                    // Shouldn't happen, just in case
                    LL_WARNS("GestureMgr") << "Gesture " << item_id << " existed when it shouldn't" << LL_ENDL;

                    self.stopGesture(old_gesture);
                    delete old_gesture;
                    old_gesture = NULL;
                }
                self.mActive.erase(item_id);
            }

            delete gesture;
            gesture = NULL;
        }
    }
    else
    {
        if( LL_ERR_ASSET_REQUEST_NOT_IN_DATABASE == status ||
            LL_ERR_FILE_EMPTY == status)
        {
            LLDelayedGestureError::gestureMissing( item_id );
        }
        else
        {
            LLDelayedGestureError::gestureFailedToLoad( item_id );
        }

        LL_WARNS("GestureMgr") << "Problem loading gesture: " << status << LL_ENDL;

        item_map_t::iterator it = self.mActive.find(item_id);
        if (it != self.mActive.end())
        {
            LLMultiGesture* old_gesture = (*it).second;
            if (old_gesture)
            {
                // Shouldn't happen, just in case
                LL_WARNS("GestureMgr") << "Gesture " << item_id << " existed when it shouldn't" << LL_ENDL;

                self.stopGesture(old_gesture);
                delete old_gesture;
                old_gesture = NULL;
            }
            self.mActive.erase(item_id);
        }
    }
}

// static
void LLGestureMgr::onAssetLoadComplete(const LLUUID& asset_uuid,
                                       LLAssetType::EType type,
                                       void* user_data, S32 status, LLExtStat ext_status)
{
    LLGestureMgr& self = LLGestureMgr::instance();

    // Complete the asset loading process depending on the type and
    // remove the asset id from pending downloads list.
    switch(type)
    {
    case LLAssetType::AT_ANIMATION:
        {
            LLKeyframeMotion::onLoadComplete(asset_uuid, type, user_data, status, ext_status);

            self.mLoadingAssets.erase(asset_uuid);

            break;
        }
    case LLAssetType::AT_SOUND:
        {
            LLAudioEngine::assetCallback(asset_uuid, type, user_data, status, ext_status);

            self.mLoadingAssets.erase(asset_uuid);

            break;
        }
    default:
        {
            LL_WARNS() << "Unexpected asset type: " << type << LL_ENDL;

            // We don't want to return from this callback without
            // an animation or sound callback being fired
            // and *user_data handled to avoid memory leaks.
            llassert(type == LLAssetType::AT_ANIMATION || type == LLAssetType::AT_SOUND);
        }
    }
}

// static
bool LLGestureMgr::hasLoadingAssets(LLMultiGesture* gesture)
{
    LLGestureMgr& self = LLGestureMgr::instance();

    for (std::vector<LLGestureStep*>::iterator steps_it = gesture->mSteps.begin();
         steps_it != gesture->mSteps.end();
         ++steps_it)
    {
        LLGestureStep* step = *steps_it;
        switch(step->getType())
        {
        case STEP_ANIMATION:
            {
                LLGestureStepAnimation* anim_step = (LLGestureStepAnimation*)step;
                const LLUUID& anim_id = anim_step->mAnimAssetID;

                if (!(anim_id.isNull()
                      || anim_step->mFlags & ANIM_FLAG_STOP
                      || self.mLoadingAssets.find(anim_id) == self.mLoadingAssets.end()))
                {
                    return true;
                }
                break;
            }
        case STEP_SOUND:
            {
                LLGestureStepSound* sound_step = (LLGestureStepSound*)step;
                const LLUUID& sound_id = sound_step->mSoundAssetID;

                if (!(sound_id.isNull()
                      || self.mLoadingAssets.find(sound_id) == self.mLoadingAssets.end()))
                {
                    return true;
                }
                break;
            }
        case STEP_CHAT:
        case STEP_WAIT:
        case STEP_EOF:
            {
                break;
            }
        default:
            {
                LL_WARNS() << "Unknown gesture step type: " << step->getType() << LL_ENDL;
            }
        }
    }

    return false;
}

void LLGestureMgr::stopGesture(LLMultiGesture* gesture)
{
    if (!gesture) return;

    // Stop any animations that this gesture is currently playing
    std::set<LLUUID>::const_iterator set_it;
    for (set_it = gesture->mRequestedAnimIDs.begin(); set_it != gesture->mRequestedAnimIDs.end(); ++set_it)
    {
        const LLUUID& anim_id = *set_it;
        gAgent.sendAnimationRequest(anim_id, ANIM_REQUEST_STOP);
    }
    for (set_it = gesture->mPlayingAnimIDs.begin(); set_it != gesture->mPlayingAnimIDs.end(); ++set_it)
    {
        const LLUUID& anim_id = *set_it;
        gAgent.sendAnimationRequest(anim_id, ANIM_REQUEST_STOP);
    }

    std::vector<LLMultiGesture*>::iterator it;
    it = std::find(mPlaying.begin(), mPlaying.end(), gesture);
    while (it != mPlaying.end())
    {
        mPlaying.erase(it);
        it = std::find(mPlaying.begin(), mPlaying.end(), gesture);
    }

    gesture->reset();

    if (gesture->mDoneCallback)
    {
        gesture->mDoneCallback(gesture, gesture->mCallbackData);

        // callback might have deleted gesture, can't
        // rely on this pointer any more
        gesture = NULL;
    }

    notifyObservers();
}


void LLGestureMgr::stopGesture(const LLUUID& item_id)
{
    const LLUUID& base_item_id = gInventory.getLinkedItemID(item_id);

    item_map_t::iterator it = mActive.find(base_item_id);
    if (it == mActive.end()) return;

    LLMultiGesture* gesture = (*it).second;
    if (!gesture) return;

    stopGesture(gesture);
}


void LLGestureMgr::addObserver(LLGestureManagerObserver* observer)
{
    mObservers.push_back(observer);
}

void LLGestureMgr::removeObserver(LLGestureManagerObserver* observer)
{
    std::vector<LLGestureManagerObserver*>::iterator it;
    it = std::find(mObservers.begin(), mObservers.end(), observer);
    if (it != mObservers.end())
    {
        mObservers.erase(it);
    }
}

// Call this method when it's time to update everyone on a new state.
// Copy the list because an observer could respond by removing itself
// from the list.
void LLGestureMgr::notifyObservers()
{
    LL_DEBUGS() << "LLGestureMgr::notifyObservers" << LL_ENDL;

    for(std::vector<LLGestureManagerObserver*>::iterator iter = mObservers.begin();
        iter != mObservers.end();
        ++iter)
    {
        LLGestureManagerObserver* observer = (*iter);
        observer->changed();
    }
}

bool LLGestureMgr::matchPrefix(const std::string& in_str, std::string* out_str)
{
    auto in_len = in_str.length();

    //return whole trigger, if received text equals to it
    item_map_t::iterator it;
    for (it = mActive.begin(); it != mActive.end(); ++it)
    {
        LLMultiGesture* gesture = (*it).second;
        if (gesture)
        {
            const std::string& trigger = gesture->getTrigger();
            if (!LLStringUtil::compareInsensitive(in_str, trigger))
            {
                *out_str = trigger;
                return true;
            }
        }
    }

    //return common chars, if more than one trigger matches the prefix
    std::string rest_of_match = "";
    std::string buf = "";
    for (it = mActive.begin(); it != mActive.end(); ++it)
    {
        LLMultiGesture* gesture = (*it).second;
        if (gesture)
        {
            const std::string& trigger = gesture->getTrigger();

            if (in_len > trigger.length())
            {
                // too short, bail out
                continue;
            }

            std::string trigger_trunc = trigger;
            LLStringUtil::truncate(trigger_trunc, in_len);
            if (!LLStringUtil::compareInsensitive(in_str, trigger_trunc))
            {
                if (rest_of_match.compare("") == 0)
                {
                    rest_of_match = trigger.substr(in_str.size());
                }
                std::string cur_rest_of_match = trigger.substr(in_str.size());
                buf = "";
                S32 i=0;

                while (i<rest_of_match.length() && i<cur_rest_of_match.length())
                {
                    if (rest_of_match[i]==cur_rest_of_match[i])
                    {
                        buf.push_back(rest_of_match[i]);
                    }
                    else
                    {
                        if(i==0)
                        {
                            rest_of_match = "";
                        }
                        break;
                    }
                    i++;
                }
                if (rest_of_match.compare("") == 0)
                {
                    return true;
                }
                if (buf.compare("") != 0)
                {
                    rest_of_match = buf;
                }

            }
        }
    }

    if (rest_of_match.compare("") != 0)
    {
        *out_str = in_str+rest_of_match;
        return true;
    }

    return false;
}


void LLGestureMgr::getItemIDs(uuid_vec_t* ids)
{
    item_map_t::const_iterator it;
    for (it = mActive.begin(); it != mActive.end(); ++it)
    {
        ids->push_back(it->first);
    }
}

void LLGestureMgr::done()
{
    bool notify = false;
    for(item_map_t::iterator it = mActive.begin(); it != mActive.end(); ++it)
    {
        if(it->second && it->second->mName.empty())
        {
            LLViewerInventoryItem* item = gInventory.getItem(it->first);
            if(item)
            {
                it->second->mName = item->getName();
                notify = true;
            }
        }
    }
    if(notify)
    {
        notifyObservers();
    }
}