#include <deque>
#include <vector>
#include "doomtype.h"
#include "networkshared.h"
#include "sv_main.h"
#include "zstring.h"

//-----------------------------------------------------------------------------
// Defines
//-----------------------------------------------------------------------------

#define JOINQUEUE_DEFAULT_TIMEOUT (5 * 60 * TICRATE)
#define JOINQUEUE_NOT_IN_LINE -1
#define JOINQUEUE_NO_POSITION -1

//-----------------------------------------------------------------------------
// Enums
//-----------------------------------------------------------------------------
typedef enum {
    JQPRIORITY_ANY = 0, // The first player found (either random or specific team)
    JQPRIORITY_RANDOM = 1, // Priority given to random's
    JQPRIORITY_SPECIFIC = 2, // Priority given to people who want that specific team
} JoinQueueTeamPriorityType_e;

//-----------------------------------------------------------------------------
// Structures
//-----------------------------------------------------------------------------

// Encapsulates a join entry
typedef struct {

    // The player identifier
    ULONG ulPlayer;

    // The team the player wishes to join
    ULONG ulTeam;

    // The address the player was connected with (to see if they reconnect)
    NETADDRESS_s netAddress;

    // The gametic the user joined the queue with
    int gameticJoinedQueue;

} JoinQueueEntry_t;

//-----------------------------------------------------------------------------
// Classes
//-----------------------------------------------------------------------------

// A class that contains operations for a functioning join queue
// The front of the queue holds the players who are first in line to be picked
class JoinQueue {
private:
    std::deque<JoinQueueEntry_t> queue; // The queue that holds all the players who want to join
    LONG timeoutTicThreshold; // How long until a disconnected player is purged

    bool popIntoGame(const ULONG ulPosition);

public:
    JoinQueue();
    ~JoinQueue();

    void addPlayerToFrontOfQueue(JoinQueueEntry_t playerEntry);
    void addPlayerToBackOfQueue(JoinQueueEntry_t playerEntry);
    bool addPlayerToQueuePosition(JoinQueueEntry_t playerEntry, const ULONG ulPosition);
    
    bool popPlayerIntoGame(const ULONG ulPlayer);
    bool popPositionIntoGame(const ULONG ulPosition);
    bool popTeamIntoGame(const ULONG ulTeam, JoinQueueTeamPriorityType_e priorityEnum);

    int getQueuePosition(ULONG ulPlayer);

    JoinQueueEntry_t getFrontOfQueue();
    JoinQueueEntry_t getBackOfQueue();
    JoinQueueEntry_t getQueueEntryAt(const ULONG ulPosition);
    JoinQueueEntry_t getQueueEntryForPlayer(const ULONG ulPlayer);
    std::vector<JoinQueueEntry_t> getPlayersForTeam(const ULONG ulTeam);

    bool removePlayerFromQueue(const ULONG ulPlayer, const bool bBroadcast);
    bool removePlayerFromQueueFront(const bool bBroadcast);
    bool removePlayerFromQueueBack(const bool bBroadcast);
    bool removePlayerFromQueueAt(const ULONG ulPosition, const bool bBroadcast);

    void handleSpectatorLeftGame(const ULONG ulPlayer, const bool bWantPop);
    void handlePlayerLeftGame(const ULONG ulPlayer, const bool bBroadcast = true);

    bool isPlayerInLine(const ULONG ulPlayer);
    LONG getPositionInLine(const ULONG ulPlayer);

    void setTimeoutThreshold(const LONG ticAmount);
    LONG getTimeoutThreshold();

    bool attemptToRestorePlayer(const ULONG ulPlayer, NETADDRESS_s netAddress);

    ULONG getSize();
    bool isEmpty();

    void purgeMissingPlayers(const bool bBroadcast);
    void clearQueue();

    FString getPrintableJoinQueue();
};

//-----------------------------------------------------------------------------
// Extern variables
//-----------------------------------------------------------------------------

extern JoinQueue g_joinQueue;

//-----------------------------------------------------------------------------
// Prototypes
//-----------------------------------------------------------------------------

void JOINQUEUE_CLIENT_SetPositionInLine(LONG lPosition);