#include "Rendering/AnimationSystem.h"

AnimationSystem::AnimationSystem(SystemParams params)
    : System(params)
{
    EVENT_SUBSCRIBE_MEMBER(m_EAutoAnimationBlend, &AnimationSystem::OnAutoAnimationBlend);
    EVENT_SUBSCRIBE_MEMBER(m_EEntityDeleted, &AnimationSystem::OnEntityDeleted);
    EVENT_SUBSCRIBE_MEMBER(m_ESetBlendWeight, &AnimationSystem::OnSetBlendWeight);
    EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &AnimationSystem::OnInputCommand);
}

void AnimationSystem::Update(double dt)
{
    UpdateAnimations(dt);
    CreateBlendTrees();
    UpdateWeights(dt);

    EntityWrapper aimEntity = m_World->GetFirstEntityByName("ThirdPerson").FirstChildByName("Aim");
    (Field<double>)aimEntity["Animation"]["Time"] = glm::clamp((const double&)(Field<double>)aimEntity["Animation"]["Time"] + ((aimMove * 0.2f) * dt), 0.0, 1.0);


    EntityWrapper aimTextEntity = m_World->GetFirstEntityByName("AimText");

    if (aimMove > 0) {
        (Field<std::string>)aimTextEntity["Text"]["Content"] = "Up";
    } else if (aimMove < 0) {
        (Field<std::string>)aimTextEntity["Text"]["Content"] = "Down";
    } else {
        (Field<std::string>)aimTextEntity["Text"]["Content"] = " ";
    }

    for(auto& autoBlendQueue : m_AutoBlendQueues) {
        autoBlendQueue.second.UpdateTime(dt);
    }
}

void AnimationSystem::CreateBlendTrees()
{
    auto modelComponents = m_World->GetComponents("Model");
    if (modelComponents == nullptr) {
        return;
    }

    for (auto& modelC : *modelComponents) {
        EntityWrapper entity = EntityWrapper(m_World, modelC.EntityID);

        Model* model;
        try {
            model = ResourceManager::Load<::Model, true>(entity["Model"]["Resource"]);
        } catch (const std::exception&) {
            continue;;
        }

        Skeleton* skeleton = model->m_RawModel->m_Skeleton;
        if (skeleton == nullptr) {
            continue;
        }

        if (entity.HasComponent("Blend") || entity.HasComponent("BlendOverride") ||
            entity.HasComponent("BlendAdditive") || entity.HasComponent("Animation"))
        {
            std::shared_ptr<BlendTree> blendTree = std::shared_ptr<BlendTree>(new BlendTree(entity, skeleton));

            if(blendTree->IsValid()) {
                skeleton->BlendTrees[entity] = blendTree;
            }
            
        }
    }
}

void AnimationSystem::UpdateAnimations(double dt)
{
    auto animationComponents = m_World->GetComponents("Animation");
    if(animationComponents == nullptr) {
        return;
    }

    for (auto& animationC : *animationComponents) {
        EntityWrapper entity = EntityWrapper(m_World, animationC.EntityID);
        EntityWrapper modelEntity;
        if(!entity.HasComponent("Model")) {
            modelEntity = entity.FirstParentWithComponent("Model");
        } else {
            modelEntity = entity;
        }

        Model* model;
        try {
            Field<std::string> res = modelEntity["Model"]["Resource"];
            model = ResourceManager::Load<::Model, true>(res);
        } catch (const std::exception&) {
            continue;
        }

        Skeleton* skeleton = model->m_RawModel->m_Skeleton;
        if (skeleton == nullptr) {
            continue;
        }

        const Skeleton::Animation* animation = skeleton->GetAnimation(animationC["AnimationName"]);

        if (animation == nullptr) {
            continue;
        }

        double animationSpeed = (const double&)animationC["Speed"];

        if((const bool&)animationC["Reverse"]) {
            animationSpeed *= -1;
        }


        if ((const bool&)animationC["Play"]) {

            double nextTime = (Field<double>)animationC["Time"] + animationSpeed * dt;
            if (!(Field<bool>)animationC["Loop"]) {
                if (nextTime > animation->Duration) {
                    nextTime = animation->Duration;
                    (Field<bool>)animationC["Play"] = false;
                } else if (nextTime < 0) {
                    nextTime = 0;
                    (Field<bool>)animationC["Play"] = false;
                }
            } else {
                if (nextTime > animation->Duration) {

                    while (nextTime > animation->Duration) {
                        nextTime -= animation->Duration;
                    }
                } else if (nextTime < 0) {
                    while (nextTime < 0) {
                        nextTime += animation->Duration;
                    }
                }
            }
            (Field<double>)animationC["Time"] = nextTime;
        }
    }
}

void AnimationSystem::UpdateWeights(double dt)
{
    for (auto it = m_AutoBlendQueues.begin(); it != m_AutoBlendQueues.end(); ) {
        //LOG_INFO("%s", it->first.Name().c_str());
        //it->second.PrintQueue();
        
        if(it->second.HasActiveBlendJob()) {
            AutoBlendQueue::AutoBlendJob& blendJob = it->second.GetActiveBlendJob();
            //LOG_INFO("%s", blendJob.RootNode.Name().c_str());
            std::shared_ptr<BlendTree> blendTree = it->second.GetBlendTree();
            if (blendTree != nullptr) {
                if (blendJob.Duration != 0.0) {
                    blendJob.BlendInfo.progress = glm::clamp(blendJob.CurrentTime / blendJob.Duration, 0.0, 1.0);
                } else {
                    blendJob.BlendInfo.progress = 1.0;
                }

                blendJob.BlendInfo = blendTree->AutoBlendStep(blendJob.BlendInfo);
            } else {
                it = m_AutoBlendQueues.erase(it);
            }
            it++;
        } else {
            if (it->second.Empty()) {
                it = m_AutoBlendQueues.erase(it);
            } else {
                it++;
            }
        }
    }
}

bool AnimationSystem::OnAutoAnimationBlend(Events::AutoAnimationBlend& e)
{
    if (!e.RootNode.Valid()) {
        LOG_ERROR("%s, RootNode invalid %s", e.NodeName, e.RootNode.Name().c_str());
        return false;
    }

    if (!e.RootNode.HasComponent("Model")) {
        LOG_ERROR("%s, RootNode has no model %s", e.NodeName, e.RootNode.Name().c_str());
        return false;
    }

    Model* model;
    try {
        model = ResourceManager::Load<::Model, true>((std::string)e.RootNode["Model"]["Resource"]);
    } catch (const std::exception&) {
        LOG_ERROR("%s, RootNode model not finished loading %s", e.NodeName, e.RootNode.Name().c_str());
        return false;
    }

    Skeleton* skeleton = model->m_RawModel->m_Skeleton;
    if (skeleton == nullptr) {
        LOG_ERROR("%s, RootNode skeleton invalid %s", e.NodeName, e.RootNode.Name().c_str());
        return false;
    }

    std::shared_ptr<BlendTree> blendTree;
    if (skeleton->BlendTrees.find(e.RootNode) != skeleton->BlendTrees.end()) {
        blendTree = skeleton->BlendTrees.at(e.RootNode);
    } else {
        LOG_ERROR("%s, No blendtree was found invalid %s", e.NodeName, e.RootNode.Name().c_str());
        return false;
    }

    EntityWrapper subTreeRoot;


    if (e.SingleLevelBlend) {
        subTreeRoot = blendTree->GetSubTreeRoot(e.NodeName);

        if (!subTreeRoot.Valid()) {
            LOG_ERROR("%s, subTreeRoot invalid", e.NodeName);
            return false;
        }

        AutoBlendQueue::AutoBlendJob abj;
        abj.AnimationEntity = e.AnimationEntity;
        abj.CurrentTime = 0.0;
        abj.Delay = e.Delay;
        abj.Duration = e.Duration;
        abj.RootNode = e.RootNode;

        abj.BlendInfo.NodeName = e.NodeName;
        abj.BlendInfo.progress = 0.0;
        abj.BlendInfo.Start = e.Start;
        abj.BlendInfo.SingleBlend = e.SingleLevelBlend;
        abj.BlendInfo.Weight = e.Weight;

        std::vector<EntityWrapper> animationEntities = blendTree->GetEntitesByName(e.NodeName); // more than one
        for(auto entity : animationEntities)
        if (entity.Valid()) {
            if (entity.HasComponent("Animation")) {
                const Skeleton::Animation* animation = skeleton->GetAnimation(entity["Animation"]["AnimationName"]);
                (Field<bool>)entity["Animation"]["Reverse"] = e.Reverse;

                if (e.Restart) {
                    if (animation != nullptr) {
                        if (e.Restart) {
                            if (e.Reverse) {
                                (Field<double>)entity["Animation"]["Time"] = animation->Duration;
                            } else {
                                (Field<double>)entity["Animation"]["Time"] = 0.0;
                            }
                        }
                    }
                }
            }
        }
        m_AutoBlendQueues[subTreeRoot].Insert(abj);
    } else {
        std::vector<EntityWrapper> subtreeroots = blendTree->GetSingleLevelRoots(e.NodeName);

        for(auto entity : subtreeroots) {
            subTreeRoot = entity;

            if (!subTreeRoot.Valid()) {
                LOG_ERROR("%s, subTreeRoot invalid", e.NodeName);
                return false;
            }

            AutoBlendQueue::AutoBlendJob abj;
            abj.AnimationEntity = e.AnimationEntity;
            abj.CurrentTime = 0.0;
            abj.Delay = e.Delay;
            abj.Duration = e.Duration;
            abj.RootNode = e.RootNode;

            abj.BlendInfo.NodeName = e.NodeName;
            abj.BlendInfo.progress = 0.0;
            abj.BlendInfo.Start = e.Start;
            abj.BlendInfo.SingleBlend = e.SingleLevelBlend;
            abj.BlendInfo.Weight = e.Weight;
            m_AutoBlendQueues[subTreeRoot].Insert(abj);
        }

        std::vector<EntityWrapper> animationEntities = blendTree->GetEntitesByName(e.NodeName); // more than one
        for (auto entity : animationEntities)
            if (entity.Valid()) {
                if (entity.HasComponent("Animation")) {
                    const Skeleton::Animation* animation = skeleton->GetAnimation(entity["Animation"]["AnimationName"]);
                    entity["Animation"]["Reverse"] = e.Reverse;

                    if (e.Restart) {
                        if (animation != nullptr) {
                            if (e.Restart) {
                                if (e.Reverse) {
                                    entity["Animation"]["Time"] = animation->Duration;
                                } else {
                                    entity["Animation"]["Time"] = 0.0;
                                }
                            }
                        }
                    }
                }
            }
    }

   
    return true;
}

bool AnimationSystem::OnEntityDeleted(Events::EntityDeleted& e)
{
    EntityWrapper entity = e.DeletedEntity;

    if (entity.HasComponent("Model")) {
        Model* model;
        try {
            model = ResourceManager::Load<::Model, true>(entity["Model"]["Resource"]);
        } catch (const std::exception&) {
            return false;
        }

        Skeleton* skeleton = model->m_RawModel->m_Skeleton;
        if (skeleton == nullptr) {
            return false;
        }

        if (skeleton->BlendTrees.find(entity) != skeleton->BlendTrees.end()) {
            skeleton->BlendTrees.erase(entity);
        }


    }

}

bool AnimationSystem::OnSetBlendWeight(Events::SetBlendWeight& e)
{
    if (!e.RootNode.Valid()) {
        return false;
    }

    if (!e.RootNode.HasComponent("Model")) {
        return false;
    }

    Model* model;
    try {
        model = ResourceManager::Load<::Model, true>((std::string)e.RootNode["Model"]["Resource"]);
    } catch (const std::exception&) {
        return false;
    }

    Skeleton* skeleton = model->m_RawModel->m_Skeleton;
    if (skeleton == nullptr) {
        return false;
    }

    std::shared_ptr<BlendTree> blendTree;
    if (skeleton->BlendTrees.find(e.RootNode) != skeleton->BlendTrees.end()) {
        blendTree = skeleton->BlendTrees.at(e.RootNode);
    } else {
        return false;
    }

    if(e.Weight >= 0 && e.Weight <= 1) {

        blendTree->SetWeightByName(e.NodeName, e.Weight);

        return true;
    } else {
        return false;
    }

}

bool AnimationSystem::OnInputCommand(Events::InputCommand& e)
{
    EntityWrapper firstPerson = m_World->GetFirstEntityByName("FirstPerson");
    EntityWrapper thirdPerson = m_World->GetFirstEntityByName("ThirdPerson");

    EntityWrapper currentBlend = m_World->GetFirstEntityByName("CurrentBlend");
    EntityWrapper queuedBlend = m_World->GetFirstEntityByName("QueuedBlend");
    EntityWrapper MovementText = m_World->GetFirstEntityByName("MovementText");
    
    
    if (e.Command == "ClearText") {
        if (e.Value > 0) {
            (Field<std::string>)currentBlend["Text"]["Content"] = " ";
            (Field<std::string>)queuedBlend["Text"]["Content"] = " ";
        }
    }

    if(e.Command == "Jump") {
        if(e.Value > 0) {
            (Field<std::string>)currentBlend["Text"]["Content"] = "Jump";
            (Field<std::string>)queuedBlend["Text"]["Content"] = "Movement";

            Events::AutoAnimationBlend blendEvent;
            blendEvent.RootNode = thirdPerson;
            blendEvent.Duration = 0.2f;
            blendEvent.NodeName = "Jump";
            blendEvent.Start = true;
            blendEvent.Restart = true;
            m_EventBroker->Publish(blendEvent);

            Events::AutoAnimationBlend blendEventQueued;
            blendEventQueued.RootNode = thirdPerson;
            blendEventQueued.Delay = -0.1;
            blendEventQueued.Duration = 0.3f;
            blendEventQueued.NodeName = "MovementBlend";
            blendEventQueued.AnimationEntity = thirdPerson.FirstChildByName("Jump");
            m_EventBroker->Publish(blendEventQueued);
        }
    }

    if (e.Command == "DashL") {
        if (e.Value > 0) {
            (Field<std::string>)currentBlend["Text"]["Content"] = "Dash Left";
            (Field<std::string>)queuedBlend["Text"]["Content"] = "Movement";


            Events::AutoAnimationBlend blendEvent;
            blendEvent.RootNode = thirdPerson;
            blendEvent.Duration = 0.2f;
            blendEvent.NodeName = "DashLeft";
            blendEvent.Start = true;
            blendEvent.Restart = true;
            m_EventBroker->Publish(blendEvent);

            Events::AutoAnimationBlend blendEventQueued;
            blendEventQueued.RootNode = thirdPerson;
            blendEventQueued.Delay = -0.1;
            blendEventQueued.Duration = 0.3f;
            blendEventQueued.NodeName = "MovementBlend";
            blendEventQueued.AnimationEntity = thirdPerson.FirstChildByName("DashLeft");
            m_EventBroker->Publish(blendEventQueued);
        }
    }

    if (e.Command == "DashR") {
        if (e.Value > 0) {
            (Field<std::string>)currentBlend["Text"]["Content"] = "Dash Right";
            (Field<std::string>)queuedBlend["Text"]["Content"] = "Movement";


            Events::AutoAnimationBlend blendEvent;
            blendEvent.RootNode = thirdPerson;
            blendEvent.Duration = 0.2f;
            blendEvent.NodeName = "DashRight";
            blendEvent.Start = true;
            blendEvent.Restart = true;
            m_EventBroker->Publish(blendEvent);

            Events::AutoAnimationBlend blendEventQueued;
            blendEventQueued.RootNode = thirdPerson;
            blendEventQueued.Delay = -0.1;
            blendEventQueued.Duration = 0.3f;
            blendEventQueued.NodeName = "MovementBlend";
            blendEventQueued.AnimationEntity = thirdPerson.FirstChildByName("DashRight");
            m_EventBroker->Publish(blendEventQueued);
        }
    }

    if (e.Command == "DashF") {
        if (e.Value > 0) {
            (Field<std::string>)currentBlend["Text"]["Content"] = "Dash Forward";
            (Field<std::string>)queuedBlend["Text"]["Content"] = "Movement";


            Events::AutoAnimationBlend blendEvent;
            blendEvent.RootNode = thirdPerson;
            blendEvent.Duration = 0.2f;
            blendEvent.NodeName = "DashForward";
            blendEvent.Start = true;
            blendEvent.Restart = true;
            m_EventBroker->Publish(blendEvent);

            Events::AutoAnimationBlend blendEventQueued;
            blendEventQueued.RootNode = thirdPerson;
            blendEventQueued.Delay = -0.1;
            blendEventQueued.Duration = 0.3f;
            blendEventQueued.NodeName = "MovementBlend";
            blendEventQueued.AnimationEntity = thirdPerson.FirstChildByName("DashForward");
            m_EventBroker->Publish(blendEventQueued);
        }
    }

    if (e.Command == "DashB") {
        if (e.Value > 0) {
            (Field<std::string>)currentBlend["Text"]["Content"] = "Dash Backward";
            (Field<std::string>)queuedBlend["Text"]["Content"] = "Movement";


            Events::AutoAnimationBlend blendEvent;
            blendEvent.RootNode = thirdPerson;
            blendEvent.Duration = 0.2f;
            blendEvent.NodeName = "DashBackward";
            blendEvent.Start = true;
            blendEvent.Restart = true;
            m_EventBroker->Publish(blendEvent);

            Events::AutoAnimationBlend blendEventQueued;
            blendEventQueued.RootNode = thirdPerson;
            blendEventQueued.Delay = -0.1;
            blendEventQueued.Duration = 0.3f;
            blendEventQueued.NodeName = "MovementBlend";
            blendEventQueued.AnimationEntity = thirdPerson.FirstChildByName("DashBackward");
            m_EventBroker->Publish(blendEventQueued);
        }
    }


    if (e.Command == "Right") {
        if (e.Value > 0) {
            (Field<std::string>)MovementText["Text"]["Content"] = "Right";
            Events::AutoAnimationBlend blendEvent;
            blendEvent.RootNode = thirdPerson;
            blendEvent.Duration = 0.3f;
            blendEvent.NodeName = "Right";
            blendEvent.Start = true;
            m_EventBroker->Publish(blendEvent);

            Events::AutoAnimationBlend blendEventFP;
            blendEventFP.RootNode = firstPerson;
            blendEventFP.Duration = 0.3f;
            blendEventFP.NodeName = "Run";
            blendEventFP.Start = true;
            m_EventBroker->Publish(blendEventFP);


        } else if (e.Value < 0) {
            (Field<std::string>)MovementText["Text"]["Content"] = "Left";
            Events::AutoAnimationBlend blendEvent;
            blendEvent.RootNode = thirdPerson;
            blendEvent.Duration = 0.3f;
            blendEvent.NodeName = "Left";
            blendEvent.Start = true;
            m_EventBroker->Publish(blendEvent);

            Events::AutoAnimationBlend blendEventFP;
            blendEventFP.RootNode = firstPerson;
            blendEventFP.Duration = 0.3f;
            blendEventFP.NodeName = "Run";
            blendEventFP.Reverse = true;
            blendEventFP.Start = true;
            m_EventBroker->Publish(blendEventFP);
        }
    }else if (e.Command == "Up") {
        if (e.Value > 0) {
            (Field<std::string>)MovementText["Text"]["Content"] = "Forward";
            Events::AutoAnimationBlend blendEvent;
            blendEvent.RootNode = thirdPerson;
            blendEvent.Duration = 0.3f;
            if (Crouch) {
                blendEvent.NodeName = "Walk";

                Events::AutoAnimationBlend blendEventFP;
                blendEventFP.RootNode = firstPerson;
                blendEventFP.Duration = 0.3f;
                blendEventFP.NodeName = "Idle";
                blendEventFP.Start = true;
                m_EventBroker->Publish(blendEventFP);

            } else {
                blendEvent.NodeName = "Run";


                Events::AutoAnimationBlend blendEventFP;
                blendEventFP.RootNode = firstPerson;
                blendEventFP.Duration = 0.3f;
                blendEventFP.NodeName = "Run";
                blendEventFP.Start = true;
                m_EventBroker->Publish(blendEventFP);

            }
            blendEvent.Start = true;
            m_EventBroker->Publish(blendEvent);
        }else if (e.Value < 0) {
            (Field<std::string>)MovementText["Text"]["Content"] = "Backward";
            Events::AutoAnimationBlend blendEvent;
            blendEvent.RootNode = thirdPerson;
            blendEvent.Duration = 0.3f;
            if(Crouch) {
                blendEvent.NodeName = "Walk";

                Events::AutoAnimationBlend blendEventFP;
                blendEventFP.RootNode = firstPerson;
                blendEventFP.Duration = 0.3f;
                blendEventFP.NodeName = "Idle";
                blendEventFP.Start = true;
                m_EventBroker->Publish(blendEventFP);
            } else {
                blendEvent.NodeName = "Run";

                Events::AutoAnimationBlend blendEventFP;
                blendEventFP.RootNode = firstPerson;
                blendEventFP.Duration = 0.3f;
                blendEventFP.NodeName = "Run";
                blendEventFP.Reverse = true;
                blendEventFP.Start = true;
                m_EventBroker->Publish(blendEventFP);
            }
            blendEvent.Start = true;
            blendEvent.Reverse = true;
            m_EventBroker->Publish(blendEvent);
        }
    }

    if (e.Command == "Idle"){
        if (e.Value > 0) {
            (Field<std::string>)MovementText["Text"]["Content"] = "Idle";
            Events::AutoAnimationBlend blendEvent;
            blendEvent.RootNode = thirdPerson;
            blendEvent.Duration = 0.5f;
            blendEvent.NodeName = "Idle";
            blendEvent.Start = true;
            blendEvent.Reverse = true;
            m_EventBroker->Publish(blendEvent);

            Events::AutoAnimationBlend blendEventFP;
            blendEventFP.RootNode = firstPerson;
            blendEventFP.Duration = 0.3f;
            blendEventFP.NodeName = "Idle";
            blendEventFP.Start = true;
            m_EventBroker->Publish(blendEventFP);
        }
    }


    if (e.Command == "Crouch") {
        if (e.Value > 0) {
            Events::AutoAnimationBlend blendEvent;
            blendEvent.RootNode = thirdPerson;
            blendEvent.Duration = 0.5f;
            blendEvent.NodeName = "CrouchMovement";
            blendEvent.Start = true;
            blendEvent.Reverse = true;
            m_EventBroker->Publish(blendEvent);
            Crouch = true;
        } else {
            Events::AutoAnimationBlend blendEvent;
            blendEvent.RootNode = thirdPerson;
            blendEvent.Duration = 0.5f;
            blendEvent.NodeName = "StandMovement";
            blendEvent.Start = true;
            blendEvent.Reverse = true;
            m_EventBroker->Publish(blendEvent);
            Crouch = false;
        }
    }

    if (e.Command == "Aim") {
        aimMove = e.Value;
    } 

    if (e.Command == "Shoot") {
        if (e.Value > 0) {
            (Field<std::string>)currentBlend["Text"]["Content"] = "Fire";
            (Field<std::string>)queuedBlend["Text"]["Content"] = "Idle";

            Events::AutoAnimationBlend blendEvent;
            blendEvent.RootNode = thirdPerson;
            blendEvent.Duration = 0.1f;
            blendEvent.NodeName = "Fire";
            blendEvent.Start = true;
            blendEvent.Restart = true;
            m_EventBroker->Publish(blendEvent);

            Events::AutoAnimationBlend blendEventFP;
            blendEventFP.RootNode = firstPerson;
            blendEventFP.Duration = 0.1f;
            blendEventFP.NodeName = "Fire";
            blendEventFP.Start = true;
            blendEventFP.Restart = true;
            m_EventBroker->Publish(blendEventFP);
        }
    }


    if (e.Command == "Reload") {
        if (e.Value > 0) {
            (Field<std::string>)currentBlend["Text"]["Content"] = "Reload";
            (Field<std::string>)queuedBlend["Text"]["Content"] = "Idle";


            Events::AutoAnimationBlend blendEvent;
            blendEvent.RootNode = thirdPerson;
            blendEvent.Duration = 0.1f;
            blendEvent.NodeName = "Reload";
            blendEvent.Start = true;
            blendEvent.Restart = true;
            m_EventBroker->Publish(blendEvent);

            Events::AutoAnimationBlend blendEventQ;
            blendEventQ.RootNode = thirdPerson;
            blendEventQ.Duration = 0.2f;
            blendEventQ.Delay = -0.1;
            blendEventQ.NodeName = "Fire";
            blendEventQ.Start = false;
            blendEventQ.Restart = true;
            blendEventQ.AnimationEntity = thirdPerson.FirstChildByName("Reload");
            m_EventBroker->Publish(blendEventQ);



            Events::AutoAnimationBlend blendEventFP;
            blendEventFP.RootNode = firstPerson;
            blendEventFP.Duration = 0.1f;
            blendEventFP.NodeName = "Reload";
            blendEventFP.Start = true;
            blendEventFP.Restart = true;
            m_EventBroker->Publish(blendEventFP);

            Events::AutoAnimationBlend blendEventFPQ;
            blendEventFPQ.RootNode = firstPerson;
            blendEventFPQ.Duration = 0.2f;
            blendEventFPQ.Delay = -0.1;
            blendEventFPQ.NodeName = "Fire";
            blendEventFPQ.Start = false;
            blendEventFPQ.Restart = true;
            blendEventFPQ.AnimationEntity = thirdPerson.FirstChildByName("Reload");
            m_EventBroker->Publish(blendEventFPQ);

        }
    }

    return true;
}