#pragma once

#include <cstdint>
#include <mutex>

#include "4J.Profile/4J_Profile.h"
#include "4J.Storage/4J_Storage.h"

// using namespace std;

#include "Minecraft.Client/Common/App_structs.h"
#include "Minecraft.Client/Common/src/Audio/Consoles_SoundEngine.h"
#include "Minecraft.Client/Common/src/DLC/DLCManager.h"
#include "Minecraft.Client/Common/src/GameRules/ConsoleGameRulesConstants.h"
#include "Minecraft.Client/Common/src/GameRules/GameRuleManager.h"
#include "Minecraft.Client/Common/src/Localisation/StringTable.h"
#include "Minecraft.Client/Common/src/Tutorial/TutorialEnum.h"
#include "Minecraft.Client/Common/src/UI/All Platforms/ArchiveFile.h"
#include "Minecraft.Client/Common/src/UI/All Platforms/UIStructs.h"
#include "Minecraft.Client/include/NetTypes.h"
#include "Minecraft.Client/include/SkinBox.h"
#include "Minecraft.Client/include/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 CMinecraftApp {
private:
    static int s_iHTMLFontSizesA[eHTMLSize_COUNT];

public:
    CMinecraftApp();

    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
    std::vector<std::wstring> vSkinNames;
    DLCManager m_dlcManager;

    // 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);
    static int DisplaySavingMessage(void* pParam,
                                    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);

    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_bLoadSavesFromFolderEnabled;
    }
    void SetLoadSavesFromFolderEnabled(bool bVal) {
        m_bLoadSavesFromFolderEnabled = bVal;
    }

    // 4J Stu - Useful for debugging
    bool GetWriteSavesToFolderEnabled() { return m_bWriteSavesToFolderEnabled; }
    void SetWriteSavesToFolderEnabled(bool bVal) {
        m_bWriteSavesToFolderEnabled = bVal;
    }
    bool GetMobsDontAttackEnabled() { return m_bMobsDontAttack; }
    void SetMobsDontAttackEnabled(bool bVal) { m_bMobsDontAttack = bVal; }
    bool GetUseDPadForDebug() { return m_bUseDPadForDebug; }
    void SetUseDPadForDebug(bool bVal) { m_bUseDPadForDebug = bVal; }
    bool GetMobsDontTickEnabled() { return m_bMobsDontTick; }
    void SetMobsDontTickEnabled(bool bVal) { m_bMobsDontTick = bVal; }

    bool GetFreezePlayers() { return m_bFreezePlayers; }
    void SetFreezePlayers(bool bVal) { m_bFreezePlayers = 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);
    virtual void SetRichPresenceContext(int iPad, int contextId) = 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);
    void SetPlayerSkin(int iPad, std::uint32_t dwSkinId);
    void SetPlayerCape(int iPad, const std::wstring& name);
    void SetPlayerCape(int iPad, std::uint32_t dwCapeId);
    void SetPlayerFavoriteSkin(int iPad, int iIndex, unsigned int uiSkinID);
    unsigned int GetPlayerFavoriteSkin(int iPad, int iIndex);
    unsigned char GetPlayerFavoriteSkinsPos(int iPad);
    void SetPlayerFavoriteSkinsPos(int iPad, int iPos);
    unsigned int GetPlayerFavoriteSkinsCount(int iPad);
    void ValidateFavoriteSkins(
        int iPad);  // check the DLC is available for the skins

    // 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
    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);
    std::uint32_t GetPlayerSkinId(int iPad);
    std::wstring GetPlayerCapeName(int iPad);
    std::uint32_t GetPlayerCapeId(int iPad);
    std::uint32_t GetAdditionalModelParts(int 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_bDebugOptions; }
    bool DebugArtToolsOn();
#else
    bool DebugSettingsOn() { return false; }
    bool DebugArtToolsOn() { return false; }
#endif
    void SetDebugSequence(const char* pchSeq);
    static int DebugInputCallback(void* pParam);
    // bool			UploadFileToGlobalStorage(int iQuadrant,
    // C4JStorage::eGlobalStorage eStorageFacility, std::wstring *wsFile  );

    // Installed DLC
    bool StartInstallDLCProcess(int iPad);
    static int DLCInstalledCallback(void* pParam, int iOfferC, int iPad);
    void HandleDLCLicenseChange();
    static int DLCMountedCallback(void* pParam, 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);
    bool isXuidDeadmau5(PlayerUID xuid);

    void AddMemoryTextureFile(const std::wstring& wName, std::uint8_t* pbData,
                              unsigned int byteCount);
    void RemoveMemoryTextureFile(const std::wstring& wName);
    void GetMemFileDetails(const std::wstring& wName, std::uint8_t** ppbData,
                           unsigned int* pByteCount);
    bool IsFileInMemoryTextures(const std::wstring& wName);

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

    bool 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:
    PlayerUID m_xuidNotch;
    std::unordered_map<PlayerUID, std::uint8_t*> m_GTS_Files;

    // for storing memory textures - player skin
    std::unordered_map<std::wstring, PMEMDATA> m_MEM_Files;
    // for storing texture pack data files
    std::unordered_map<int, PMEMDATA> m_MEM_TPD;
    std::mutex csMemFilesLock;  // For locking access to the above map
    std::mutex csMemTPDLock;    // For locking access to the above map

    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);
    bool IsInBannedLevelList(int iPad, PlayerUID xuid, char* pszLevelName);
    void RemoveLevelFromBannedLevelList(int iPad, PlayerUID xuid,
                                        char* pszLevelName);
    void InvalidateBannedList(int iPad);
    void SetUniqueMapName(char* pszUniqueMapName);
    char* GetUniqueMapName(void);

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();
    void loadStringTable();

protected:
    ArchiveFile* m_mediaArchive;
    StringTable* m_stringTable;

public:
    int getArchiveFileSize(const std::wstring& filename);
    bool hasArchiveFile(const std::wstring& filename);
    std::vector<uint8_t> getArchiveFile(const std::wstring& filename);

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

    VBANNEDLIST* m_vBannedListA[XUSER_MAX_COUNT];

    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];

    // For promo work
    bool m_bLoadSavesFromFolderEnabled;

    // For debugging
    bool m_bWriteSavesToFolderEnabled;
    bool m_bMobsDontAttack;
    bool m_bUseDPadForDebug;
    bool m_bMobsDontTick;
    bool m_bFreezePlayers;

    // 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;
    bool m_bDebugOptions;  // toggle debug things on or off

    // Trial timer
    float m_fTrialTimerStart, mfTrialPausedTime;
    typedef struct TimeInfo {
        std::int64_t qwTime;
        std::int64_t qwAppTime;

        float fAppTime;
        float fElapsedTime;
        float fSecsPerTick;
    } TIMEINFO;

    TimeInfo m_Time;

protected:
    static const int MAX_TIPS_GAMETIP = 50;
    static const int MAX_TIPS_TRIVIATIP = 20;
    static TIPSTRUCT m_GameTipA[MAX_TIPS_GAMETIP];
    static TIPSTRUCT m_TriviaTipA[MAX_TIPS_TRIVIATIP];
    static Random* TipRandom;

public:
    void InitialiseTips();
    int GetNextTip();
    int GetHTMLColour(eMinecraftColour colour);
    int GetHTMLColor(eMinecraftColour colour) { return GetHTMLColour(colour); }
    int GetHTMLFontSize(EHTMLFontSize size);
    std::wstring FormatHTMLString(int iPad, const std::wstring& desc,
                                  int shadowColour = 0xFFFFFFFF);
    std::wstring GetActionReplacement(int iPad, unsigned char ucAction);
    std::wstring GetVKReplacement(unsigned int uiVKey);
    std::wstring GetIconReplacement(unsigned int 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);

private:
    int m_TipIDA[MAX_TIPS_GAMETIP + MAX_TIPS_TRIVIATIP];
    unsigned int m_uiCurrentTip;
    static int TipsSortFunction(const void* a, const void* b);

    // XML
public:
    // Hold a vector of terrain feature positions
    void AddTerrainFeaturePosition(_eTerrainFeatureType, int, int);
    void ClearTerrainFeaturePosition();
    _eTerrainFeatureType IsTerrainFeature(int x, int z);
    bool GetTerrainFeaturePosition(_eTerrainFeatureType eType, int* pX,
                                   int* pZ);
    std::vector<FEATURE_DATA*> m_vTerrainFeatures;

    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
    virtual void CaptureSaveThumbnail() = 0;
    virtual void GetSaveThumbnail(std::uint8_t** thumbnailData,
                                  unsigned int* thumbnailSize) = 0;
    virtual void ReleaseSaveThumbnail() = 0;
    virtual void GetScreenshot(int iPad, std::uint8_t** screenshotData,
                               unsigned int* screenshotSize) = 0;

    virtual void ReadBannedList(int iPad, eTMSAction action = (eTMSAction)0,
                                bool bCallback = false) = 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];

private:
    // 	XUI_FontRenderer *m_fontRenderer;
    // 	bool m_bFontRendererOverridden;
    // 	bool m_bOverrideFontRenderer;

    bool m_bRead_BannedListA[XUSER_MAX_COUNT];
    char m_pszUniqueMapName[14];
    bool m_BanListCheck[XUSER_MAX_COUNT];

public:
    void SetBanListCheck(int iPad, bool bVal) { m_BanListCheck[iPad] = bVal; }
    bool GetBanListCheck(int iPad) { return m_BanListCheck[iPad]; }
    // AUTOSAVE
public:
    void SetAutosaveTimerTime(void);
    bool AutosaveDue(void);
    unsigned int SecondsToAutosave();

private:
    unsigned int m_uiAutosaveTimer;
    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();
    static int DLCOffersReturned(void* pParam, 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();
    void unlockSaveNotification();

private:
    std::mutex m_saveNotificationMutex;
    int m_saveNotificationDepth;
    // 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;
    std::mutex csAdditionalModelParts;
    std::mutex csAdditionalSkinBoxes;
    std::mutex csAnimOverrideBitmask;
    bool m_bCorruptSaveDeleted;

    std::uint32_t m_dwAdditionalModelParts[XUSER_MAX_COUNT];

    std::uint8_t* m_pBannedListFileBuffer;
    unsigned int 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);
    std::vector<ModelPart*>* SetAdditionalSkinBoxes(
        std::uint32_t dwSkinID, std::vector<SKIN_BOX*>* pvSkinBoxA);
    std::vector<ModelPart*>* GetAdditionalModelParts(std::uint32_t dwSkinID);
    std::vector<SKIN_BOX*>* GetAdditionalSkinBoxes(std::uint32_t dwSkinID);
    void SetAnimOverrideBitmask(std::uint32_t dwSkinID,
                                unsigned int uiAnimOverrideBitmask);
    unsigned int GetAnimOverrideBitmask(std::uint32_t dwSkinID);

    static std::uint32_t getSkinIdFromPath(const std::wstring& skin);
    static std::wstring getSkinPathFromId(std::uint32_t skinId);

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

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

    bool GetBanListRead(int iPad) { return m_bRead_BannedListA[iPad]; }
    void SetBanListRead(int iPad, bool bVal) {
        m_bRead_BannedListA[iPad] = bVal;
    }
    void ClearBanList(int iPad) {
        BannedListA[iPad].pBannedList = nullptr;
        BannedListA[iPad].byteCount = 0;
    }

    std::uint32_t GetRequiredTexturePackID() {
        return m_dwRequiredTexturePackID;
    }
    void SetRequiredTexturePackID(std::uint32_t texturePackId) {
        m_dwRequiredTexturePackID = texturePackId;
    }

    virtual void GetFileFromTPD(eTPDFileType eType, std::uint8_t* pbData,
                                unsigned int byteCount, std::uint8_t** ppbData,
                                unsigned int* pByteCount) {
        *ppbData = nullptr;
        *pByteCount = 0;
    }

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

private:
    // vector of additional skin model parts, indexed by the skin texture id
    std::unordered_map<std::uint32_t, std::vector<ModelPart*>*>
        m_AdditionalModelParts;
    std::unordered_map<std::uint32_t, std::vector<SKIN_BOX*>*>
        m_AdditionalSkinBoxes;
    std::unordered_map<std::uint32_t, unsigned int> m_AnimOverrides;

    bool m_bResetNether;
    std::uint32_t m_dwRequiredTexturePackID;

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

    void SetTickTMSDLCFiles(bool bVal);

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

private:
    std::unordered_map<int, std::wstring> m_localeA;
    std::unordered_map<std::wstring, int> m_eMCLangA;
    std::unordered_map<std::wstring, int> m_xcLangA;
    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;