//========= Copyright Valve Corporation, All rights reserved. ============//
//=======================================================================================//

#if defined(REPLAY_ENABLED)

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

//----------------------------------------------------------------------------------------

#include "GameEventListener.h"
#include "replay/iclientreplaycontext.h"
#include "replay/replay.h"

// For RoundStats_t
#include "replay/gamedefs.h"

//----------------------------------------------------------------------------------------

extern IClientReplayContext *g_pClientReplayContext;

//----------------------------------------------------------------------------------------

class CGenericClassBasedReplay : public CReplay, public CGameEventListener {
    typedef CReplay BaseClass;

   public:
    CGenericClassBasedReplay();
    ~CGenericClassBasedReplay();

    virtual void OnBeginRecording();
    virtual void OnEndRecording();
    virtual void OnComplete();
    virtual bool ShouldAllowDelete() const;
    virtual void OnDelete();

    virtual void FireGameEvent(IGameEvent *pEvent);

    virtual bool Read(KeyValues *pIn);
    virtual void Write(KeyValues *pOut);

    virtual void DumpGameSpecificData() const;

    void SetPlayerClass(int nPlayerClass);
    void SetPlayerTeam(int nPlayerTeam);

    void RecordPlayerDeath(const char *pKillerName, int nKillerClass);

    // Add a new kill to the list
    void AddKill(const char *pPlayerName, int nPlayerClass);

    // Get the player class as a string
    virtual const char *GetPlayerClass() const;

    // Get the player team as a string
    virtual const char *GetPlayerTeam() const = 0;

    // Utility to get the material-friendly player class (demoman->demo,
    // heavyweapons->heavy)
    virtual const char *GetMaterialFriendlyPlayerClass() const;

    // Was there a killer?
    inline bool WasKilled() const { return m_szKillerName[0] != 0; }

    // Get killer name
    const char *GetKillerName() const;

    // Get the killer class, if there was a killer
    const char *GetKillerClass() const;

    int GetDownloadStatus() const;

    // Kill info
    struct KillData_t {
        char m_szPlayerName[MAX_OSPATH];
        int m_nPlayerClass;
    };

    inline int GetKillCount() const { return m_vecKills.Count(); }
    inline const KillData_t *GetKill(int nKillIndex) {
        return m_vecKills[nKillIndex];
    }

    // A generic info struct used for dominations, assisted dominations,
    // revenges, assisted revenged... Not all data members are necessarily used
    struct GenericStatInfo_t {
        GenericStatInfo_t() : m_nVictimFriendId(0), m_nAssisterFriendId(0) {}
        uint32 m_nVictimFriendId;
        uint32 m_nAssisterFriendId;
    };

    inline int GetDominationCount() const { return m_vecDominations.Count(); }
    inline const GenericStatInfo_t *GetDomination(int nIndex) const {
        return m_vecDominations[nIndex];
    }

    inline int GetAssisterDominationCount() const {
        return m_vecAssisterDominations.Count();
    }
    inline const GenericStatInfo_t *GetAssisterDomination(int nIndex) const {
        return m_vecAssisterDominations[nIndex];
    }

    inline int GetRevengeCount() const { return m_vecRevenges.Count(); }
    inline const GenericStatInfo_t *GetRevenge(int nIndex) const {
        return m_vecRevenges[nIndex];
    }

    inline int GetAssisterRevengeCount() const {
        return m_vecAssisterRevenges.Count();
    }
    inline const GenericStatInfo_t *GetAssisterRevenge(int nIndex) const {
        return m_vecAssisterRevenges[nIndex];
    }

    RoundStats_t const &GetStats() const { return m_lifeStats; }

   protected:
    int m_nPlayerClass;
    int m_nPlayerTeam;
    int m_nStatUndefined;

    char m_szKillerName[MAX_OSPATH];
    int m_nKillerClass;

    virtual bool IsValidClass(int nClass) const = 0;
    virtual bool IsValidTeam(int iTeam) const = 0;
    virtual bool GetCurrentStats(RoundStats_t &out) = 0;
    virtual const char *GetStatString(int iStat) const = 0;
    virtual const char *GetPlayerClass(int iClass) const = 0;

    virtual void Update();

    // Domination
    void AddDomination(int nVictimID);
    void AddAssisterDomination(int nVictimID, int nAssiterID);

    void AddRevenge(int nVictimID);
    void AddAssisterRevenge(int nVictimID, int nAssiterID);

    float GetKillScreenshotDelay();

    RoundStats_t m_refStats;   // Reference stats, used to compute current stats
    RoundStats_t m_lifeStats;  // Stats for this life, based on reference stats
                               // (m_refStats)

   private:
    void MedicUpdate();

    bool GetFriendIdFromUserId(int nPlayerIndex, uint32 &nFriendIdOut)
        const;  // Get a friend ID based on player index.  Returns true on
                // success
    void AddKillStatFromUserIds(CUtlVector<GenericStatInfo_t *> &vec,
                                int nVictimId, int nAssisterId = 0);
    void AddKillStatFromFriendIds(CUtlVector<GenericStatInfo_t *> &vec,
                                  uint32 nVictimFriendId,
                                  uint32 nAssisterFriendId = 0);
    void WriteKillStatVector(CUtlVector<GenericStatInfo_t *> const &vec,
                             const char *pSubKeyName,
                             const char *pElementKeyName, KeyValues *pRootKey,
                             int nNumMembersToWrite) const;
    void AddKillStats(CUtlVector<GenericStatInfo_t *> &vecKillStats,
                      KeyValues *pIn, const char *pSubKeyName, int iStatIndex);
    void RecordUpdatedStats();

    CUtlVector<KillData_t *> m_vecKills;
    CUtlVector<GenericStatInfo_t *> m_vecDominations;
    CUtlVector<GenericStatInfo_t *> m_vecAssisterDominations;
    CUtlVector<GenericStatInfo_t *> m_vecRevenges;
    CUtlVector<GenericStatInfo_t *> m_vecAssisterRevenges;

    // TODO... dominations, achievements, etc.
};

//----------------------------------------------------------------------------------------

inline CGenericClassBasedReplay *ToGenericClassBasedReplay(
    CReplay *pClientReplay) {
    return static_cast<CGenericClassBasedReplay *>(pClientReplay);
}

inline const CGenericClassBasedReplay *ToGenericClassBasedReplay(
    const CReplay *pClientReplay) {
    return static_cast<const CGenericClassBasedReplay *>(pClientReplay);
}

inline CGenericClassBasedReplay *GetGenericClassBasedReplay(
    ReplayHandle_t hReplay) {
    return ToGenericClassBasedReplay(
        g_pClientReplayContext->GetReplay(hReplay));
}

//----------------------------------------------------------------------------------------

#endif  // GENERICCLASSBASED_REPLAY_H

#endif