//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//

#ifndef CHOREOEVENT_H
#define CHOREOEVENT_H
#ifdef _WIN32
#pragma once
#endif

class CChoreoActor;
class CChoreoChannel;
class CChoreoEvent;
class CChoreoScene;
class IChoreoEventCallback;
class CAudioMixer;
class CUtlBuffer;
class IChoreoStringPool;

#include "expressionsample.h"
#include "localflexcontroller.h"
#include "networkvar.h"
#include "tier1/utlstring.h"
#include "tier1/utlvector.h"

typedef CUtlString ChoreoStr_t;

//-----------------------------------------------------------------------------
// Purpose: SPEAK events can have "relative tags" that other objects can
// reference
//  to specify their start times off of
//-----------------------------------------------------------------------------
class CEventRelativeTag {
   public:
    DECLARE_CLASS_NOBASE(CEventRelativeTag);

    enum {
        MAX_EVENTTAG_LENGTH = 128,
    };

    CEventRelativeTag(CChoreoEvent *owner, const char *name, float percentage);
    CEventRelativeTag(const CEventRelativeTag &src);

    const char *GetName(void);
    float GetPercentage(void);
    void SetPercentage(float percentage);

    // Returns the corrected time based on the owner's length and start time
    float GetStartTime(void);
    CChoreoEvent *GetOwner(void);
    void SetOwner(CChoreoEvent *event);

   protected:
    ChoreoStr_t m_Name;
    float m_flPercentage;
    CChoreoEvent *m_pOwner;
};

//-----------------------------------------------------------------------------
// Purpose: GESTURE events can have "absolute tags" (where the value is not a
//  percentage, but an actual timestamp from the start of the event)
//-----------------------------------------------------------------------------
class CEventAbsoluteTag {
   public:
    enum {
        MAX_EVENTTAG_LENGTH = 128,
    };

    CEventAbsoluteTag(CChoreoEvent *owner, const char *name, float percentage);
    CEventAbsoluteTag(const CEventAbsoluteTag &src);

    const char *GetName(void);

    float GetPercentage(void);
    void SetPercentage(float percentage);

    float GetEventTime(void);
    void SetEventTime(float t);

    float GetAbsoluteTime(void);
    void SetAbsoluteTime(float t);

    CChoreoEvent *GetOwner(void);
    void SetOwner(CChoreoEvent *event);

    void SetLocked(bool bLocked);
    bool GetLocked(void);

    void SetLinear(bool bLinear);
    bool GetLinear(void);

    void SetEntry(bool bEntry);
    bool GetEntry(void);

    void SetExit(bool bExit);
    bool GetExit(void);

   protected:
    ChoreoStr_t m_Name;
    float m_flPercentage;
    bool m_bLocked : 1;
    bool m_bLinear : 1;
    bool m_bEntry : 1;
    bool m_bExit : 1;
    CChoreoEvent *m_pOwner;
};

//-----------------------------------------------------------------------------
// Purpose: FLEXANIMATION events can have "timing tags" that are used to align
// and
//  manipulate flex animation curves
//-----------------------------------------------------------------------------
class CFlexTimingTag : public CEventRelativeTag {
    DECLARE_CLASS(CFlexTimingTag, CEventRelativeTag);

   public:
    CFlexTimingTag(CChoreoEvent *owner, const char *name, float percentage,
                   bool locked);
    CFlexTimingTag(const CFlexTimingTag &src);

    bool GetLocked(void);
    void SetLocked(bool locked);

   protected:
    bool m_bLocked;
};

//-----------------------------------------------------------------------------
// Purpose: A flex controller position can be animated over a period of time
//-----------------------------------------------------------------------------
class CFlexAnimationTrack {
   public:
    enum {
        MAX_CONTROLLER_NAME = 128,
    };

    CFlexAnimationTrack(CChoreoEvent *event);
    CFlexAnimationTrack(const CFlexAnimationTrack *src);
    virtual ~CFlexAnimationTrack(void);

    void SetEvent(CChoreoEvent *event);
    CChoreoEvent *GetEvent(void);

    void SetFlexControllerName(const char *name);
    char const *GetFlexControllerName(void);

    void SetComboType(bool combo);
    bool IsComboType(void);

    void SetMin(float value);
    void SetMax(float value);
    float GetMin(int type = 0);
    float GetMax(int type = 0);

    bool IsInverted(void);
    void SetInverted(bool isInverted);

    int GetNumSamples(int type = 0);
    CExpressionSample *GetSample(int index, int type = 0);

    bool IsTrackActive(void);
    void SetTrackActive(bool active);

    // returns scaled value for absolute time per left/right side
    float GetIntensity(float time, int side = 0);

    CExpressionSample *AddSample(float time, float value, int type = 0);
    void RemoveSample(int index, int type = 0);
    void Clear(void);

    void Resort(int type = 0);

    // Puts in dummy start/end samples to spline to zero ( or 0.5 for
    //  left/right data) at the origins
    CExpressionSample *GetBoundedSample(int number, bool &bClamped,
                                        int type = 0);

    int GetFlexControllerIndex(int side = 0);
    LocalFlexController_t GetRawFlexControllerIndex(int side = 0);
    void SetFlexControllerIndex(LocalFlexController_t raw, int index,
                                int side = 0);

    // returns 0..1 value for 0..1 time fraction per mag/balance
    float GetFracIntensity(float time, int type);

    // retrieves raw intensity values (for mag vs. left/right slider setting)
    float GetSampleIntensity(float time);
    float GetBalanceIntensity(float time);

    void SetEdgeInfo(bool leftEdge, int curveType, float zero);
    void GetEdgeInfo(bool leftEdge, int &curveType, float &zero) const;
    void SetEdgeActive(bool leftEdge, bool state);
    bool IsEdgeActive(bool leftEdge) const;
    int GetEdgeCurveType(bool leftEdge) const;
    float GetEdgeZeroValue(bool leftEdge) const;

    float GetDefaultEdgeZeroPos() const;

    void SetServerSide(bool state);
    bool IsServerSide() const;

   private:
    // remove any samples after endtime
    void RemoveOutOfRangeSamples(int type);

    // returns scaled value for absolute time per mag/balance
    float GetIntensityInternal(float time, int type);

   public:
    // returns the fractional (0..1) value for "zero" based on Min/Max ranges
    float GetZeroValue(int type, bool leftSide);

   private:
    char *m_pControllerName;

    // base track has range, combo is always 0..1
    float m_flMin;
    float m_flMax;

    // 0 == magnitude
    // 1 == left/right
    CUtlVector<CExpressionSample> m_Samples[2];
    int m_nFlexControllerIndex[2];
    LocalFlexController_t m_nFlexControllerIndexRaw[2];

    // For left and right edge of type 0 flex data ( magnitude track )
    EdgeInfo_t m_EdgeInfo[2];

    CChoreoEvent *m_pEvent;

    // Is track active
    bool m_bActive : 1;

    // Is this a combo (magnitude + stereo) track
    bool m_bCombo : 1;
    bool m_bServerSide : 1;

    bool m_bInverted;  // track is displayed 1..0 instead of 0..1
};

//-----------------------------------------------------------------------------
// Purpose: The generic scene event type
//-----------------------------------------------------------------------------
class CChoreoEvent : public ICurveDataAccessor {
   public:
    // Type of event this object represents
    typedef enum {
        // Don't know yet
        UNSPECIFIED = 0,

        // Section start/end
        SECTION,

        // Play an expression
        EXPRESSION,

        // Look at another actor
        LOOKAT,

        // Move to a location
        MOVETO,

        // Speak/visemes a wave file
        SPEAK,

        // Play a gesture
        GESTURE,

        // Play a sequence
        SEQUENCE,

        // Face another actor
        FACE,

        // Fire a trigger
        FIRETRIGGER,

        // One or more flex sliders animated over the course of the event time
        // period
        FLEXANIMATION,

        // A contained .vcd file
        SUBSCENE,

        // Loop back to previous time (forever or up to N times)
        LOOP,

        // A time span during which the scene may be temporarily interrupted
        INTERRUPT,

        // A dummy event that is used to mark the .vcd end time
        STOPPOINT,

        // A time span during which this actor can respond to events happening
        // in the world, etc.
        PERMIT_RESPONSES,

        // A string passed to the game code for interpretation
        GENERIC,

        // THIS MUST BE LAST!!!
        NUM_TYPES,
    } EVENTTYPE;

    enum {
        MAX_TAGNAME_STRING = 128,
        MAX_CCTOKEN_STRING = 64,
    };

    typedef enum {
        DEFAULT = 0,
        SIMULATION,
        DISPLAY,
    } TIMETYPE;

    typedef enum {
        CC_MASTER = 0,  // default, implied
        CC_SLAVE,
        CC_DISABLED,

        NUM_CC_TYPES,
    } CLOSECAPTION;

    static int s_nGlobalID;

    // Construction
    CChoreoEvent(CChoreoScene *scene);
    CChoreoEvent(CChoreoScene *scene, EVENTTYPE type, const char *name);
    CChoreoEvent(CChoreoScene *scene, EVENTTYPE type, const char *name,
                 const char *param);

    // Assignment
    CChoreoEvent &operator=(const CChoreoEvent &src);

    ~CChoreoEvent(void);

    // ICurveDataAccessor methods
    virtual bool CurveHasEndTime();
    virtual int GetDefaultCurveType();

    // Binary serialization
    void SaveToBuffer(CUtlBuffer &buf, CChoreoScene *pScene,
                      IChoreoStringPool *pStringPool);
    bool RestoreFromBuffer(CUtlBuffer &buf, CChoreoScene *pScene,
                           IChoreoStringPool *pStringPool);

    // Accessors
    EVENTTYPE GetType(void);
    void SetType(EVENTTYPE type);

    void SetName(const char *name);
    const char *GetName(void);

    void SetParameters(const char *target);
    const char *GetParameters(void);
    void SetParameters2(const char *target);
    const char *GetParameters2(void);
    void SetParameters3(const char *target);
    const char *GetParameters3(void);

    void SetStartTime(float starttime);
    float GetStartTime(void);

    void SetEndTime(float endtime);
    float GetEndTime(void);

    float GetDuration(void);

    void SetResumeCondition(bool resumecondition);
    bool IsResumeCondition(void);

    void SetLockBodyFacing(bool lockbodyfacing);
    bool IsLockBodyFacing(void);

    void SetDistanceToTarget(float distancetotarget);
    float GetDistanceToTarget(void);

    void SetForceShortMovement(bool bForceShortMovement);
    bool GetForceShortMovement(void);

    void SetSyncToFollowingGesture(bool bSyncToFollowingGesture);
    bool GetSyncToFollowingGesture(void);

    void SetPlayOverScript(bool bPlayOverScript);
    bool GetPlayOverScript(void);

    int GetRampCount(void) { return m_Ramp.GetCount(); };
    CExpressionSample *GetRamp(int index) { return m_Ramp.Get(index); };
    CExpressionSample *AddRamp(float time, float value, bool selected) {
        return m_Ramp.Add(time, value, selected);
    };
    void DeleteRamp(int index) { m_Ramp.Delete(index); };
    void ClearRamp(void) { m_Ramp.Clear(); };
    void ResortRamp(void) { m_Ramp.Resort(this); };
    CCurveData *GetRamp(void) { return &m_Ramp; };

    float GetRampIntensity(float time) {
        return m_Ramp.GetIntensity(this, time);
    };

    // Calculates weighting for a given time
    float GetIntensity(float scenetime);
    float GetIntensityArea(float scenetime);

    // Calculates 0..1 completion for a given time
    float GetCompletion(float time);

    // An end time of -1.0f means that the events is just triggered at the
    // leading edge
    bool HasEndTime(void);

    // Is the event something that can be sized ( a wave file, e.g. )
    bool IsFixedLength(void);
    void SetFixedLength(bool isfixedlength);

    // Move the start/end/both times by the specified dt (fixes up -1.0f
    // endtimes)
    void OffsetStartTime(float dt);
    void OffsetEndTime(float dt);
    void OffsetTime(float dt);

    // Snap to scene framerate
    void SnapTimes(void);
    float SnapTime(float t);

    CChoreoScene *GetScene(void);
    void SetScene(CChoreoScene *scene);

    // The actor the event is associated with
    void SetActor(CChoreoActor *actor);
    CChoreoActor *GetActor(void);

    // The channel the event is associated with
    void SetChannel(CChoreoChannel *channel);
    CChoreoChannel *GetChannel(void);

    // Get a more involved description of the event
    const char *GetDescription(void);

    void ClearAllRelativeTags(void);
    int GetNumRelativeTags(void);
    CEventRelativeTag *GetRelativeTag(int tagnum);
    CEventRelativeTag *FindRelativeTag(const char *tagname);
    void AddRelativeTag(const char *tagname, float percentage);
    void RemoveRelativeTag(const char *tagname);

    bool IsUsingRelativeTag(void);
    void SetUsingRelativeTag(bool usetag, const char *tagname = 0,
                             const char *wavname = 0);
    const char *GetRelativeTagName(void);
    const char *GetRelativeWavName(void);

    // Absolute tags
    typedef enum {
        PLAYBACK = 0,  // new timeline		- FIXME: should be stored as an
                       // absolute time
        ORIGINAL,  // original timeline - FIXME: should be stored at a fixed
                   // percentage of event

        NUM_ABS_TAG_TYPES,
    } AbsTagType;

    void SetGestureSequenceDuration(float duration);
    bool GetGestureSequenceDuration(float &duration);

    void ClearAllAbsoluteTags(AbsTagType type);
    int GetNumAbsoluteTags(AbsTagType type);
    CEventAbsoluteTag *GetAbsoluteTag(AbsTagType type, int tagnum);
    CEventAbsoluteTag *FindAbsoluteTag(AbsTagType type, const char *tagname);
    void AddAbsoluteTag(AbsTagType type, const char *tagname, float t);
    void RemoveAbsoluteTag(AbsTagType type, const char *tagname);
    bool VerifyTagOrder(void);
    float GetOriginalPercentageFromPlaybackPercentage(float t);
    float GetPlaybackPercentageFromOriginalPercentage(float t);

    static const char *NameForAbsoluteTagType(AbsTagType t);
    static AbsTagType TypeForAbsoluteTagName(const char *name);

    void RescaleGestureTimes(float newstart, float newend,
                             bool bMaintainAbsoluteTagPositions);
    bool PreventTagOverlap(void);

    CEventAbsoluteTag *FindEntryTag(AbsTagType type);
    CEventAbsoluteTag *FindExitTag(AbsTagType type);

    // Flex animation type
    int GetNumFlexAnimationTracks(void);
    CFlexAnimationTrack *GetFlexAnimationTrack(int index);
    CFlexAnimationTrack *AddTrack(const char *controllername);
    CFlexAnimationTrack *FindTrack(const char *controllername);
    void RemoveTrack(int index);
    void RemoveAllTracks(void);
    void OnEndTimeChanged(void);

    bool GetTrackLookupSet(void);
    void SetTrackLookupSet(bool set);

    // Flex Timing Tags (used by editor only)
    void ClearAllTimingTags(void);
    int GetNumTimingTags(void);
    CFlexTimingTag *GetTimingTag(int tagnum);
    CFlexTimingTag *FindTimingTag(const char *tagname);
    void AddTimingTag(const char *tagname, float percentage, bool locked);
    void RemoveTimingTag(const char *tagname);

    // Subscene ( embedded .vcd ) support
    void SetSubScene(CChoreoScene *scene);
    CChoreoScene *GetSubScene(void);

    bool IsProcessing(void) const;
    void StartProcessing(IChoreoEventCallback *cb, CChoreoScene *scene,
                         float t);
    void ContinueProcessing(IChoreoEventCallback *cb, CChoreoScene *scene,
                            float t);
    void StopProcessing(IChoreoEventCallback *cb, CChoreoScene *scene, float t);
    bool CheckProcessing(IChoreoEventCallback *cb, CChoreoScene *scene,
                         float t);
    void ResetProcessing(void);

    void SetMixer(CAudioMixer *mixer);
    CAudioMixer *GetMixer(void) const;

    // Hack for LOOKAT in editor
    int GetPitch(void) const;
    void SetPitch(int pitch);
    int GetYaw(void) const;
    void SetYaw(int yaw);

    // For LOOP events
    void SetLoopCount(int numloops);
    int GetLoopCount(void);
    int GetNumLoopsRemaining(void);
    void SetNumLoopsRemaining(int loops);

    bool IsMarkedForSave() const { return m_bMarkedForSave; }
    void SetMarkedForSave(bool mark) { m_bMarkedForSave = mark; }

    void GetMovementStyle(char *style, int maxlen);
    void GetDistanceStyle(char *style, int maxlen);

    int GetGlobalID() const { return m_nGlobalID; }

    // Localization/CC support (close captioning and multiple wave file
    // recombination)
    void SetCloseCaptionType(CLOSECAPTION type);
    CLOSECAPTION GetCloseCaptionType() const;
    void SetCloseCaptionToken(char const *token);
    char const *GetCloseCaptionToken() const;
    void SetUsingCombinedFile(bool isusing);
    bool IsUsingCombinedFile() const;
    void SetRequiredCombinedChecksum(unsigned int checksum);
    unsigned int GetRequiredCombinedChecksum();
    void SetNumSlaves(int num);
    int GetNumSlaves() const;
    void SetLastSlaveEndTime(float t);
    float GetLastSlaveEndTime() const;
    void SetCloseCaptionTokenValid(bool valid);
    bool GetCloseCaptionTokenValid() const;

    bool ComputeCombinedBaseFileName(char *dest, int destlen,
                                     bool creategenderwildcard);
    bool IsCombinedUsingGenderToken() const;
    void SetCombinedUsingGenderToken(bool using_gender);

    bool IsSuppressingCaptionAttenuation() const;
    void SetSuppressingCaptionAttenuation(bool suppress);

    int ValidateCombinedFile();

    // This returns false if the wave is CC_DISABLED or is a CC_SLAVE,
    //  otherwise it returns the actual m_szCCToken value, or if that's
    //  blank it'll return the sounds.txt entry name (m_szParameters)
    bool GetPlaybackCloseCaptionToken(char *dest, int destlen);

    void ClearEventDependencies();
    void AddEventDependency(CChoreoEvent *other);
    void GetEventDependencies(CUtlVector<CChoreoEvent *> &list);

    void SetActive(bool state);
    bool GetActive() const;

    void SetDefaultCurveType(int nCurveType);

    // Turn enum into string and vice versa
    static EVENTTYPE TypeForName(const char *name);
    static const char *NameForType(EVENTTYPE type);

    // Turn enum into string and vice versa
    static CLOSECAPTION CCTypeForName(const char *name);
    static const char *NameForCCType(CLOSECAPTION type);

   private:
    // Declare copy constructor private to prevent accidental usage...
    CChoreoEvent(const CChoreoEvent &src);

    void SaveFlexAnimationsToBuffer(CUtlBuffer &buf,
                                    IChoreoStringPool *pStringPool);
    bool RestoreFlexAnimationsFromBuffer(CUtlBuffer &buf,
                                         IChoreoStringPool *pStringPool);

    float GetBoundedAbsoluteTagPercentage(AbsTagType type, int tagnum);

    float _GetIntensity(float time);

    // String bounds
    enum {
        MAX_CHOREOEVENT_NAME = 128,
        MAX_PARAMETERS_STRING = 128,
    };

    // Base initialization
    void Init(CChoreoScene *scene);

    // Type of event
    byte m_fType;

    // Close caption type
    byte m_ccType;

    // Name of event
    ChoreoStr_t m_Name;

    // Event parameters
    ChoreoStr_t m_Parameters;
    ChoreoStr_t m_Parameters2;
    ChoreoStr_t m_Parameters3;

    // Event start time
    float m_flStartTime;

    // Event end time ( -1.0f means no ending, just leading edge triggered )
    float m_flEndTime;

    // Duration of underlying gesture sequence
    float m_flGestureSequenceDuration;

    // For CChoreoEvent::LOOP
    int m_nNumLoops;  // -1 == no limit
    int m_nLoopsRemaining;

    // Overall intensity curve
    CCurveData m_Ramp;

    // Start time is computed based on length of item referenced by tagged name
    ChoreoStr_t m_TagName;
    ChoreoStr_t m_TagWavName;

    // Associated actor
    CChoreoActor *m_pActor;
    // Associated channel
    CChoreoChannel *m_pChannel;

    CUtlVector<CEventRelativeTag> m_RelativeTags;
    CUtlVector<CFlexTimingTag> m_TimingTags;
    CUtlVector<CEventAbsoluteTag> m_AbsoluteTags[NUM_ABS_TAG_TYPES];

    CUtlVector<CFlexAnimationTrack *> m_FlexAnimationTracks;

    CChoreoScene *m_pSubScene;
    CAudioMixer *m_pMixer;

    // Scene which owns this event
    CChoreoScene *m_pScene;

    int m_nPitch;
    int m_nYaw;

    float m_flDistanceToTarget;

    int m_nGlobalID;

    ChoreoStr_t m_CCToken;
    unsigned int m_uRequiredCombinedChecksum;
    // on master only, the combined file must have the same checksum to be
    // useable
    int m_nNumSlaves;
    // Only set on master, helps UI draw underbar
    float m_flLastSlaveEndTime;
    // true if the cc token was found in the cc manager's database

    CUtlVector<CChoreoEvent *> m_Dependencies;

    int m_nDefaultCurveType;

   public:
    // used only during scrubbing of looping sequences
    float m_flPrevCycle;
    float m_flPrevTime;

    // Flags

    bool m_bFixedLength : 1;
    // True if this event must be "finished" before the next section can be
    // started
    //  after playback is paused from a globalevent
    bool m_bResumeCondition : 1;
    bool m_bUsesTag : 1;
    bool m_bTrackLookupSet : 1;
    bool m_bProcessing : 1;
    bool m_bLockBodyFacing : 1;
    // Purely for save/load
    bool m_bMarkedForSave : 1;
    bool m_bUsingCombinedSoundFile : 1;
    bool m_bCCTokenValid : 1;
    bool m_bCombinedUsingGenderToken : 1;

    bool m_bSuppressCaptionAttenuation : 1;

    bool m_bForceShortMovement : 1;
    bool m_bSyncToFollowingGesture : 1;
    bool m_bActive : 1;
    bool m_bPlayOverScript : 1;
};

#endif  // CHOREOEVENT_H