#pragma once

#include <cstdint>
#include <mutex>

#include "util/Timer.h"
#include "platform/sdl2/Profile.h"
#include "platform/sdl2/Storage.h"

// using namespace std;

#include "app/common/ArchiveManager.h"
#include "app/common/BannedListManager.h"
#include "app/common/DebugOptions.h"
#include "app/common/IPlatformGame.h"
#include "app/common/App_structs.h"
#include "app/common/LocalizationManager.h"
#include "app/common/SaveManager.h"
#include "app/common/SkinManager.h"
#include "app/common/TerrainFeatureManager.h"
#include "app/common/Audio/Consoles_SoundEngine.h"
#include "app/common/DLC/DLCManager.h"
#include "app/common/GameRules/ConsoleGameRulesConstants.h"
#include "app/common/GameRules/GameRuleManager.h"
#include "app/common/Localisation/StringTable.h"
#include "app/common/Tutorial/TutorialEnum.h"
#include "app/common/UI/All Platforms/ArchiveFile.h"
#include "app/common/UI/All Platforms/UIStructs.h"
#include "platform/NetTypes.h"
#include "minecraft/client/SkinBox.h"
#include "platform/XboxStubs.h"
#include "minecraft/network/packet/DisconnectPacket.h"
#include "minecraft/world/entity/item/MinecartHopper.h"

typedef struct _JoinFromInviteData {
    std::uint32_t dwUserIndex;       // dwUserIndex
    std::uint32_t dwLocalUsersMask;  // dwUserMask
    const INVITE_INFO* pInviteInfo;  // pInviteInfo
} JoinFromInviteData;

class Player;
class Inventory;
class Level;
class FurnaceTileEntity;
class Container;
class DispenserTileEntity;
class SignTileEntity;
class BrewingStandTileEntity;
class CommandBlockEntity;
class HopperTileEntity;
// class MinecartHopper;
class EntityHorse;
class BeaconTileEntity;
class LocalPlayer;
class DLCPack;
class LevelRuleset;
class ConsoleSchematicFile;
class Model;
class ModelPart;
class StringTable;
class Merchant;

class CMinecraftAudio;

class Game : public IPlatformGame {
public:
    Game();

    static const float fSafeZoneX;  // 5% of 1280
    static const float fSafeZoneY;  // 5% of 720

    typedef std::vector<PMEMDATA> VMEMFILES;
    typedef std::vector<PNOTIFICATION> VNOTIFICATIONS;

    // storing skin files - delegated to SkinManager
    std::vector<std::wstring>& vSkinNames = m_skinManager.vSkinNames;
    DLCManager m_dlcManager;
    SaveManager m_saveManager;
    BannedListManager m_bannedListManager;
    TerrainFeatureManager m_terrainFeatureManager;
    DebugOptions m_debugOptions;
    LocalizationManager m_localizationManager;
    ArchiveManager m_archiveManager;
    SkinManager m_skinManager;

    // storing credits text from the DLC
    std::vector<std::wstring> m_vCreditText;  // hold the credit text lines so
                                              // we can avoid duplicating them

    // In builds prior to TU5, the size of the GAME_SETTINGS struct was 204
    // bytes. We added a few new values to the internal struct in TU5, and even
    // though we changed the size of the ucUnused array to be decreased by the
    // size of the values we added, the packing of the struct has introduced
    // some extra padding that resulted in the GAME_SETTINGS struct being 208
    // bytes. The knock-on effect from this was that all the stats, which come
    // after the game settings in the profile data, we being read offset by 4
    // bytes. We need to ensure that the GAME_SETTINGS struct does not grow
    // larger than 204 bytes or if we need it to then we need to rebuild the
    // profile data completely and increase the profile version. There should be
    // enough free space to grow larger for a few more updates as long as we
    // take into account the padding issues and check that settings are still
    // stored at the same positions when we read them
    static const int GAME_SETTINGS_PROFILE_DATA_BYTES = 204;

#if defined(_EXTENDED_ACHIEVEMENTS)
    /* 4J-JEV:
     * We need more space in the profile data because of the new achievements
     * and statistics necessary for the new expanded achievement set.
     */
    static const int GAME_DEFINED_PROFILE_DATA_BYTES = 2 * 972;  // per user
#else
    static const int GAME_DEFINED_PROFILE_DATA_BYTES = 972;  // per user
#endif
    unsigned int uiGameDefinedDataChangedBitmask;

    void DebugPrintf(const char* szFormat, ...);
    void DebugPrintfVerbose(bool bVerbose, const char* szFormat,
                            ...);  // Conditional printf
    void DebugPrintf(int user, const char* szFormat, ...);

    static const int USER_NONE = 0;  // disables printf
    static const int USER_GENERAL = 1;
    static const int USER_JV = 2;
    static const int USER_MH = 3;
    static const int USER_PB = 4;
    static const int USER_RR = 5;
    static const int USER_SR = 6;
    static const int USER_UI =
        7;  // 4J Stu - This also makes it appear on the UI console

    void HandleButtonPresses();
    bool IntroRunning() { return m_bIntroRunning; }
    void SetIntroRunning(bool bSet) { m_bIntroRunning = bSet; }
#if defined(_CONTENT_PACKAGE)
#if !defined(_FINAL_BUILD)
    bool PartnernetPasswordRunning() { return m_bPartnernetPasswordRunning; }
    void SetPartnernetPasswordRunning(bool bSet) {
        m_bPartnernetPasswordRunning = bSet;
    }
#endif
#endif

    bool IsAppPaused();
    void SetAppPaused(bool val);
    int displaySavingMessage(const C4JStorage::ESavingMessage eMsg, int iPad);
    bool GetGameStarted() { return m_bGameStarted; }
    void SetGameStarted(bool bVal) {
        if (bVal)
            DebugPrintf("SetGameStarted - true\n");
        else
            DebugPrintf("SetGameStarted - false\n");
        m_bGameStarted = bVal;
        m_bIsAppPaused = !bVal;
    }
    int GetLocalPlayerCount(void);
    bool LoadInventoryMenu(int iPad, std::shared_ptr<LocalPlayer> player,
                           bool bNavigateBack = false);
    bool LoadCreativeMenu(int iPad, std::shared_ptr<LocalPlayer> player,
                          bool bNavigateBack = false);
    bool LoadEnchantingMenu(int iPad, std::shared_ptr<Inventory> inventory,
                            int x, int y, int z, Level* level,
                            const std::wstring& name);
    bool LoadFurnaceMenu(int iPad, std::shared_ptr<Inventory> inventory,
                         std::shared_ptr<FurnaceTileEntity> furnace);
    bool LoadBrewingStandMenu(
        int iPad, std::shared_ptr<Inventory> inventory,
        std::shared_ptr<BrewingStandTileEntity> brewingStand);
    bool LoadContainerMenu(int iPad, std::shared_ptr<Container> inventory,
                           std::shared_ptr<Container> container);
    bool LoadTrapMenu(int iPad, std::shared_ptr<Container> inventory,
                      std::shared_ptr<DispenserTileEntity> trap);
    bool LoadCrafting2x2Menu(int iPad, std::shared_ptr<LocalPlayer> player);
    bool LoadCrafting3x3Menu(int iPad, std::shared_ptr<LocalPlayer> player,
                             int x, int y, int z);
    bool LoadFireworksMenu(int iPad, std::shared_ptr<LocalPlayer> player, int x,
                           int y, int z);
    bool LoadSignEntryMenu(int iPad, std::shared_ptr<SignTileEntity> sign);
    bool LoadRepairingMenu(int iPad, std::shared_ptr<Inventory> inventory,
                           Level* level, int x, int y, int z);
    bool LoadTradingMenu(int iPad, std::shared_ptr<Inventory> inventory,
                         std::shared_ptr<Merchant> trader, Level* level,
                         const std::wstring& name);

    bool LoadCommandBlockMenu(
        int iPad, std::shared_ptr<CommandBlockEntity> commandBlock) {
        return false;
    }
    bool LoadHopperMenu(int iPad, std::shared_ptr<Inventory> inventory,
                        std::shared_ptr<HopperTileEntity> hopper);
    bool LoadHopperMenu(int iPad, std::shared_ptr<Inventory> inventory,
                        std::shared_ptr<MinecartHopper> hopper);
    bool LoadHorseMenu(int iPad, std::shared_ptr<Inventory> inventory,
                       std::shared_ptr<Container> container,
                       std::shared_ptr<EntityHorse> horse);
    bool LoadBeaconMenu(int iPad, std::shared_ptr<Inventory> inventory,
                        std::shared_ptr<BeaconTileEntity> beacon);

    bool GetTutorialMode() { return m_bTutorialMode; }
    void SetTutorialMode(bool bSet) { m_bTutorialMode = bSet; }

    void SetSpecialTutorialCompletionFlag(int iPad, int index);

    static const wchar_t* GetString(int iID);
    StringTable* getStringTable() const { return m_localizationManager.getStringTable(); }

    eGameMode GetGameMode() { return m_eGameMode; }
    void SetGameMode(eGameMode eMode) { m_eGameMode = eMode; }

    eXuiAction GetGlobalXuiAction() { return m_eGlobalXuiAction; }
    void SetGlobalXuiAction(eXuiAction action) { m_eGlobalXuiAction = action; }
    eXuiAction GetXuiAction(int iPad) { return m_eXuiAction[iPad]; }
    void SetAction(int iPad, eXuiAction action, void* param = nullptr);
    void SetTMSAction(int iPad, eTMSAction action) {
        m_eTMSAction[iPad] = action;
    }
    eTMSAction GetTMSAction(int iPad) { return m_eTMSAction[iPad]; }
    eXuiServerAction GetXuiServerAction(int iPad) {
        return m_eXuiServerAction[iPad];
    }
    void* GetXuiServerActionParam(int iPad) {
        return m_eXuiServerActionParam[iPad];
    }
    void SetXuiServerAction(int iPad, eXuiServerAction action,
                            void* param = nullptr) {
        m_eXuiServerAction[iPad] = action;
        m_eXuiServerActionParam[iPad] = param;
    }
    eXuiServerAction GetGlobalXuiServerAction() {
        return m_eGlobalXuiServerAction;
    }
    void SetGlobalXuiServerAction(eXuiServerAction action) {
        m_eGlobalXuiServerAction = action;
    }

    DisconnectPacket::eDisconnectReason GetDisconnectReason() {
        return m_disconnectReason;
    }
    void SetDisconnectReason(DisconnectPacket::eDisconnectReason bVal) {
        m_disconnectReason = bVal;
    }

    bool GetChangingSessionType() { return m_bChangingSessionType; }
    void SetChangingSessionType(bool bVal) { m_bChangingSessionType = bVal; }

    bool GetReallyChangingSessionType() { return m_bReallyChangingSessionType; }
    void SetReallyChangingSessionType(bool bVal) {
        m_bReallyChangingSessionType = bVal;
    }

    // 4J Stu - Added so that we can call this when a confirmation box is
    // selected
    static void SetActionConfirmed(void* param);
    void HandleXuiActions(void);

    // 4J Stu - Functions used for Minecon and other promo work
    bool GetLoadSavesFromFolderEnabled() {
        return m_debugOptions.getLoadSavesFromFolderEnabled();
    }
    void SetLoadSavesFromFolderEnabled(bool bVal) {
        m_debugOptions.setLoadSavesFromFolderEnabled(bVal);
    }

    // 4J Stu - Useful for debugging
    bool GetWriteSavesToFolderEnabled() {
        return m_debugOptions.getWriteSavesToFolderEnabled();
    }
    void SetWriteSavesToFolderEnabled(bool bVal) {
        m_debugOptions.setWriteSavesToFolderEnabled(bVal);
    }
    bool GetMobsDontAttackEnabled() {
        return m_debugOptions.getMobsDontAttack();
    }
    void SetMobsDontAttackEnabled(bool bVal) {
        m_debugOptions.setMobsDontAttack(bVal);
    }
    bool GetUseDPadForDebug() { return m_debugOptions.getUseDPadForDebug(); }
    void SetUseDPadForDebug(bool bVal) {
        m_debugOptions.setUseDPadForDebug(bVal);
    }
    bool GetMobsDontTickEnabled() { return m_debugOptions.getMobsDontTick(); }
    void SetMobsDontTickEnabled(bool bVal) {
        m_debugOptions.setMobsDontTick(bVal);
    }

    bool GetFreezePlayers() { return m_debugOptions.getFreezePlayers(); }
    void SetFreezePlayers(bool bVal) { m_debugOptions.setFreezePlayers(bVal); }

    // debug -0 show safe area
    void ShowSafeArea(bool show) {}
    // 4J-PB - to capture the social post screenshot
    virtual void CaptureScreenshot(int iPad) {};
    // void			GetPreviewImage(int iPad,XSOCIAL_PREVIEWIMAGE
    // *preview);

    void InitGameSettings();
    static int OldProfileVersionCallback(void* pParam, unsigned char* pucData,
                                         const unsigned short usVersion,
                                         const int iPad);

    static int DefaultOptionsCallback(void* pParam,
                                      C_4JProfile::PROFILESETTINGS* pSettings,
                                      const int iPad);
    int SetDefaultOptions(C_4JProfile::PROFILESETTINGS* pSettings,
                          const int iPad);
    void SetRichPresenceContext(int iPad, int contextId) override = 0;

    void SetGameSettings(int iPad, eGameSetting eVal, unsigned char ucVal);
    unsigned char GetGameSettings(int iPad, eGameSetting eVal);
    unsigned char GetGameSettings(eGameSetting eVal);  // for the primary pad
    void SetPlayerSkin(int iPad, const std::wstring& name) {
        m_skinManager.setPlayerSkin(iPad, name, GameSettingsA);
    }
    void SetPlayerSkin(int iPad, std::uint32_t dwSkinId) {
        m_skinManager.setPlayerSkin(iPad, dwSkinId, GameSettingsA);
    }
    void SetPlayerCape(int iPad, const std::wstring& name) {
        m_skinManager.setPlayerCape(iPad, name, GameSettingsA);
    }
    void SetPlayerCape(int iPad, std::uint32_t dwCapeId) {
        m_skinManager.setPlayerCape(iPad, dwCapeId, GameSettingsA);
    }
    void SetPlayerFavoriteSkin(int iPad, int iIndex, unsigned int uiSkinID) {
        m_skinManager.setPlayerFavoriteSkin(iPad, iIndex, uiSkinID, GameSettingsA);
    }
    unsigned int GetPlayerFavoriteSkin(int iPad, int iIndex) {
        return m_skinManager.getPlayerFavoriteSkin(iPad, iIndex, GameSettingsA);
    }
    unsigned char GetPlayerFavoriteSkinsPos(int iPad) {
        return m_skinManager.getPlayerFavoriteSkinsPos(iPad, GameSettingsA);
    }
    void SetPlayerFavoriteSkinsPos(int iPad, int iPos) {
        m_skinManager.setPlayerFavoriteSkinsPos(iPad, iPos, GameSettingsA);
    }
    unsigned int GetPlayerFavoriteSkinsCount(int iPad) {
        return m_skinManager.getPlayerFavoriteSkinsCount(iPad, GameSettingsA);
    }
    void ValidateFavoriteSkins(int iPad) {
        m_skinManager.validateFavoriteSkins(iPad, GameSettingsA, m_dlcManager);
    }

    // Mash-up pack worlds hide/display
    void HideMashupPackWorld(int iPad, unsigned int iMashupPackID);
    void EnableMashupPackWorlds(int iPad);
    unsigned int GetMashupPackWorlds(int iPad);

    // Minecraft language select - implementations remain in Game.cpp
    // (they access GameSettingsA directly)
    void SetMinecraftLanguage(int iPad, unsigned char ucLanguage);
    unsigned char GetMinecraftLanguage(int iPad);
    void SetMinecraftLocale(int iPad, unsigned char ucLanguage);
    unsigned char GetMinecraftLocale(int iPad);

    // 4J-PB - set a timer when the user navigates the quickselect, so we can
    // bring the opacity back to defaults for a short time
    unsigned int GetOpacityTimer(int iPad) {
        return m_uiOpacityCountDown[iPad];
    }
    void SetOpacityTimer(int iPad) {
        m_uiOpacityCountDown[iPad] = 120;
    }  // 6 seconds
    void TickOpacityTimer(int iPad) {
        if (m_uiOpacityCountDown[iPad] > 0) m_uiOpacityCountDown[iPad]--;
    }

public:
    std::wstring GetPlayerSkinName(int iPad) {
        return m_skinManager.getPlayerSkinName(iPad, GameSettingsA);
    }
    std::uint32_t GetPlayerSkinId(int iPad) {
        return m_skinManager.getPlayerSkinId(iPad, GameSettingsA, m_dlcManager);
    }
    std::wstring GetPlayerCapeName(int iPad) {
        return m_skinManager.getPlayerCapeName(iPad, GameSettingsA);
    }
    std::uint32_t GetPlayerCapeId(int iPad) {
        return m_skinManager.getPlayerCapeId(iPad, GameSettingsA);
    }
    std::uint32_t GetAdditionalModelParts(int iPad) {
        return m_skinManager.getAdditionalModelParts(iPad);
    }
    void CheckGameSettingsChanged(bool bOverride5MinuteTimer = false,
                                  int iPad = XUSER_INDEX_ANY);
    void ApplyGameSettingsChanged(int iPad);
    void ClearGameSettingsChangedFlag(int iPad);
    void ActionGameSettings(int iPad, eGameSetting eVal);
    unsigned int GetGameSettingsDebugMask(int iPad = -1,
                                          bool bOverridePlayer = false);
    void SetGameSettingsDebugMask(int iPad, unsigned int uiVal);
    void ActionDebugMask(int iPad, bool bSetAllClear = false);

    //
    bool IsLocalMultiplayerAvailable();

    // for sign in change monitoring
    static void SignInChangeCallback(void* pParam, bool bVal,
                                     unsigned int uiSignInData);
    static void ClearSignInChangeUsersMask();
    static int SignoutExitWorldThreadProc(void* lpParameter);
    static int PrimaryPlayerSignedOutReturned(void* pParam, int iPad,
                                              const C4JStorage::EMessageResult);
    static int EthernetDisconnectReturned(void* pParam, int iPad,
                                          const C4JStorage::EMessageResult);
    static void ProfileReadErrorCallback(void* pParam);

    // FATAL LOAD ERRORS
    virtual void FatalLoadError();

    // Notifications from the game listener to be passed to the qnet listener
    static void NotificationsCallback(void* pParam,
                                      std::uint32_t dwNotification,
                                      unsigned int uiParam);

    // for the ethernet being disconnected
    static void LiveLinkChangeCallback(void* pParam, bool bConnected);
    bool GetLiveLinkRequired() { return m_bLiveLinkRequired; }
    void SetLiveLinkRequired(bool required) { m_bLiveLinkRequired = required; }

#if defined(_DEBUG_MENUS_ENABLED)
    bool DebugSettingsOn() { return m_debugOptions.settingsOn(); }
    bool DebugArtToolsOn();
#else
    bool DebugSettingsOn() { return false; }
    bool DebugArtToolsOn() { return false; }
#endif
    void SetDebugSequence(const char* pchSeq);
    // bool			UploadFileToGlobalStorage(int iQuadrant,
    // C4JStorage::eGlobalStorage eStorageFacility, std::wstring *wsFile  );

    // Installed DLC
    bool StartInstallDLCProcess(int iPad);
    int dlcInstalledCallback(int iOfferC, int iPad);
    void HandleDLCLicenseChange();
    int dlcMountedCallback(int iPad, std::uint32_t dwErr,
                           std::uint32_t dwLicenceMask);
    void MountNextDLC(int iPad);
    // static int DLCReadCallback(void* pParam,C4JStorage::DLC_FILE_DETAILS
    // *pDLCData);
    void HandleDLC(DLCPack* pack);
    bool DLCInstallPending() { return m_bDLCInstallPending; }
    bool DLCInstallProcessCompleted() { return m_bDLCInstallProcessCompleted; }
    void ClearDLCInstalled() { m_bDLCInstallProcessCompleted = false; }
    static int MarketplaceCountsCallback(void* pParam,
                                         C4JStorage::DLC_TMS_DETAILS*,
                                         int iPad);

    bool AlreadySeenCreditText(const std::wstring& wstemp);

    void ClearNewDLCAvailable(void) {
        m_bNewDLCAvailable = false;
        m_bSeenNewDLCTip = true;
    }
    bool GetNewDLCAvailable() { return m_bNewDLCAvailable; }
    void DisplayNewDLCTipAgain() { m_bSeenNewDLCTip = false; }
    bool DisplayNewDLCTip() {
        if (!m_bSeenNewDLCTip) {
            m_bSeenNewDLCTip = true;
            return true;
        } else
            return false;
    }

    // functions to store launch data, and to exit the game - required due to
    // possibly being on a demo disc
    virtual void StoreLaunchData();
    virtual void ExitGame();

    bool isXuidNotch(PlayerUID xuid) {
        return m_skinManager.isXuidNotch(xuid);
    }
    bool isXuidDeadmau5(PlayerUID xuid);

    void AddMemoryTextureFile(const std::wstring& wName, std::uint8_t* pbData,
                              unsigned int byteCount) {
        m_skinManager.addMemoryTextureFile(wName, pbData, byteCount);
    }
    void RemoveMemoryTextureFile(const std::wstring& wName) {
        m_skinManager.removeMemoryTextureFile(wName);
    }
    void GetMemFileDetails(const std::wstring& wName, std::uint8_t** ppbData,
                           unsigned int* pByteCount) {
        m_skinManager.getMemFileDetails(wName, ppbData, pByteCount);
    }
    bool IsFileInMemoryTextures(const std::wstring& wName) {
        return m_skinManager.isFileInMemoryTextures(wName);
    }

    // Texture Pack Data files (icon, banner, comparison shot & text)
    void AddMemoryTPDFile(int iConfig, std::uint8_t* pbData,
                          unsigned int byteCount) {
        m_archiveManager.addMemoryTPDFile(iConfig, pbData, byteCount);
    }
    void RemoveMemoryTPDFile(int iConfig) {
        m_archiveManager.removeMemoryTPDFile(iConfig);
    }
    bool IsFileInTPD(int iConfig) {
        return m_archiveManager.isFileInTPD(iConfig);
    }
    void GetTPD(int iConfig, std::uint8_t** ppbData, unsigned int* pByteCount) {
        m_archiveManager.getTPD(iConfig, ppbData, pByteCount);
    }
    int GetTPDSize() { return m_archiveManager.getTPDSize(); }
    int GetTPConfigVal(wchar_t* pwchDataFile) {
        return m_archiveManager.getTPConfigVal(pwchDataFile);
    }

    bool DefaultCapeExists() {
        return m_skinManager.defaultCapeExists();
    }
    // void InstallDefaultCape(); // attempt  to install the default cape once
    // per game launch

    // invites
    // void ProcessInvite(JoinFromInviteData *pJoinData);
    void ProcessInvite(std::uint32_t dwUserIndex,
                       std::uint32_t dwLocalUsersMask,
                       const INVITE_INFO* pInviteInfo);

    // Add credits for DLC installed
    void AddCreditText(const wchar_t* lpStr);

private:
    std::unordered_map<PlayerUID, std::uint8_t*> m_GTS_Files;

    VNOTIFICATIONS m_vNotifications;

public:
    // launch data
    std::uint8_t* m_pLaunchData;
    unsigned int m_dwLaunchDataSize;

public:
    // BAN LIST
    void AddLevelToBannedLevelList(int iPad, PlayerUID xuid, char* pszLevelName,
                                   bool bWriteToTMS) {
        m_bannedListManager.addLevel(iPad, xuid, pszLevelName, bWriteToTMS);
    }
    bool IsInBannedLevelList(int iPad, PlayerUID xuid, char* pszLevelName) {
        return m_bannedListManager.isInList(iPad, xuid, pszLevelName);
    }
    void RemoveLevelFromBannedLevelList(int iPad, PlayerUID xuid,
                                        char* pszLevelName) {
        m_bannedListManager.removeLevel(iPad, xuid, pszLevelName);
    }
    void InvalidateBannedList(int iPad) {
        m_bannedListManager.invalidate(iPad);
    }
    void SetUniqueMapName(char* pszUniqueMapName) {
        m_bannedListManager.setUniqueMapName(pszUniqueMapName);
    }
    char* GetUniqueMapName(void) {
        return m_bannedListManager.getUniqueMapName();
    }

public:
    bool GetResourcesLoaded() { return m_bResourcesLoaded; }
    void SetResourcesLoaded(bool bVal) { m_bResourcesLoaded = bVal; }

public:
    bool m_bGameStarted;
    bool m_bIntroRunning;
    bool m_bTutorialMode;
    bool m_bIsAppPaused;

    bool m_bChangingSessionType;
    bool m_bReallyChangingSessionType;

    // trial, and trying to unlock full
    // version on an upsell

    void loadMediaArchive() { m_archiveManager.loadMediaArchive(); }
    void loadStringTable() {
        m_localizationManager.loadStringTable(m_archiveManager.getMediaArchive());
    }

public:
    int getArchiveFileSize(const std::wstring& filename) {
        return m_archiveManager.getArchiveFileSize(filename);
    }
    bool hasArchiveFile(const std::wstring& filename) {
        return m_archiveManager.hasArchiveFile(filename);
    }
    std::vector<uint8_t> getArchiveFile(const std::wstring& filename) {
        return m_archiveManager.getArchiveFile(filename);
    }

private:
    static int BannedLevelDialogReturned(void* pParam, int iPad,
                                         const C4JStorage::EMessageResult);
    static int TexturePackDialogReturned(void* pParam, int iPad,
                                         C4JStorage::EMessageResult result);

    void HandleButtonPresses(int iPad);

    bool m_bResourcesLoaded;

    // Global string table for this application.
    // CXuiStringTable StringTable;

    // Container scene for some menu

    //	CXuiScene debugContainerScene;

    // bool m_bSplitScreenEnabled;

#if defined(_CONTENT_PACKAGE)
#if !defined(_FINAL_BUILD)
    bool m_bPartnernetPasswordRunning;
#endif
#endif

    eGameMode m_eGameMode;  // single or multiplayer

    static unsigned int m_uiLastSignInData;

    // We've got sizeof(GAME_SETTINGS) bytes reserved at the start of the
    // gamedefined data per player for settings
    GAME_SETTINGS* GameSettingsA[XUSER_MAX_COUNT];

    // Debug options now in m_debugOptions

    // 4J : WESTY : For taking screen shots.
    // bool m_bInterfaceRenderingOff;
    // bool m_bHandRenderingOff;

    DisconnectPacket::eDisconnectReason m_disconnectReason;

public:
    virtual void RunFrame() {};

    static constexpr unsigned int m_dwOfferID = 0x00000001;

    // timer
    void InitTime();
    void UpdateTime();

    // trial timer
    void SetTrialTimerStart(void);
    float getTrialTimer(void);

    // notifications from the game for qnet
    VNOTIFICATIONS* GetNotifications() { return &m_vNotifications; }

private:
    // To avoid problems with threads being kicked off from xuis that alter
    // things that may be in progress within the run_middle, we'll action these
    // at the end of the game loop
    eXuiAction m_eXuiAction[XUSER_MAX_COUNT];
    eTMSAction m_eTMSAction[XUSER_MAX_COUNT];
    void* m_eXuiActionParam[XUSER_MAX_COUNT];
    eXuiAction m_eGlobalXuiAction;
    eXuiServerAction m_eXuiServerAction[XUSER_MAX_COUNT];
    void* m_eXuiServerActionParam[XUSER_MAX_COUNT];
    eXuiServerAction m_eGlobalXuiServerAction;

    bool m_bLiveLinkRequired;

    static int UnlockFullExitReturned(void* pParam, int iPad,
                                      C4JStorage::EMessageResult result);
    static int UnlockFullSaveReturned(void* pParam, int iPad,
                                      C4JStorage::EMessageResult result);
    static int UnlockFullInviteReturned(void* pParam, int iPad,
                                        C4JStorage::EMessageResult result);
    static int TrialOverReturned(void* pParam, int iPad,
                                 C4JStorage::EMessageResult result);
    static int ExitAndJoinFromInvite(void* pParam, int iPad,
                                     C4JStorage::EMessageResult result);
    static int ExitAndJoinFromInviteSaveDialogReturned(
        void* pParam, int iPad, C4JStorage::EMessageResult result);
    static int ExitAndJoinFromInviteAndSaveReturned(
        void* pParam, int iPad, C4JStorage::EMessageResult result);
    static int ExitAndJoinFromInviteDeclineSaveReturned(
        void* pParam, int iPad, C4JStorage::EMessageResult result);
    static int FatalErrorDialogReturned(void* pParam, int iPad,
                                        C4JStorage::EMessageResult result);
    static int WarningTrialTexturePackReturned(
        void* pParam, int iPad, C4JStorage::EMessageResult result);

    JoinFromInviteData m_InviteData;
    // m_bDebugOptions moved to m_debugOptions

    // Trial timer
    float m_fTrialTimerStart, mfTrialPausedTime;
    typedef struct TimeInfo {
        time_util::time_point qwTime;
        time_util::clock::duration qwAppTime{};

        float fAppTime;
        float fElapsedTime;
    } TIMEINFO;

    TimeInfo m_Time;

public:
    void InitialiseTips() { m_localizationManager.initialiseTips(); }
    int GetNextTip() { return m_localizationManager.getNextTip(); }
    int GetHTMLColour(eMinecraftColour colour) {
        return m_localizationManager.getHTMLColour(colour);
    }
    int GetHTMLColor(eMinecraftColour colour) { return GetHTMLColour(colour); }
    int GetHTMLFontSize(EHTMLFontSize size) {
        return m_localizationManager.getHTMLFontSize(size);
    }
    std::wstring FormatHTMLString(int iPad, const std::wstring& desc,
                                  int shadowColour = 0xFFFFFFFF) {
        return m_localizationManager.formatHTMLString(iPad, desc, shadowColour);
    }
    std::wstring GetActionReplacement(int iPad, unsigned char ucAction) {
        return m_localizationManager.getActionReplacement(iPad, ucAction);
    }
    std::wstring GetVKReplacement(unsigned int uiVKey) {
        return m_localizationManager.getVKReplacement(uiVKey);
    }
    std::wstring GetIconReplacement(unsigned int uiIcon) {
        return m_localizationManager.getIconReplacement(uiIcon);
    }

    float getAppTime() { return m_Time.fAppTime; }
    void UpdateTrialPausedTimer() { mfTrialPausedTime += m_Time.fElapsedTime; }

    static int RemoteSaveThreadProc(void* lpParameter);
    static void ExitGameFromRemoteSave(void* lpParameter);
    static int ExitGameFromRemoteSaveDialogReturned(
        void* pParam, int iPad, C4JStorage::EMessageResult result);

    // XML
public:
    // Hold a vector of terrain feature positions
    void AddTerrainFeaturePosition(_eTerrainFeatureType eType, int x, int z) {
        m_terrainFeatureManager.add(eType, x, z);
    }
    void ClearTerrainFeaturePosition() { m_terrainFeatureManager.clear(); }
    _eTerrainFeatureType IsTerrainFeature(int x, int z) {
        return m_terrainFeatureManager.isFeature(x, z);
    }
    bool GetTerrainFeaturePosition(_eTerrainFeatureType eType, int* pX,
                                   int* pZ) {
        return m_terrainFeatureManager.getPosition(eType, pX, pZ);
    }

    static int32_t RegisterMojangData(wchar_t*, PlayerUID, wchar_t*, wchar_t*);
    MOJANG_DATA* GetMojangDataForXuid(PlayerUID xuid);
    static int32_t RegisterConfigValues(wchar_t* pType, int iValue);

    static int32_t RegisterDLCData(wchar_t*, wchar_t*, int, uint64_t, uint64_t,
                                   wchar_t*, unsigned int, int,
                                   wchar_t* pDataFile);
    bool GetDLCFullOfferIDForSkinID(const std::wstring& FirstSkin,
                                    uint64_t* pullVal);
    DLC_INFO* GetDLCInfoForTrialOfferID(uint64_t ullOfferID_Trial);
    DLC_INFO* GetDLCInfoForFullOfferID(uint64_t ullOfferID_Full);

    unsigned int GetDLCCreditsCount();
    SCreditTextItemDef* GetDLCCredits(int iIndex);

    // TMS
    void ReadDLCFileFromTMS(int iPad, eTMSAction action,
                            bool bCallback = false);
    void ReadXuidsFileFromTMS(int iPad, eTMSAction action,
                              bool bCallback = false);

    // images for save thumbnail/social post
    void CaptureSaveThumbnail() override = 0;
    void GetSaveThumbnail(std::uint8_t** thumbnailData,
                          unsigned int* thumbnailSize) override = 0;
    void ReleaseSaveThumbnail() override = 0;
    void GetScreenshot(int iPad, std::uint8_t** screenshotData,
                       unsigned int* screenshotSize) override = 0;

    void ReadBannedList(int iPad, eTMSAction action = (eTMSAction)0,
                        bool bCallback = false) override = 0;

private:
    std::vector<SCreditTextItemDef*> vDLCCredits;

    static std::unordered_map<PlayerUID, MOJANG_DATA*> MojangData;
    static std::unordered_map<int, uint64_t>
        DLCTextures_PackID;  // for mash-up packs & texture packs
    static std::unordered_map<uint64_t, DLC_INFO*>
        DLCInfo_Trial;  // full offerid, dlc_info
    static std::unordered_map<uint64_t, DLC_INFO*>
        DLCInfo_Full;  // full offerid, dlc_info
    static std::unordered_map<std::wstring, uint64_t>
        DLCInfo_SkinName;  // skin name, full offer id
    //	bool m_bRead_TMS_XUIDS_XML; // track whether we have already read the
    // TMS xuids.xml file 	bool m_bRead_TMS_DLCINFO_XML; // track whether
    // we have already read the TMS DLC.xml file

    bool m_bDefaultCapeInstallAttempted;  // have we attempted to install the
                                          // default cape from tms

    // bool m_bwasHidingGui; // 4J Stu - Removed 1.8.2 bug fix (TU6) as not
    // needed
    bool m_bDLCInstallProcessCompleted;
    bool m_bDLCInstallPending;
    int m_iTotalDLC;
    int m_iTotalDLCInstalled;

public:
    // 4J Stu - We need to be able to detect when a guest player signs in or out
    // causing other guest players to change their xuid The simplest way to do
    // this is to check if their guest number has changed, so store the last
    // known one here 4J Stu - Now storing the whole XUSER_SIGNIN_INFO so we can
    // detect xuid changes
    XUSER_SIGNIN_INFO m_currentSigninInfo[XUSER_MAX_COUNT];

    // void OverrideFontRenderer(bool set, bool immediate = true);
    //	void ToggleFontRenderer() {
    // OverrideFontRenderer(!m_bFontRendererOverridden,false); }
    BANNEDLIST (&BannedListA)[XUSER_MAX_COUNT] = m_bannedListManager.BannedListA;

public:
    void SetBanListCheck(int iPad, bool bVal) {
        m_bannedListManager.setBanListCheck(iPad, bVal);
    }
    bool GetBanListCheck(int iPad) {
        return m_bannedListManager.getBanListCheck(iPad);
    }
    // AUTOSAVE
public:
    void SetAutosaveTimerTime(void);
    bool AutosaveDue(void) { return m_saveManager.autosaveDue(); }
    int64_t SecondsToAutosave() { return m_saveManager.secondsToAutosave(); }

private:
    unsigned int m_uiOpacityCountDown[XUSER_MAX_COUNT];

    // DLC
    bool m_bNewDLCAvailable;
    bool m_bSeenNewDLCTip;

    // Host options
private:
    unsigned int m_uiGameHostSettings;
    static unsigned char m_szPNG[8];

#if defined(_LARGE_WORLDS)
    unsigned int m_GameNewWorldSize;
    bool m_bGameNewWorldSizeUseMoat;
    unsigned int m_GameNewHellScale;
#endif
    unsigned int FromBigEndian(unsigned int uiValue);

public:
    void SetGameHostOption(eGameHostOption eVal, unsigned int uiVal);
    void SetGameHostOption(unsigned int& uiHostSettings, eGameHostOption eVal,
                           unsigned int uiVal);
    unsigned int GetGameHostOption(eGameHostOption eVal);
    unsigned int GetGameHostOption(unsigned int uiHostSettings,
                                   eGameHostOption eVal);

#if defined(_LARGE_WORLDS)
    void SetGameNewWorldSize(unsigned int newSize, bool useMoat) {
        m_GameNewWorldSize = newSize;
        m_bGameNewWorldSizeUseMoat = useMoat;
    }
    unsigned int GetGameNewWorldSize() { return m_GameNewWorldSize; }
    unsigned int GetGameNewWorldSizeUseMoat() {
        return m_bGameNewWorldSizeUseMoat;
    }
    void SetGameNewHellScale(unsigned int newScale) {
        m_GameNewHellScale = newScale;
    }
    unsigned int GetGameNewHellScale() { return m_GameNewHellScale; }
#endif
    void SetResetNether(bool bResetNether) { m_bResetNether = bResetNether; }
    bool GetResetNether() { return m_bResetNether; }
    bool CanRecordStatsAndAchievements();

    // World seed from png image
    void GetImageTextData(std::uint8_t* imageData, unsigned int imageBytes,
                          unsigned char* seedText, unsigned int& uiHostOptions,
                          bool& bHostOptionsRead, std::uint32_t& uiTexturePack);
    unsigned int CreateImageTextData(std::uint8_t* textMetadata, int64_t seed,
                                     bool hasSeed, unsigned int uiHostOptions,
                                     unsigned int uiTexturePackId);

    // Game rules
    GameRuleManager m_gameRules;

public:
    void processSchematics(LevelChunk* levelChunk);
    void processSchematicsLighting(LevelChunk* levelChunk);
    void loadDefaultGameRules();
    std::vector<LevelGenerationOptions*>* getLevelGenerators() {
        return m_gameRules.getLevelGenerators();
    }
    void setLevelGenerationOptions(LevelGenerationOptions* levelGen);
    LevelRuleset* getGameRuleDefinitions() {
        return m_gameRules.getGameRuleDefinitions();
    }
    LevelGenerationOptions* getLevelGenerationOptions() {
        return m_gameRules.getLevelGenerationOptions();
    }
    const wchar_t* GetGameRulesString(const std::wstring& key);

private:
    std::uint8_t m_playerColours[MINECRAFT_NET_MAX_PLAYERS];  // An array of
                                                              // QNet small-id's
    unsigned int m_playerGamePrivileges[MINECRAFT_NET_MAX_PLAYERS];

public:
    void UpdatePlayerInfo(std::uint8_t networkSmallId,
                          int16_t playerColourIndex,
                          unsigned int playerGamePrivileges);
    short GetPlayerColour(std::uint8_t networkSmallId);
    unsigned int GetPlayerPrivileges(std::uint8_t networkSmallId);

    std::wstring getEntityName(eINSTANCEOF type);

    unsigned int AddDLCRequest(eDLCMarketplaceType eContentType,
                               bool bPromote = false);
    bool RetrieveNextDLCContent();
    bool CheckTMSDLCCanStop();
    int dlcOffersReturned(int iOfferC, std::uint32_t dwType, int iPad);
    std::uint32_t GetDLCContentType(eDLCContentType eType) {
        return m_dwContentTypeA[eType];
    }
    eDLCContentType Find_eDLCContentType(std::uint32_t dwType);
    int GetDLCOffersCount() { return m_iDLCOfferC; }
    bool DLCContentRetrieved(eDLCMarketplaceType eType);
    void TickDLCOffersRetrieved();
    void ClearAndResetDLCDownloadQueue();
    bool RetrieveNextTMSPPContent();
    void TickTMSPPFilesRetrieved();
    void ClearTMSPPFilesRetrieved();
    unsigned int AddTMSPPFileTypeRequest(eDLCContentType eType,
                                         bool bPromote = false);
    int GetDLCInfoTexturesOffersCount();

    static int TMSPPFileReturned(void* pParam, int iPad, int iUserData,
                                 C4JStorage::PTMSPP_FILEDATA pFileData,
                                 const char* szFilename);
    DLC_INFO* GetDLCInfoTrialOffer(int iIndex);
    DLC_INFO* GetDLCInfoFullOffer(int iIndex);

    int GetDLCInfoTrialOffersCount();
    int GetDLCInfoFullOffersCount();
    bool GetDLCFullOfferIDForPackID(const int iPackID, uint64_t* pullVal);
    uint64_t GetDLCInfoTexturesFullOffer(int iIndex);

    void SetCorruptSaveDeleted(bool bVal) { m_bCorruptSaveDeleted = bVal; }
    bool GetCorruptSaveDeleted(void) { return m_bCorruptSaveDeleted; }

    void lockSaveNotification() { m_saveManager.lock(); }
    void unlockSaveNotification() { m_saveManager.unlock(); }

private:
    // Download Status

    // Request current_download;
    std::vector<DLCRequest*> m_DLCDownloadQueue;
    std::vector<TMSPPRequest*> m_TMSPPDownloadQueue;
    static std::uint32_t m_dwContentTypeA[e_Marketplace_MAX];
    int m_iDLCOfferC;
    bool m_bAllDLCContentRetrieved;
    bool m_bAllTMSContentRetrieved;
    bool m_bTickTMSDLCFiles;
    std::mutex csDLCDownloadQueue;
    std::mutex csTMSPPDownloadQueue;
    bool m_bCorruptSaveDeleted;

    std::uint8_t*& m_pBannedListFileBuffer = m_bannedListManager.m_pBannedListFileBuffer;
    unsigned int& m_dwBannedListFileSize = m_bannedListManager.m_dwBannedListFileSize;

public:
    unsigned int m_dwDLCFileSize;
    std::uint8_t* m_pDLCFileBuffer;

    // 	static int CallbackReadXuidsFileFromTMS(void* lpParam, wchar_t
    // *wchFilename, int iPad, bool bResult, int iAction); 	static int
    // CallbackDLCFileFromTMS(void* lpParam, wchar_t *wchFilename, int iPad,
    // bool bResult, int iAction); 	static int
    // CallbackBannedListFileFromTMS(void* lpParam, wchar_t *wchFilename, int
    // iPad, bool bResult, int iAction);

    // Storing additional model parts per skin texture
    void SetAdditionalSkinBoxes(std::uint32_t dwSkinID, SKIN_BOX* SkinBoxA,
                                unsigned int dwSkinBoxC) {
        m_skinManager.setAdditionalSkinBoxes(dwSkinID, SkinBoxA, dwSkinBoxC);
    }
    std::vector<ModelPart*>* SetAdditionalSkinBoxes(
        std::uint32_t dwSkinID, std::vector<SKIN_BOX*>* pvSkinBoxA) {
        return m_skinManager.setAdditionalSkinBoxes(dwSkinID, pvSkinBoxA);
    }
    std::vector<ModelPart*>* GetAdditionalModelParts(std::uint32_t dwSkinID) {
        return m_skinManager.getAdditionalModelParts(dwSkinID);
    }
    std::vector<SKIN_BOX*>* GetAdditionalSkinBoxes(std::uint32_t dwSkinID) {
        return m_skinManager.getAdditionalSkinBoxes(dwSkinID);
    }
    void SetAnimOverrideBitmask(std::uint32_t dwSkinID,
                                unsigned int uiAnimOverrideBitmask) {
        m_skinManager.setAnimOverrideBitmask(dwSkinID, uiAnimOverrideBitmask);
    }
    unsigned int GetAnimOverrideBitmask(std::uint32_t dwSkinID) {
        return m_skinManager.getAnimOverrideBitmask(dwSkinID);
    }

    static std::uint32_t getSkinIdFromPath(const std::wstring& skin) {
        return SkinManager::getSkinIdFromPath(skin);
    }
    static std::wstring getSkinPathFromId(std::uint32_t skinId) {
        return SkinManager::getSkinPathFromId(skinId);
    }

    int LoadLocalTMSFile(wchar_t* wchTMSFile) override = 0;
    int LoadLocalTMSFile(wchar_t* wchTMSFile,
                         eFileExtensionType eExt) override = 0;
    void FreeLocalTMSFiles(eTMSFileType eType) override = 0;
    int GetLocalTMSFileIndex(wchar_t* wchTMSFile,
                             bool bFilenameIncludesExtension,
                             eFileExtensionType eEXT) override = 0;

    virtual bool GetTMSGlobalFileListRead() { return true; }
    virtual bool GetTMSDLCInfoRead() { return true; }
    virtual bool GetTMSXUIDsFileRead() { return true; }

    bool GetBanListRead(int iPad) {
        return m_bannedListManager.getBanListRead(iPad);
    }
    void SetBanListRead(int iPad, bool bVal) {
        m_bannedListManager.setBanListRead(iPad, bVal);
    }
    void ClearBanList(int iPad) { m_bannedListManager.clearBanList(iPad); }

    std::uint32_t GetRequiredTexturePackID() {
        return m_archiveManager.getRequiredTexturePackID();
    }
    void SetRequiredTexturePackID(std::uint32_t texturePackId) {
        m_archiveManager.setRequiredTexturePackID(texturePackId);
    }

    virtual void GetFileFromTPD(eTPDFileType eType, std::uint8_t* pbData,
                                unsigned int byteCount, std::uint8_t** ppbData,
                                unsigned int* pByteCount) {
        m_archiveManager.getFileFromTPD(eType, pbData, byteCount, ppbData,
                                        pByteCount);
    }

    // XTITLE_DEPLOYMENT_TYPE getDeploymentType() { return
    // m_titleDeploymentType; }

private:
    bool m_bResetNether;

    // 4J-PB - language and locale functions
public:
    void LocaleAndLanguageInit() { m_localizationManager.localeAndLanguageInit(); }
    void getLocale(std::vector<std::wstring>& vecWstrLocales) {
        m_localizationManager.getLocale(vecWstrLocales);
    }
    int get_eMCLang(wchar_t* pwchLocale) {
        return m_localizationManager.get_eMCLang(pwchLocale);
    }
    int get_xcLang(wchar_t* pwchLocale) {
        return m_localizationManager.get_xcLang(pwchLocale);
    }

    void SetTickTMSDLCFiles(bool bVal);

    std::wstring getFilePath(std::uint32_t packId, std::wstring filename,
                             bool bAddDataFolder,
                             std::wstring mountPoint = L"TPACK:");

private:
    std::wstring getRootPath(std::uint32_t packId, bool allowOverride,
                             bool bAddDataFolder, std::wstring mountPoint);

public:
#if defined(_WINDOWS64)
    // CMinecraftAudio audio;
#else

#endif
};


// singleton
// extern CMinecraftApp app;