/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
/////////////////////////////////////////////////////////////////////////////////////////
//
// INCLUDES
//
/////////////////////////////////////////////////////////////////////////////////////////

// singular
#include "plAGAnimInstance.h"

// local
#include "plAGAnim.h"
#include "plAGModifier.h"
#include "plAGMasterMod.h"

// global
#include "hsTimer.h"        // just when debugging for GetSysSeconds

// other
#include "pnNetCommon/plSDLTypes.h"
#include "plMessage/plAnimCmdMsg.h"
#include "plMessage/plOneShotCallbacks.h"
#include "plModifier/plSDLModifier.h"
#include "plSDL/plSDL.h"

/////////////////////////////////////////////////////////////////////////////////////////
//
// FLAGS
//
/////////////////////////////////////////////////////////////////////////////////////////

// enable this to show blend trees before and after attaches and detaches
// #define SHOW_AG_CHANGES

/////////////////////////////////////////////////////////////////////////////////////////
//
// STATIC
//
/////////////////////////////////////////////////////////////////////////////////////////
#ifdef TRACK_AG_ALLOCS
extern const char *gGlobalAnimName = nil;
extern const char *gGlobalChannelName = nil;
#endif // TRACK_AG_ALLOCS

/////////////////////////////////////////////////////////////////////////////////////////
//
// plAGAnimInstance
//
/////////////////////////////////////////////////////////////////////////////////////////

// ctor -------------------------------------------------------------------
// -----
plAGAnimInstance::plAGAnimInstance(plAGAnim * anim, plAGMasterMod * master,
                                   hsScalar blend, UInt16 blendPriority, hsBool cache,
                                   bool useAmplitude)
: fAnimation(anim),
  fMaster(master),
  fBlend(blend),
  fAmplitude(useAmplitude ? 1.0f : -1.0f)
{
    int i;
    fTimeConvert = nil;
    plScalarChannel *timeChan = nil;
#ifdef TRACK_AG_ALLOCS
    gGlobalAnimName = anim->GetName();      // for debug tracking...
#endif // TRACK_AG_ALLOCS

    plATCAnim *atcAnim = plATCAnim::ConvertNoRef(anim);
    if (atcAnim)
    {
        fTimeConvert = TRACKED_NEW plAnimTimeConvert();
        fTimeConvert->Init(atcAnim, this, master);
        timeChan = TRACKED_NEW plATCChannel(fTimeConvert);
    }
    else
    {
        timeChan = TRACKED_NEW plScalarSDLChannel(anim->GetLength());
        fSDLChannels.push_back((plScalarSDLChannel *)timeChan);
    }

    int nInChannels = anim->GetChannelCount();

    fCleanupChannels.push_back(timeChan);

#ifdef SHOW_AG_CHANGES
    hsStatusMessageF("\nAbout to Attach anim <%s>", GetName());
    fMaster->DumpAniGraph("bone_pelvis", false, hsTimer::GetSysSeconds());
#endif

    for (i = 0; i < nInChannels; i++)
    {
        plAGApplicator * app = fAnimation->GetApplicator(i);
        plAGChannel * inChannel = app->GetChannel();
        const char * channelName = app->GetChannelName();
        plAGModifier * channelMod = master->GetChannelMod(channelName);
        
        if(channelMod) {
#ifdef TRACK_AG_ALLOCS
            gGlobalChannelName = channelName;
#endif // TRACK_AG_ALLOCS

            // we're going to be accumulating a chain of channels.
            // curChannel will always point to the top one...
            plAGChannel *topNode = inChannel;

            if(cache)
            {
                topNode = topNode->MakeCacheChannel(fTimeConvert);
                IRegisterDetach(channelName, topNode);
            }

            if(useAmplitude)
            {
                // amplitude is rarely used and expensive, so only alloc if asked
                // first build a static copy of the incoming channel...
                plAGChannel *zeroState = inChannel->MakeZeroState();
                IRegisterDetach(channelName, zeroState);

                // now make a blend node to blend the anim with its static copy
                topNode = zeroState->MakeBlend(topNode, &fAmplitude, -1);
            }

            // make a time scaler to localize time for this instance
            topNode = topNode->MakeTimeScale(timeChan);
                IRegisterDetach(channelName, topNode);

            channelMod->MergeChannel(app, topNode, &fBlend, this, blendPriority);
        }
        else
            hsAssert(false, "Adding an animation with an invalid channel.");
    }
    fFadeBlend = fFadeAmp = false;

#ifdef TRACK_AG_ALLOCS
    gGlobalAnimName = nil;
#endif // TRACK_AG_ALLOCS
}

// dtor -----------------------------
// -----
plAGAnimInstance::~plAGAnimInstance()
{
    delete fTimeConvert;
}

// SearchForGlobals ---------------------
// -----------------
void plAGAnimInstance::SearchForGlobals()
{
    const plAgeGlobalAnim *ageAnim = plAgeGlobalAnim::ConvertNoRef(fAnimation);
    if (ageAnim != nil && fSDLChannels.size() > 0)
    {
        extern const plSDLModifier *ExternFindAgeSDL();
        const plSDLModifier *sdlMod = ExternFindAgeSDL();
        if (!sdlMod)
            return;

        plSimpleStateVariable *var = sdlMod->GetStateCache()->FindVar(ageAnim->GetGlobalVarName());
        if (!var)
            return;

        sdlMod->AddNotifyForVar(fMaster->GetKey(), ageAnim->GetGlobalVarName(), 0);
        int i;
        for (i = 0; i < fSDLChannels.size(); i++)
            fSDLChannels[i]->SetVar(var);
    }
}

void plAGAnimInstance::IRegisterDetach(const char *channelName, plAGChannel *channel)
{
    plDetachMap::value_type newPair(channelName, channel);
    fManualDetachChannels.insert(newPair);
}

// SetCurrentTime ---------------------------------------------------------------
// ---------------
void plAGAnimInstance::SetCurrentTime(hsScalar localT, hsBool jump /* = false */)
{
    if (fTimeConvert)
        fTimeConvert->SetCurrentAnimTime(localT, jump);
}

// SeekRelative ------------------------------------
// -------------
void plAGAnimInstance::SeekRelative (hsScalar delta, hsBool jump)
{
    if(fTimeConvert)
    {
        hsScalar now = fTimeConvert->CurrentAnimTime();
        fTimeConvert->SetCurrentAnimTime (now + delta, jump);
    }
}

// Detach ---------------------
// -------
void plAGAnimInstance::Detach()
{
    fMaster->DetachAnimation(this);
}

// DetachChannels ---------------------
// ---------------
void plAGAnimInstance::DetachChannels()
{
#ifdef SHOW_AG_CHANGES
    hsStatusMessageF("\nAbout to DETACH anim <%s>", GetName());
    fMaster->DumpAniGraph("bone_pelvis", false, hsTimer::GetSysSeconds());
#endif
    plDetachMap::iterator i = fManualDetachChannels.begin();

    while(i != fManualDetachChannels.end())
    {
        const char *channelName = (*i).first;
        plAGModifier *channelMod = fMaster->GetChannelMod(channelName, true);

        if(channelMod)
        {
            do {
                plAGChannel *channel = (*i).second;
                channelMod->DetachChannel(channel);
            } while (++i != fManualDetachChannels.end() && i->first == channelName);
        } else {
            do {
            } while (++i != fManualDetachChannels.end() && i->first == channelName);
        }
    }

    int cleanCount = fCleanupChannels.size();
    hsAssert(cleanCount, "No time controls when deleting animation");
    for (int j = 0; j < cleanCount; j++)
    {
        delete fCleanupChannels[j];
    }
    fCleanupChannels.clear();

#ifdef SHOW_AG_CHANGES
    hsStatusMessageF("\nFinished DETACHING anim <%s>", GetName());
    fMaster->DumpAniGraph("bone_pelvis", false, hsTimer::GetSysSeconds());
#endif
}

// SetBlend ---------------------------------------
// ---------
hsScalar plAGAnimInstance::SetBlend(hsScalar blend)
{
    float oldBlend = fBlend.Value(0.0, true);
    if(oldBlend != blend &&
        (oldBlend == 0.0f ||
         blend == 0.0f ||
         oldBlend == 1.0f ||
         blend == 1.0f))
    {
        fMaster->SetNeedCompile(true);
    }
    fBlend.Set(blend);
    return blend;
}

// GetBlend -------------------------
// ---------
hsScalar plAGAnimInstance::GetBlend()
{
    return fBlend.Value(0);
}

// SetAmplitude -------------------------------------
// -------------
hsScalar plAGAnimInstance::SetAmplitude(hsScalar amp)
{
    if(fAmplitude.Get() != -1.0f)
    {
        fAmplitude.Set(amp);
    }
    return amp;
}

// GetAmplitude -------------------------
// -------------
hsScalar plAGAnimInstance::GetAmplitude()
{
    return fAmplitude.Value(0);
}

// GetName -----------------------------
// --------
const char * plAGAnimInstance::GetName()
{
    if(fAnimation)
        return fAnimation->GetName();
    else
        return nil;
}

// SetLoop ----------------------------------
// --------
void plAGAnimInstance::SetLoop(hsBool status)
{
    if (fTimeConvert)
        fTimeConvert->Loop(status);
}

// HandleCmd ----------------------------------------
// ----------
hsBool plAGAnimInstance::HandleCmd(plAnimCmdMsg *msg)
{
    if (fTimeConvert)
        return fTimeConvert->HandleCmd(msg);
    return false;
}

// IsFinished -----------------------
// -----------
hsBool plAGAnimInstance::IsFinished()
{
    if (fTimeConvert)
        return fTimeConvert->IsStopped();
    return false;
}

// IsAtEnd -----------------------
// --------
hsBool plAGAnimInstance::IsAtEnd()
{
    if(fTimeConvert)
    {
        return fTimeConvert->CurrentAnimTime() == fTimeConvert->GetEnd();
    }
    else
        return false;
}

// Start -----------------------------------
// ------
void plAGAnimInstance::Start(double timeNow)
{
    if (fTimeConvert)
    {
        if (timeNow < 0)
            fTimeConvert->Start();
        else
            fTimeConvert->Start(timeNow);
    }
}

// Stop ---------------------
// -----
void plAGAnimInstance::Stop()
{
    if (fTimeConvert)
        fTimeConvert->Stop();
}

// AttachCallbacks --------------------------------------------------
// ----------------
void plAGAnimInstance::AttachCallbacks(plOneShotCallbacks *callbacks)
{
    const plATCAnim *anim = plATCAnim::ConvertNoRef(fAnimation);
    if (callbacks && anim)
    {
        plAnimCmdMsg animMsg;
        animMsg.SetCmd(plAnimCmdMsg::kAddCallbacks);

        for (int i = 0; i < callbacks->GetNumCallbacks(); i++)
        {
            plOneShotCallbacks::plOneShotCallback& cb = callbacks->GetCallback(i);

            plEventCallbackMsg *eventMsg = TRACKED_NEW plEventCallbackMsg;
            eventMsg->AddReceiver(cb.fReceiver);
            eventMsg->fRepeats = 0;
            eventMsg->fUser = cb.fUser;

            if (cb.fMarker)
            {
                float marker = anim->GetMarker(cb.fMarker);
                hsAssert(marker != -1, "Bad marker name");
                eventMsg->fEventTime = marker;
                eventMsg->fEvent = kTime;
            }
            else
            {
                eventMsg->fEvent = kStop;
            }
            
            animMsg.AddCallback(eventMsg);
            hsRefCnt_SafeUnRef(eventMsg);
        }
        
        fTimeConvert->HandleCmd(&animMsg);
    }
}

// ProcessFade -------------------------------------
// ------------
void plAGAnimInstance::ProcessFade(hsScalar elapsed)
{
    if (fFadeBlend) {
        hsScalar newBlend = ICalcFade(fFadeBlend, GetBlend(), fFadeBlendGoal, fFadeBlendRate, elapsed);
        SetBlend(newBlend);
        if(fFadeDetach && (newBlend == fFadeBlendGoal) && (fFadeBlendGoal == 0.0f) )
        {
            fMaster->DetachAnimation(this);
            return;
        }
    }

    if (fFadeAmp && fAmplitude.Get() != -1.0f) {
        hsScalar curAmp = GetAmplitude();
        hsScalar newAmp = ICalcFade(fFadeAmp, curAmp, fFadeAmpGoal, fFadeAmpRate, elapsed);
        SetAmplitude(newAmp);
    }
}

// ICalcFade ---------------------------------------------------------------------
// ----------
hsScalar plAGAnimInstance::ICalcFade(hsBool &fade, hsScalar curVal, hsScalar goal,
                                     hsScalar rate, hsScalar elapsed)
{
    hsScalar newVal;
    hsScalar curStep = rate * elapsed;
    if(rate > 0) {
        newVal = __min(goal, curVal + curStep);
    } else {
        newVal = __max(goal, curVal + curStep);
    }

    if(newVal == goal)
    {
        fade = false;
        fMaster->DirtySynchState(kSDLAGMaster, 0);  // send SDL state update to server
    }
    return newVal;
}

// FadeAndDetach -------------------------------------------------
// --------------
void plAGAnimInstance::FadeAndDetach(hsScalar goal, hsScalar rate)
{
    ISetupFade(goal, rate, true, kFadeBlend);
}

// Fade --------------------------------------------------------------------------------
// -----
void plAGAnimInstance::Fade(hsScalar goal, hsScalar rate, UInt8 type /* = kFadeBlend */)
{
    ISetupFade(goal, rate, false, type);
}

// ISetupFade --------------------------------------------------------------------------
// -----------
void plAGAnimInstance::ISetupFade(hsScalar goal, hsScalar rate, bool detach, UInt8 type)
{
    if (rate == 0)
    {
        if (type == kFadeBlend)
        {
            SetBlend(goal);
            fFadeBlend = false;
            if(detach) {
                fMaster->DetachAnimation(this);
            }
        }
        else if (type == kFadeAmp)
        {
            SetAmplitude(goal);
            fFadeAmp = false;
        }
        return;
    }

    rate = (rate > 0 ? rate : -rate); // For old code that sends negative values
    
    hsScalar curVal = 0;
    switch (type)
    {
    case kFadeBlend:
        curVal = GetBlend();
        break;
    case kFadeAmp:
        curVal = GetAmplitude();
        break;
    }
    if (curVal > goal)
        rate = -rate;
    
    switch (type)
    {
    case kFadeBlend:
        fFadeBlend = true;      
        fFadeBlendGoal = goal;
        fFadeBlendRate = rate;
        fFadeDetach = detach;
        break;
    case kFadeAmp:
        fFadeAmp = true;
        fFadeAmpGoal = goal;
        fFadeAmpRate = rate;
        fFadeDetach = false;    // only detach on blend fades, for the moment.
        break;
    }
}

class agAlloc
{
public:
    agAlloc(plAGChannel *object, const char *chanName, const char *animName, UInt16 classIndex)
        : fObject(object),
          fClassIndex(classIndex)
    {
        fChannelName = hsStrcpy(chanName);
        fAnimName = hsStrcpy(animName);
    }

    ~agAlloc()
    {
        delete[] fChannelName;
        delete[] fAnimName;
    }

    plAGChannel *fObject;
    char *fChannelName;
    char *fAnimName;
    UInt16 fClassIndex;
};

typedef std::map<plAGChannel *, agAlloc *> agAllocMap;
static agAllocMap gAGAllocs;

void RegisterAGAlloc(plAGChannel *object, const char *chanName, const char *animName, UInt16 classIndex)
{
    gAGAllocs[object] = TRACKED_NEW agAlloc(object, chanName, animName, classIndex);
}

void DumpAGAllocs()
{
    agAllocMap::iterator i = gAGAllocs.begin();
    agAllocMap::iterator theEnd = gAGAllocs.end();

    hsStatusMessage("DUMPING AG ALLOCATIONS ================================================");

    for ( ; i != theEnd; i++)
    {
        agAlloc * al = (*i).second;

        UInt16 realClassIndex = al->fObject->ClassIndex();

        hsStatusMessageF("agAlloc: an: %s ch: %s, cl: %s", al->fAnimName, al->fChannelName, plFactory::GetNameOfClass(realClassIndex));

    }
    // it's not fast but it's safe and simple..
    i = gAGAllocs.begin();
    while(i != gAGAllocs.end())
    {
        agAlloc * al = (*i).second;
        delete al;

        i = gAGAllocs.erase(i);
    }
    hsStatusMessage("FINISHED DUMPING AG ALLOCATIONS *********************************************");
}

void UnRegisterAGAlloc(plAGChannel *object)
{
    agAllocMap::iterator i = gAGAllocs.find(object);
    if(i != gAGAllocs.end())
    {
        agAlloc * al = (*i).second;

        gAGAllocs.erase(i);
        delete al;
    }
}