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

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

#include "shareddefs.h"

#define TEAM_ARRAY(index, team) (index + (team * MAX_CONTROL_POINTS))

//-----------------------------------------------------------------------------
// Purpose: An entity that networks the state of the game's objectives.
//			May contain data for objectives that aren't used by your
//mod, but 			the extra data will never be networked as long as it's zeroed out.
//-----------------------------------------------------------------------------
class CBaseTeamObjectiveResource : public CBaseEntity {
    DECLARE_CLASS(CBaseTeamObjectiveResource, CBaseEntity);

   public:
    DECLARE_SERVERCLASS();
    DECLARE_DATADESC();

    CBaseTeamObjectiveResource();
    ~CBaseTeamObjectiveResource();

    virtual void Spawn(void);
    virtual int UpdateTransmitState(void);

    virtual void ObjectiveThink(void);

    //--------------------------------------------------------------------
    // CONTROL POINT DATA
    //--------------------------------------------------------------------
   public:
    void ResetControlPoints(void);

    // Data functions, called to set up the state at the beginning of a round
    void SetNumControlPoints(int num);
    int GetNumControlPoints(void) { return m_iNumControlPoints; }
    void SetCPIcons(int index, int iTeam, int iIcon);
    void SetCPOverlays(int index, int iTeam, int iIcon);
    void SetTeamBaseIcons(int iTeam, int iBaseIcon);
    void SetCPPosition(int index, const Vector &vPosition);
    void SetCPVisible(int index, bool bVisible);
    void SetCPRequiredCappers(int index, int iTeam, int iReqPlayers);
    void SetCPCapTime(int index, int iTeam, float flTime);
    void SetCPCapPercentage(int index, float flTime);
    float GetCPCapPercentage(int index);
    void SetTeamCanCap(int index, int iTeam, bool bCanCap);
    void SetBaseCP(int index, int iTeam);
    void SetPreviousPoint(int index, int iTeam, int iPrevIndex, int iPrevPoint);
    int GetPreviousPointForPoint(int index, int team, int iPrevIndex);
    bool TeamCanCapPoint(int index, int team);
    void SetCapLayoutInHUD(const char *pszLayout) {
        Q_strncpy(m_pszCapLayoutInHUD.GetForModify(), pszLayout,
                  MAX_CAPLAYOUT_LENGTH);
    }
    void SetCapLayoutCustomPosition(float flPositionX, float flPositionY) {
        m_flCustomPositionX = flPositionX;
        m_flCustomPositionY = flPositionY;
    }
    void SetWarnOnCap(int index, int iWarnLevel);
    void SetWarnSound(int index, string_t iszSound);
    void SetCPGroup(int index, int iCPGroup);
    void SetCPLocked(int index, bool bLocked);
    void SetTrackAlarm(int index, bool bAlarm);
    void SetCPUnlockTime(int index, float flTime);
    void SetCPTimerTime(int index, float flTime);
    void SetCPCapTimeScalesWithPlayers(int index, bool bScales);

    // State functions, called many times
    void SetNumPlayers(int index, int team, int iNumPlayers);
    void StartCap(int index, int team);
    void SetOwningTeam(int index, int team);
    void SetCappingTeam(int index, int team);
    void SetTeamInZone(int index, int team);
    void SetCapBlocked(int index, bool bBlocked);
    int GetOwningTeam(int index);

    void AssertValidIndex(int index) {
        Assert(0 <= index && index <= MAX_CONTROL_POINTS &&
               index < m_iNumControlPoints);
    }

    int GetBaseControlPointForTeam(int iTeam) {
        Assert(iTeam < MAX_TEAMS);
        return m_iBaseControlPoints[iTeam];
    }

    int GetCappingTeam(int index) {
        if (index >= m_iNumControlPoints) return TEAM_UNASSIGNED;

        return m_iCappingTeam[index];
    }

    void SetTimerInHUD(CBaseEntity *pTimer) {
        m_iTimerToShowInHUD = pTimer ? pTimer->entindex() : 0;
    }

    void SetStopWatchTimer(CBaseEntity *pTimer) {
        m_iStopWatchTimer = pTimer ? pTimer->entindex() : 0;
    }

    int GetTimerInHUD(void) { return m_iTimerToShowInHUD; }

    // Mini-rounds data
    void SetPlayingMiniRounds(bool bPlayingMiniRounds) {
        m_bPlayingMiniRounds = bPlayingMiniRounds;
    }
    bool PlayingMiniRounds(void) { return m_bPlayingMiniRounds; }
    void SetInMiniRound(int index, bool bInRound) {
        m_bInMiniRound.Set(index, bInRound);
    }
    bool IsInMiniRound(int index) { return m_bInMiniRound[index]; }

    void UpdateCapHudElement(void);

    // Train Path data
    void SetTrainPathDistance(int index, float flDistance);

    bool GetCPLocked(int index) {
        Assert(index < m_iNumControlPoints);
        return m_bCPLocked[index];
    }

    void ResetHillData(int team) {
        if (team < TEAM_TRAIN_MAX_TEAMS) {
            m_nNumNodeHillData.Set(team, 0);

            int nNumEntriesPerTeam =
                TEAM_TRAIN_MAX_HILLS * TEAM_TRAIN_FLOATS_PER_HILL;
            int iStartingIndex = team * nNumEntriesPerTeam;
            for (int i = 0; i < nNumEntriesPerTeam; i++) {
                m_flNodeHillData.Set(iStartingIndex + i, 0);
            }

            iStartingIndex = team * TEAM_TRAIN_MAX_HILLS;
            for (int i = 0; i < TEAM_TRAIN_MAX_HILLS; i++) {
                m_bHillIsDownhill.Set(iStartingIndex + i, 0);
            }
        }
    }

    void SetHillData(int team, float flStart, float flEnd, bool bDownhill) {
        if (team < TEAM_TRAIN_MAX_TEAMS) {
            int index =
                (m_nNumNodeHillData[team] * TEAM_TRAIN_FLOATS_PER_HILL) +
                (team * TEAM_TRAIN_MAX_HILLS * TEAM_TRAIN_FLOATS_PER_HILL);
            if (index < TEAM_TRAIN_HILLS_ARRAY_SIZE -
                            1)  // - 1 because we want to add 2 entries
            {
                m_flNodeHillData.Set(index, flStart);
                m_flNodeHillData.Set(index + 1, flEnd);

                if (m_nNumNodeHillData[team] < TEAM_TRAIN_MAX_HILLS) {
                    m_bHillIsDownhill.Set(m_nNumNodeHillData[team] +
                                              (team * TEAM_TRAIN_MAX_HILLS),
                                          bDownhill);
                }

                m_nNumNodeHillData.Set(team, m_nNumNodeHillData[team] + 1);
            }
        }
    }

   private:
    CNetworkVar(int, m_iTimerToShowInHUD);
    CNetworkVar(int, m_iStopWatchTimer);

    CNetworkVar(int, m_iNumControlPoints);
    CNetworkVar(bool, m_bPlayingMiniRounds);
    CNetworkVar(bool, m_bControlPointsReset);
    CNetworkVar(int, m_iUpdateCapHudParity);

    // data variables
    CNetworkArray(Vector, m_vCPPositions, MAX_CONTROL_POINTS);
    CNetworkArray(int, m_bCPIsVisible, MAX_CONTROL_POINTS);
    CNetworkArray(float, m_flLazyCapPerc, MAX_CONTROL_POINTS);
    CNetworkArray(int, m_iTeamIcons,
                  MAX_CONTROL_POINTS *MAX_CONTROL_POINT_TEAMS);
    CNetworkArray(int, m_iTeamOverlays,
                  MAX_CONTROL_POINTS *MAX_CONTROL_POINT_TEAMS);
    CNetworkArray(int, m_iTeamReqCappers,
                  MAX_CONTROL_POINTS *MAX_CONTROL_POINT_TEAMS);
    CNetworkArray(float, m_flTeamCapTime,
                  MAX_CONTROL_POINTS *MAX_CONTROL_POINT_TEAMS);
    CNetworkArray(
        int, m_iPreviousPoints,
        MAX_CONTROL_POINTS *MAX_CONTROL_POINT_TEAMS *MAX_PREVIOUS_POINTS);
    CNetworkArray(bool, m_bTeamCanCap,
                  MAX_CONTROL_POINTS *MAX_CONTROL_POINT_TEAMS);
    CNetworkArray(int, m_iTeamBaseIcons, MAX_TEAMS);
    CNetworkArray(int, m_iBaseControlPoints, MAX_TEAMS);
    CNetworkArray(bool, m_bInMiniRound, MAX_CONTROL_POINTS);
    CNetworkArray(int, m_iWarnOnCap, MAX_CONTROL_POINTS);
    CNetworkArray(string_t, m_iszWarnSound, MAX_CONTROL_POINTS);
    CNetworkArray(float, m_flPathDistance, MAX_CONTROL_POINTS);
    CNetworkArray(bool, m_bCPLocked, MAX_CONTROL_POINTS);
    CNetworkArray(float, m_flUnlockTimes, MAX_CONTROL_POINTS);
    CNetworkArray(float, m_flCPTimerTimes, MAX_CONTROL_POINTS);

    // change when players enter/exit an area
    CNetworkArray(int, m_iNumTeamMembers,
                  MAX_CONTROL_POINTS *MAX_CONTROL_POINT_TEAMS);

    // changes when a cap starts. start and end times are calculated on client
    CNetworkArray(int, m_iCappingTeam, MAX_CONTROL_POINTS);

    CNetworkArray(int, m_iTeamInZone, MAX_CONTROL_POINTS);
    CNetworkArray(bool, m_bBlocked, MAX_CONTROL_POINTS);

    // changes when a point is successfully captured
    CNetworkArray(int, m_iOwner, MAX_CONTROL_POINTS);
    CNetworkArray(bool, m_bCPCapRateScalesWithPlayers, MAX_CONTROL_POINTS);

    // describes how to lay out the cap points in the hud
    CNetworkString(m_pszCapLayoutInHUD, MAX_CAPLAYOUT_LENGTH);

    // custom screen position for the cap points in the hud
    CNetworkVar(float, m_flCustomPositionX);
    CNetworkVar(float, m_flCustomPositionY);

    // the groups the points belong to
    CNetworkArray(int, m_iCPGroup, MAX_CONTROL_POINTS);

    // Not networked, because the client recalculates it
    float m_flCapPercentages[MAX_CONTROL_POINTS];

    // hill data for multi-escort payload maps
    CNetworkArray(int, m_nNumNodeHillData, TEAM_TRAIN_MAX_TEAMS);
    CNetworkArray(float, m_flNodeHillData, TEAM_TRAIN_HILLS_ARRAY_SIZE);

    CNetworkArray(bool, m_bTrackAlarm, TEAM_TRAIN_MAX_TEAMS);
    CNetworkArray(bool, m_bHillIsDownhill,
                  TEAM_TRAIN_MAX_HILLS *TEAM_TRAIN_MAX_TEAMS);
};

extern CBaseTeamObjectiveResource *g_pObjectiveResource;

inline CBaseTeamObjectiveResource *ObjectiveResource() {
    return g_pObjectiveResource;
}

#endif  // TEAM_OBJECTIVERESOURCE_H