#include "Frontend/Store/StoreScreenMgr.h"

#include "Frontend/BusySpinner.h"
#include "Frontend/MiniMap.h"
#include "Frontend/NewHud.h"
#include "Frontend/Store/StoreAdvertScreen.h"
#include "Frontend/Store/StoreMainScreen.h"
#include "Frontend/Store/StoreTextureManager.h"
#include "Frontend/Store/StoreUIChannel.h"
#include "frontend/landing_page/LandingPage.h"
#include "Game/User.h"
#include "Network/Live/NetworkTelemetry.h"
#include "Network/Live/livemanager.h"
#include "Network/Sessions/NetworkSession.h"
#include "System/controlMgr.h"
#include "Text/TextConversion.h"
#include "Vfx/Misc/MovieManager.h"
#include "fwcommerce/CommerceUtil.h"
#include "optimisations.h"
#include "peds/ped.h"
#include "scene/world/GameWorld.h"
#include "Stats/MoneyInterface.h"
#include "Stats/StatsInterface.h"
#include "streaming/defragmentation.h"
#include "streaming/streaming.h"
#include "system/FileMgr.h"
#include "text/messages.h"
#include "Network/NetworkInterface.h"

PARAM(leavempforstore, "The store will cause the player to leave mp sessions.");
PARAM(storeInitialProductId, "Initial Item to Highlight in the Store");

FRONTEND_STORE_OPTIMISATIONS()

#if __XENON
#include <xbox.h>
#endif

#if __BANK
#include "bank/bkmgr.h"
#endif // __BANK

cStoreMainScreen* cStoreScreenMgr::mp_StoreMainScreen = NULL;
bool cStoreScreenMgr::m_IsInitialised = false;
int  cStoreScreenMgr::m_ExitRequestedFrameCount = -1;
bool cStoreScreenMgr::m_bStoreIsOpen = false;

CSprite2d cStoreScreenMgr::sm_BackgroundGradient;
bool cStoreScreenMgr::m_LoadingBgSprite = false;

atString cStoreScreenMgr::m_BaseCategory;
atString cStoreScreenMgr::m_InitialProductID;
bool cStoreScreenMgr::m_InitialProductCheckout = false;

//These defaults are just the last values used before we shifted to the frontend.xml
float cStoreScreenMgr::m_MovieXPos = 0.13632f;
float cStoreScreenMgr::m_MovieYPos = 0.075693f;
float cStoreScreenMgr::m_MovieWidth = 0.728903f;
float cStoreScreenMgr::m_MovieHeight = 0.831947f;

bool cStoreScreenMgr::m_HasXMLBeenRead = false;

int cStoreScreenMgr::m_CurrentStoreBranding = 0;

grcBlendStateHandle cStoreScreenMgr::ms_StandardSpriteBlendStateHandle = grcStateBlock::BS_Invalid;

bool cStoreScreenMgr::m_ReturnToPauseMenu = false;
GEN9_STANDALONE_ONLY(bool cStoreScreenMgr::m_LaunchLandingPageOnClose = false);

cStoreTextureManager cStoreScreenMgr::m_StoreTextureManager;

bool cStoreScreenMgr::m_WasOpenedFromNetworkGame = false;
bool cStoreScreenMgr::m_PendingSessionShutdownToOpen = false;

const int DEFAULT_NUM_ITEMS_PER_COLUMN = 2;
int cStoreScreenMgr::m_StoreItemNumPerColumn = DEFAULT_NUM_ITEMS_PER_COLUMN;

int cStoreScreenMgr::m_ResetPauseRenderPhasesFrameCount = 0;
int cStoreScreenMgr::m_TogglePauseRenderPhasesFrameCount = 0;	
const int FRAMES_TO_DELAY_RENDER_PHASE_RESET = 5;
const int FRAMES_TO_DELAY_RENDER_PHASE_TOGGLE = 8;

const char* COMMERCE_SORT_TAG_MP = "MP";

bool cStoreScreenMgr::m_StoreEnabled = true;

bool cStoreScreenMgr::m_PermitCashProducts = true;
bool cStoreScreenMgr::m_ShouldShowCashProducts = true;

int cStoreScreenMgr::m_StoreOpenFrameDelay = 0;

s64 cStoreScreenMgr::m_WalletCashAmountForDisplay = 0;
s64 cStoreScreenMgr::m_BankCashAmountForDisplay = 0;

atString cStoreScreenMgr::m_PlayerNameForDisplay;

#define	STOREMENU_TXD_PATH ("platform:/textures/frontend")
#define FRONTEND_XML_FILENAME "common:/data/ui/frontend.xml"
#define COMMERCE_NODE "CommerceStore"

const int MP_STORE_FRAME_DELAY = 3;

RAGE_DEFINE_CHANNEL(storeUI)

namespace rage {
    extern char *XEX_TITLE_ID;	//	defined in gta5\src\dev\game\Core\main.cpp
}

void cStoreScreenMgr::Init(unsigned initMode)
{
    if ( INIT_CORE == initMode )
    {
        storeUIAssert(!m_IsInitialised);
        m_IsInitialised = true;

		REGISTER_FRONTEND_XML(cStoreScreenMgr::HandleXML, COMMERCE_NODE);
    }

    m_bStoreIsOpen = false;

    m_CurrentStoreBranding = 0;

    m_StoreItemNumPerColumn = DEFAULT_NUM_ITEMS_PER_COLUMN;

    m_StoreEnabled = true;

	m_PlayerNameForDisplay.Reset();
	m_WalletCashAmountForDisplay = 0;
	m_BankCashAmountForDisplay = 0;

    //Setup the state block
    // stateblocks
    grcBlendStateDesc bsd;

    //	The remaining BlendStates should all have these two flags set
    bsd.BlendRTDesc[0].BlendEnable = true;
    bsd.BlendRTDesc[0].SrcBlend = grcRSV::BLEND_SRCALPHA;
    bsd.BlendRTDesc[0].DestBlend = grcRSV::BLEND_INVSRCALPHA;
    bsd.BlendRTDesc[0].BlendOp = grcRSV::BLENDOP_ADD;
    bsd.BlendRTDesc[0].SrcBlendAlpha = grcRSV::BLEND_SRCALPHA;
    bsd.BlendRTDesc[0].DestBlendAlpha = grcRSV::BLEND_INVSRCALPHA;
    bsd.BlendRTDesc[0].BlendOpAlpha = grcRSV::BLENDOP_ADD;
    bsd.BlendRTDesc[0].RenderTargetWriteMask = grcRSV::COLORWRITEENABLE_ALL;
    ms_StandardSpriteBlendStateHandle = grcStateBlock::CreateBlendState(bsd);

    m_ReturnToPauseMenu = false;
	m_StoreOpenFrameDelay = 0;

    m_BaseCategory = "TOP_DEFAULT"; 
    m_InitialProductID.Reset();
    m_InitialProductCheckout = false;

	m_ShouldShowCashProducts = true;
}

void cStoreScreenMgr::Shutdown(unsigned shutdownMode)
{
    if ( SHUTDOWN_CORE == shutdownMode )
    {
        storeUIAssert(m_IsInitialised);
        m_IsInitialised = false;

        if ( mp_StoreMainScreen )
        {
            delete mp_StoreMainScreen;
            mp_StoreMainScreen = NULL;
        }

        m_InitialProductID.Reset();
        m_InitialProductCheckout = false;
    }
}

void cStoreScreenMgr::Update()
{
    if ( !m_IsInitialised )
    {
        return;
    }

	PF_AUTO_PUSH_TIMEBAR("cStoreScreenMgr Update");

    if ( mp_StoreMainScreen )
    {
        mp_StoreMainScreen->Update();
    }

	// added check to stop any potential loop around
	if (m_ExitRequestedFrameCount > 0)
		--m_ExitRequestedFrameCount;

    if ( m_ExitRequestedFrameCount == 0 )
    {
		storeUIDebugf1("Exit Request Complete, Closing...");
		
        m_ExitRequestedFrameCount = -1;
        if (!Close())
		{
			//Because MS abort function can stall. Thanks MS.
			m_ExitRequestedFrameCount = 1;
			return;
		}
    }

	if ( IsMPGameReadyToOpenStore() )
    {
		storeUIDebugf1("Opening MP store");

        m_PendingSessionShutdownToOpen = false;
        m_ShouldShowCashProducts = true;

		if (CPauseMenu::IsActive())
		{
			CPauseMenu::TriggerStore();
		}
		else
		{
			char cHtmlFormattedBusyString[256];
			char* html = CTextConversion::TextToHtml(TheText.Get("STORE_LOADING"),cHtmlFormattedBusyString,sizeof(cHtmlFormattedBusyString));
			CBusySpinner::On( html, SPINNER_ICON_LOADING, SPINNER_SOURCE_STORE_LOADING );
			Open(false);
		}

// 		PM_ActiveFlags pauseMenuActiveFlags = PM_SkipStore;
// 		if (CPauseMenu::IsActive(pauseMenuActiveFlags))
// 		{
// 			CPauseMenu::Close();
// 		}
    }
    
	if ( m_StoreOpenFrameDelay > 0 )
	{
		m_StoreOpenFrameDelay--;
	}

    m_StoreTextureManager.Update();
    
	if (m_ResetPauseRenderPhasesFrameCount > 0)
	{
		--m_ResetPauseRenderPhasesFrameCount;

		if (m_ResetPauseRenderPhasesFrameCount == 0)
		{
			CPauseMenu::ResetPauseRenderPhases();
		}
	}

	if (m_TogglePauseRenderPhasesFrameCount > 0)
	{
		--m_TogglePauseRenderPhasesFrameCount;

		if (m_TogglePauseRenderPhasesFrameCount == 0)
		{
			//This matches the call we have in cStoreManager::OpenInternal()
			CPauseMenu::TogglePauseRenderPhases(true, OWNER_STORE, __FUNCTION__ );
		}
	}
}

void cStoreScreenMgr::Render()
{
    if ( !m_IsInitialised )
    {
        return;
    }

    if ( !m_bStoreIsOpen )
    {
        return;
    }

	/* B* 1083542: No more store gradient
    grcStateBlock::SetRasterizerState(grcStateBlock::RS_NoBackfaceCull);
    grcStateBlock::SetDepthStencilState(grcStateBlock::DSS_IgnoreDepth);
    grcStateBlock::SetBlendState(ms_StandardSpriteBlendStateHandle);

    RenderBackground();
	*/

    grcStateBlock::SetRasterizerState(grcStateBlock::RS_Default);
    grcStateBlock::SetDepthStencilState(grcStateBlock::DSS_Default);
    grcStateBlock::SetBlendState(grcStateBlock::BS_Default);
    CSprite2d::ClearRenderState();
    CShaderLib::SetGlobalEmissiveScale(1.0f,true);

    if ( mp_StoreMainScreen )
    {
        mp_StoreMainScreen->Render();
    }
}

void cStoreScreenMgr::DisplayAdScreen()
{

}

void cStoreScreenMgr::Open(bool closeToPauseMenu GEN9_STANDALONE_ONLY(, bool launchLandingPageOnClose))
{
#if GEN9_STANDALONE_ENABLED
	m_LaunchLandingPageOnClose = launchLandingPageOnClose;
#endif

#if RSG_PC
	(void)closeToPauseMenu;
	OpenPC();
	return;
#else

    m_ReturnToPauseMenu = closeToPauseMenu;

	//Do not allow the store to be opened if the open is already in progress
	if (m_PendingSessionShutdownToOpen)
	{
		return;
	}

// 	atString baseCat("COMPAT_PACKS");
// 	cStoreScreenMgr::SetBaseCategory(baseCat);

    //If we are in a network game get out
    if ( NetworkInterface::IsGameInProgress() && PARAM_leavempforstore.Get())
    {
		// we don't leave multiplayer anymore
    }
    else
    {
		if ( m_WasOpenedFromNetworkGame || NetworkInterface::IsGameInProgress())
		{
			m_ShouldShowCashProducts = true;
		}
		else
		{
			m_ShouldShowCashProducts = false;
		}

        if ( m_WasOpenedFromNetworkGame )
		{
			m_ReturnToPauseMenu = false;
		}
		else
		{
			//Use this opportunity to store values for display in the store.
			PopulateDisplayValues();
		}

#if !RSG_FINAL
        const char* initialProductId = nullptr;
        if(PARAM_storeInitialProductId.Get(initialProductId))
        {
			storeUIDebugf1("Open :: Command Line InitialProductId: %s", initialProductId);
			m_InitialProductID = initialProductId;
        }
#endif
        
        OpenInternal();
    }
#endif //RSG_PC
}

bool cStoreScreenMgr::IsLoadingAssets()
{
	bool const c_result = mp_StoreMainScreen && mp_StoreMainScreen->IsLoadingAssets();
	return c_result;
}

bool cStoreScreenMgr::RequestMPStore()
{
    storeUIDebugf1("RequestMPStore :: IsGameInProgress: %s", NetworkInterface::IsGameInProgress() ? "True" : "False");
    
    //If we are in a network game get out
	if (NetworkInterface::IsGameInProgress() && PARAM_leavempforstore.Get() )
	{
        // we don't leave multiplayer anymore
	}
	else
	{
		Open(true);
	}

    // might not be the case if !NetworkInterface::IsGameInProgress() but 
    // taking small steps for now
    return true;
}

void cStoreScreenMgr::ResetNetworkGameTracking()
{
    storeUIDebugf1("ResetNetworkGameTracking :: FromNetworkGame: %s", m_WasOpenedFromNetworkGame ? "True" : "False");

	if(m_WasOpenedFromNetworkGame)
	{
		// we need to check for a full network close here as we only run a partial close when entering the store to
		// avoid a long load on entry and exit within multiplayer
		CNetwork::CloseNetwork(true);
#if RSG_DURANGO
		CNetwork::GetNetworkSession().RemoveFromParty(false);
#endif // RSG_DURANGO
		m_WasOpenedFromNetworkGame = false;
	}
}

void cStoreScreenMgr::OpenInternal()
{
	// NOTE: PS3 marketplace has to page out 17MB of memory to system virtual in order to load the commerce data.
	// This CANNOT happen during the Update function otherwise performance will go to shit. To get around this, 
	// we wait until the beginning of the next Update frame via a call to ContainerReserveStore (via game.cpp).
#if COMMERCE_CONTAINER
	CLiveManager::GetCommerceMgr().ContainerReserveStore();
}

void cStoreScreenMgr::OpenInternalPhase2()
{
#endif

	if (!NetworkInterface::IsGameInProgress())
	    CPauseMenu::TogglePauseRenderPhases(false, OWNER_STORE, __FUNCTION__ );

    LoadXmlData();

    char cHtmlFormattedBusyString[256];
    char* html = CTextConversion::TextToHtml(TheText.Get("STORE_LOADING"),cHtmlFormattedBusyString,sizeof(cHtmlFormattedBusyString));
    CBusySpinner::On( html, SPINNER_ICON_LOADING, SPINNER_SOURCE_STORE_LOADING );

    storeUIAssert( mp_StoreMainScreen == NULL );
    if ( mp_StoreMainScreen != NULL )
    {
        return;
    }

    mp_StoreMainScreen = rage_new cStoreMainScreen;
    mp_StoreMainScreen->Init();

	//No longer used.
	//CNetworkTelemetry::EnterIngameStore();

    if (CGameWorld::FindLocalPlayer() && CGameWorld::FindLocalPlayer()->GetPlayerInfo())
    {
        CGameWorld::FindLocalPlayer()->GetPlayerInfo()->DisableControlsFrontend();
    }

    //Check for the RoS cash permission here.
	if (NetworkInterface::GetLocalGamerIndex() == -1 || !rlRos::HasPrivilege(NetworkInterface::GetLocalGamerIndex(), RLROS_PRIVILEGEID_PURCHASEVC) || !MoneyInterface::CanBuyCash(0, 0.0f))
	{
		storeUIDebugf1("OpenInternal :: Cash Products Not Allowed: HasPrivilege: %s, CanBuyCash: %s",
			rlRos::HasPrivilege(NetworkInterface::GetLocalGamerIndex(), RLROS_PRIVILEGEID_PURCHASEVC) ? "True" : "False",
			MoneyInterface::CanBuyCash(0, 0.0f) ? "True" : "False");
		SetCashProductsAllowed(false);
	}
	else
	{	
		storeUIDebugf1("OpenInternal :: Cash Products Allowed");
		SetCashProductsAllowed(true);
	}
 
    //Start the commerce util
    CLiveManager::GetCommerceMgr().CreateCommerceUtil();
    bool isInitialized = CLiveManager::GetCommerceMgr().InitialiseCommerceUtil();

#if RSG_GEN9
    // url:bugstar:7422191 - Gen9 - Story mode / SP upgrade is available on US Disk SKU(in - game and preview store). Story mode is already included on Disk versions of the game.
    // Suppress the Story Mode item if running a version built against Disk SKU. The story mode item id was obtained from RageCommerceData used to populate the store.
    if (SUserEntitlementService::GetInstance().GetGameEntitlementMedium() == UserEntitlementMedium::UEM_DISC)
    {
		storeUIDebugf1("OpenInternal :: Suppressing SPUpgrade: Already entitled");
		CLiveManager::GetCommerceMgr().GetCommerceUtil()->SuppressItemId("SPUpgrade");
    }
#endif //RSG_GEN9

	//We now limit cash products to only within MP games. In the TU I will change this to be based on the commerce data,
	//but since this is going into the main branch I am keeping it simple.
	if ( !m_ShouldShowCashProducts || StatsInterface::GetBlockSaveRequests() || !MoneyInterface::SavegameCanBuyCashProducts() )
	{
		//Suppress cash if required
		CLiveManager::GetCommerceMgr().GetCommerceUtil()->SuppressItemId("Cash");

        //Suppress packs as well
        CLiveManager::GetCommerceMgr().GetCommerceUtil()->SuppressItemId("Packs");

#if RSG_GEN9
		//This is being effectively treated as the "suppress if not in MP" section now. Ideally migrate to a data driven solution, but for now add GTA+ cash cards and the story upgrade
        if(!CLandingPage::IsActive())
        {
            CLiveManager::GetCommerceMgr().GetCommerceUtil()->SuppressItemId("SPUpgrade"); //Removes story mode upgrade from SP
		}
        CLiveManager::GetCommerceMgr().GetCommerceUtil()->SuppressItemId("GTA+Cash"); //Removes GTA+ specific cash from SP
        CLiveManager::GetCommerceMgr().GetCommerceUtil()->SuppressItemId("GTAPlus"); //Removes GTA+ specific cash from SP
#endif

		storeUIDebugf1("OpenInternal :: Suppressing Cash/Packs: ShouldShowCashProducts: %s, GetBlockSaveRequests: %s, SavegameCanBuyCashProducts: %s", 
			m_ShouldShowCashProducts ? "True" : "False",
			StatsInterface::GetBlockSaveRequests() ? "True" : "False",
			MoneyInterface::SavegameCanBuyCashProducts() ? "True" : "False");
	}
    else if (CLiveManager::GetCommerceMgr().IsEntitledToPremiumPack() || CLiveManager::GetCommerceMgr().IsEntitledToStarterPack())
	{
		storeUIDebugf1("OpenInternal :: Suppressing Packs: IsEntitledToPremiumPack: %s, IsEntitledToStarterPack: %s",
			CLiveManager::GetCommerceMgr().IsEntitledToPremiumPack() ? "True" : "False",
			CLiveManager::GetCommerceMgr().IsEntitledToStarterPack() ? "True" : "False");

        CLiveManager::GetCommerceMgr().GetCommerceUtil()->SuppressItemId("Packs");
    }

	//Show the GonD category if appropriate
	if (!CFileMgr::IsDownloadableVersion())
	{
		storeUIDebugf1("OpenInternal :: Suppressing GOND");
		CLiveManager::GetCommerceMgr().GetCommerceUtil()->SuppressItemId("GOND");
	}

#if NET_ENABLE_MEMBERSHIP_FUNCTIONALITY
	// Add relevant subscription Ids
	if (rlScMembership::HasMembership(NetworkInterface::GetLocalGamerIndex()))
	{
		storeUIDebugf1("OpenInternal :: AddSubscriptionId: %s", rlScMembership::GetSubscriptionId());
		CLiveManager::GetCommerceMgr().GetCommerceUtil()->AddSubscriptionId(rlScMembership::GetSubscriptionId());
	}
#endif

    if (isInitialized)
    {
		storeUIDebugf1("OpenInternal :: Fetching Data...");
		CLiveManager::GetCommerceMgr().FetchData();
    }

	if (!NetworkInterface::IsGameInProgress())
	    CPauseMenu::SetupCodeForPause();

    CMiniMap::SetVisible(false);
	CLiveManager::GetCommerceMgr().SetAutoConsumePaused(true);

	//sm_BackgroundGradient.Delete();
    //RequestSprites();
    m_LoadingBgSprite = true;

    m_bStoreIsOpen = true;

    if (m_ShouldShowCashProducts && CLiveManager::GetCommerceMgr().GetCommerceUtil())
    {       
        //MP is the arbitrary sorting tag we use for designating a store source of online.
		storeUIDebugf1("OpenInternal :: Setting Sorting Tag: %s", COMMERCE_SORT_TAG_MP);
		CLiveManager::GetCommerceMgr().GetCommerceUtil()->SetSortingTag(COMMERCE_SORT_TAG_MP);
    }

#if __XENON
    XBackgroundDownloadSetMode(XBACKGROUND_DOWNLOAD_MODE_ALWAYS_ALLOW);
#endif

// Don't allow Share Play or Live Stream while modifying Social Club account details
#if RSG_ORBIS
	NetworkInterface::EnableSharePlay(false);
#elif RSG_NP
	g_rlNp.GetNpLiveStream().BeginDisableSharePlay();
#endif

    //Start up the loading spinner
    //CBusySpinner::On( "Loading the store", CSavingGameMessage::SAVEGAME_ICON_STYLE_WORKING, SPINNER_SOURCE_STORE_LOADING );  
}

bool cStoreScreenMgr::Close()
{
#if RSG_PC
    //On PC everything is handled SCUI side, so we can just return out from here.
    return true;
#else
	storeUIDebugf1("Close");

	if ( CLiveManager::GetCommerceMgr().GetCommerceUtil() && CLiveManager::GetCommerceMgr().GetCommerceUtil()->IsInDataFetchState() )
	{
		CLiveManager::GetCommerceMgr().GetCommerceUtil()->AbortDataFetch();
		if (CLiveManager::GetCommerceMgr().GetCommerceUtil()->IsAbortInProgress())
		{
			return false;
		}
	}

    CMiniMap::SetVisible(true);

    if (CGameWorld::FindLocalPlayer() && CGameWorld::FindLocalPlayer()->GetPlayerInfo())
    {
        CGameWorld::FindLocalPlayer()->GetPlayerInfo()->EnableControlsFrontend();
    }

    if ( mp_StoreMainScreen != NULL )
    {
		CNetworkTelemetry::ExitIngameStore(mp_StoreMainScreen->HasUserBeenInCheckout(), mp_StoreMainScreen->GetTimeSinceInputEnabled());

#if RSG_GEN9
        // Append the nav-out metric. Will be skipped internally if SaInNav hasn't been called.
        CNetworkTelemetry::AppendSaOutNav();
#endif

        delete mp_StoreMainScreen;
        mp_StoreMainScreen = NULL;
    }

    //RemoveSprites();

    CLiveManager::GetCommerceMgr().DestroyCommerceUtil();

    CPauseMenu::SetupCodeForUnPause();
	CLiveManager::GetCommerceMgr().SetAutoConsumePaused(false);

	//This call to CPauseMenu::TogglePauseRenderPhases(true) is needed since CPauseMenu::TogglePauseRenderPhases(false) is Called
	//albeit indirectly by CPauseMenu::SetupCodeForPause, but CPauseMenu::TogglePauseRenderPhases(true) is not called withing SetupCodeForUnpause
	//Will have a chat with the pause menu guys and see if we can sort.
	CPauseMenu::TogglePauseRenderPhases(true, OWNER_PAUSEMENU,  __FUNCTION__ );

    if (m_ReturnToPauseMenu)
    {
        //Clear out the downloaded textures in this case
        ResetStoreTextureManager();

		if ( NetworkInterface::IsGameInProgress() )
		{
			CPauseMenu::Open(FE_MENU_VERSION_MP_PAUSE,true,MENU_UNIQUE_ID_STORE);
		}
		else
		{
			CPauseMenu::Open(FE_MENU_VERSION_SP_PAUSE,true,MENU_UNIQUE_ID_STORE);
		}
    }

    if (m_WasOpenedFromNetworkGame)
    {
        m_WasOpenedFromNetworkGame = false;
        if (NetworkInterface::IsLocalPlayerOnline())
        {
			storeUIDebugf1("Rejoining multiplayer from store");

            //If we have confirmed an invite, join that instead. Otherwise, return to previous session.
            //Indicate, using JoinFailureAction::JFA_Quickmatch, that we should join a random freemode if the
            //previous session is no longer available
            if (CLiveManager::GetInviteMgr().HasConfirmedAcceptedInvite())
            {
                CNetwork::GetNetworkSession().JoinInvite();
            }
            else if (CLiveManager::GetInviteMgr().HasPendingAcceptedInvite())
            {
                CNetwork::GetNetworkSession().WaitForInvite(JoinFailureAction::JFA_Quickmatch, MultiplayerGameMode::GameMode_Freeroam);
            }
            else
            {
                //Default the failure action, for a previous session join, this will work out
                //what we should fall back to 
                CNetwork::GetNetworkSession().JoinPreviousSession(JoinFailureAction::JFA_None);
            }

			//Display the script network spinner early so there isn't a gap while MM is reestablished
			CBusySpinner::On(TheText.Get("PM_INF_PLLT01"),SPINNER_ICON_LOADING,SPINNER_SOURCE_SCRIPT);
        }
        else
        {
            //No longer signed in, bail from multiplayer.
            CNetwork::Bail(sBailParameters(BAIL_PROFILE_CHANGE, BAIL_CTX_PROFILE_CHANGE_FROM_STORE));
        }
    }

	if ( m_ReturnToPauseMenu )
	{
		m_TogglePauseRenderPhasesFrameCount = FRAMES_TO_DELAY_RENDER_PHASE_TOGGLE;
	}
	else
	{
		//We do not do this immediately so the grey background caused by the memory container doesn't cause a flash
		m_ResetPauseRenderPhasesFrameCount = FRAMES_TO_DELAY_RENDER_PHASE_RESET;
	}

#if GEN9_STANDALONE_ENABLED
	if (m_LaunchLandingPageOnClose)
	{
		CLandingPage::SetShouldLaunch( LandingPageConfig::eEntryPoint::ENTRY_FROM_PAUSE );
	}
#endif

#if __XENON
    XBackgroundDownloadSetMode(XBACKGROUND_DOWNLOAD_MODE_AUTO);
#endif
    
	//Make sure the store spinner does not leak.
	CBusySpinner::Off( SPINNER_SOURCE_STORE_LOADING );

    m_bStoreIsOpen = false;

#if RSG_ORBIS
	NetworkInterface::EnableSharePlay(true);
#elif RSG_NP
	g_rlNp.GetNpLiveStream().EndDisableSharePlay();
#endif

	return true;
#endif
}

void cStoreScreenMgr::SetStoreBgScrollSpeed( int speed )
{
    if ( m_bStoreIsOpen && mp_StoreMainScreen )
    {
        mp_StoreMainScreen->SetBgScrollSpeed( speed );
    }
}

#if __BANK

int cStoreScreenMgr::ms_StoreAnimatedBgSpeed = 240;

void StoreScreenWidgetTestTMDownload()
{
    atString texturePath("store/images/store_test_image_content_1.DDS");
     //atString texturePath("news/en/img/socialclub_avatar.dds");
    cStoreScreenMgr::GetTextureManager()->RequestTexture(texturePath);
}

void StoreScreenWidgetTestTMRelease()
{
    atString texturePath("store/images/store_test_image_content_1.DDS");
    //atString texturePath("news/en/img/socialclub_avatar.dds");
    cStoreScreenMgr::GetTextureManager()->ReleaseTexture(texturePath);
}

void StoreScreenMgrWidgetLoadXML()
{
    //Force a reload of the XML data.
    cStoreScreenMgr::LoadXmlData(true);
}

void StoreScreenMgrWidgetApplyScreenAnimation()
{
    cStoreScreenMgr::SetStoreBgScrollSpeed(cStoreScreenMgr::ms_StoreAnimatedBgSpeed);  
}

/*
void StoreScreenWidgetFetchAdvertData()
{
    cStoreScreenMgr::FetchAdvertData();
}
*/

void StoreScreenMgrWidgetSetCashEnabled()
{
	cStoreScreenMgr::SetCashProductsAllowed(true);
}

void StoreScreenMgrWidgetSetCashDisabled()
{
	cStoreScreenMgr::SetCashProductsAllowed(false);
}

void cStoreScreenMgr::InitWidgets()
{
    bkBank *pBank = BANKMGR.FindBank(UI_DEBUG_BANK_NAME);

    if (!pBank)  // create the bank if not found
    {
        pBank = &BANKMGR.CreateBank(UI_DEBUG_BANK_NAME);
    }

    if (pBank)
    {
        pBank->AddButton("Create Store Menu widgets", &cStoreScreenMgr::CreateBankWidgets);
    }
}

void cStoreScreenMgr::CreateBankWidgets()
{
    static bool bStoreScreenBankCreated = false;

    bkBank *bank = BANKMGR.FindBank(UI_DEBUG_BANK_NAME);

    if ((!bStoreScreenBankCreated) && (bank))
    {
        bank->PushGroup("Store Menu");

        bank->AddButton("Store Menu Active", &cStoreScreenMgr::SwitchOnOff);

        //bank->AddButton("Parse advert data", &StoreScreenWidgetFetchAdvertData);

        bank->AddButton("Force XML reload", &StoreScreenMgrWidgetLoadXML);

        bank->AddButton("Start TM DL", &StoreScreenWidgetTestTMDownload);

		
        bank->AddButton("Start TM Release", &StoreScreenWidgetTestTMRelease);

        bank->AddSeparator();

        bank->AddSlider("Set Num Store Items in column (power of 2) (require store exit)",&m_StoreItemNumPerColumn,0,2,DEFAULT_NUM_ITEMS_PER_COLUMN);

        bank->AddSlider("Set store BG scroll speed", &ms_StoreAnimatedBgSpeed,10,400,1);

        bank->AddButton("Apply store BG scroll speed",&StoreScreenMgrWidgetApplyScreenAnimation);

		bank->AddButton("Set Cash Enabled", &StoreScreenMgrWidgetSetCashEnabled);
		bank->AddButton("Set Cash Disabled", &StoreScreenMgrWidgetSetCashDisabled);

        bank->PopGroup();

        bStoreScreenBankCreated = true;
    }
} 

void cStoreScreenMgr::SwitchOnOff()
{
    if ( mp_StoreMainScreen )
    {
        Close();
    }
    else
    {
        Open();
    }
}

#endif

void cStoreScreenMgr::CheckIncomingFunctions(atHashWithStringBank methodName, const GFxValue* args)
{
    //Uncomment when the enum is fixed.
    /*
    if ((eSCALEFORM_BASE_CLASS)(s32)args[0].GetNumber() != SF_BASE_CLASS_STOREMENU)
        return;
   */
    if ( mp_StoreMainScreen )
    {
        mp_StoreMainScreen->CheckIncomingFunctions(methodName, args);
    }
}

void cStoreScreenMgr::RequestExit()
{ 
    if(m_ExitRequestedFrameCount < 0)
    {
		storeUIDebugf1("RequestExit");
		m_ExitRequestedFrameCount = EXIT_REQUEST_FRAME_DELAY;
    }
}

void cStoreScreenMgr::OnSignOffline()
{
	storeUIDebugf1("OnSignOffline");
	ResetNetworkGameTracking();
}

void cStoreScreenMgr::OnSignOut()
{
	storeUIDebugf1("OnSignOut");
	ResetNetworkGameTracking();
}

void cStoreScreenMgr::OnMembershipGained()
{
#if NET_ENABLE_MEMBERSHIP_FUNCTIONALITY
	storeUIDebugf1("OnMembershipGained :: Open: %s, MainScreen: %s",
        m_bStoreIsOpen ? "True" : "False",
        mp_StoreMainScreen ? "Valid" : "Invalid");

	if(m_bStoreIsOpen && mp_StoreMainScreen != nullptr)
	{
		// Add relevant subscription Ids
		storeUIDebugf1("OnMembershipGained :: AddSubscriptionId: %s", rlScMembership::GetSubscriptionId());
		CLiveManager::GetCommerceMgr().GetCommerceUtil()->AddSubscriptionId(rlScMembership::GetSubscriptionId());

        // this flags a refresh
		mp_StoreMainScreen->OnMembershipGained();
	}
#endif
}

void cStoreScreenMgr::DumpDebugInfo()
{
   
}
/*
bool cStoreScreenMgr::FetchAdvertData()
{
    
    storeUIAssertf( mp_StoreAdvertData, "mp_StoreAdvertData is NULL. make sure you call  cStoreScreenMgr::Init before opening" ); 
    if ( mp_StoreAdvertData == NULL )
    {
        return false;
    }

    int localUserIndex = 0;
    const rlGamerInfo* localGamer = NetworkInterface::GetActiveGamerInfo();
    if (!localGamer )
    {
        storeUIAssertf(false, "Local gamer currently is NULL");
        return false;
    }    
    else if ( !localGamer->IsValid() )
    {
        storeUIAssertf(false, "Local gamer currently isn't valid");
        return false;
    }
    else if ( !localGamer->IsOnline() )
    {
        storeUIAssertf(false, "Local gamer currently isn't online");
        return false;
    }
    else
    {
        localUserIndex = localGamer->GetLocalIndex();
    }

    mp_StoreAdvertData->SetLocalUserIndex( localUserIndex );

    mp_StoreAdvertData->StartDataFetch();
    
    

    return true;
}
*/

/////////////////////////////////////////////////////////////////////////////////////
// NAME:	cStoreScreenMgr::RequestSprites()
// PURPOSE:	requests the sprite txd to stream
/////////////////////////////////////////////////////////////////////////////////////
void cStoreScreenMgr::RequestSprites()
{
    if (!sm_BackgroundGradient.GetTexture())
    {
        strLocalIndex iTxdId = g_TxdStore.FindSlot(STOREMENU_TXD_PATH);

        if (iTxdId != -1)
        {
            g_TxdStore.StreamingRequest(iTxdId, (STRFLAG_FORCE_LOAD | STRFLAG_PRIORITY_LOAD | STRFLAG_DONTDELETE));
            CStreaming::SetDoNotDefrag(iTxdId, g_TxdStore.GetStreamingModuleId());
        }
    }
}

/////////////////////////////////////////////////////////////////////////////////////
// NAME:	cStoreScreenMgr::SetupSprites()
// PURPOSE:	checks if the sprites are loaded and then set them up if it has
/////////////////////////////////////////////////////////////////////////////////////
void cStoreScreenMgr::SetupSprites()
{
    if (!sm_BackgroundGradient.GetTexture())
    {
        strLocalIndex iTxdId = strLocalIndex(g_TxdStore.FindSlot(STOREMENU_TXD_PATH));

        if (iTxdId != -1)
        {
            // This should not be a blocking load
            if (g_TxdStore.HasObjectLoaded(iTxdId))
            {
                g_TxdStore.AddRef(iTxdId, REF_OTHER);
                g_TxdStore.PushCurrentTxd();
                g_TxdStore.SetCurrentTxd(iTxdId);
                if (Verifyf(fwTxd::GetCurrent(), "Current Texture Dictionary (id %u) is NULL ",iTxdId.Get()))
                {
                    sm_BackgroundGradient.SetTexture("gradient_background");
                }

                g_TxdStore.PopCurrentTxd();
            }
        }
    }
}

/////////////////////////////////////////////////////////////////////////////////////
// NAME:	cStoreScreenMgr::RemoveSprites()
// PURPOSE:	removes the sprites
/////////////////////////////////////////////////////////////////////////////////////
void cStoreScreenMgr::RemoveSprites()
{
    if (sm_BackgroundGradient.GetTexture())
    {
        sm_BackgroundGradient.Delete();
    }

    strLocalIndex iTxdId = strLocalIndex(g_TxdStore.FindSlot(STOREMENU_TXD_PATH));

    if (iTxdId != -1)
    {
        g_TxdStore.RemoveRef(iTxdId, REF_OTHER);
    }
}

/////////////////////////////////////////////////////////////////////////////////////
// NAME:	cStoreScreenMgr::RenderBackground()
// PURPOSE:	Renders the background gradiant image
/////////////////////////////////////////////////////////////////////////////////////
void cStoreScreenMgr::RenderBackground()
{
    if (sm_BackgroundGradient.GetTexture() && sm_BackgroundGradient.GetShader())
    {
        sm_BackgroundGradient.SetRenderState();

        Vector2 vPos(0.136f, 0.145f);
        Vector2 vSize(0.728f, 0.733f);

        Vector2 v[4], uv[4];
        v[0] = Vector2(vPos.x,vPos.y+vSize.y);
        v[1] = Vector2(vPos.x,vPos.y);
        v[2] = Vector2(vPos.x+vSize.x,vPos.y+vSize.y);
        v[3] = Vector2(vPos.x+vSize.x,vPos.y);

#define __UV_OFFSET (0.002f)
        uv[0] = Vector2(__UV_OFFSET,1.0f-__UV_OFFSET);
        uv[1] = Vector2(__UV_OFFSET,__UV_OFFSET);
        uv[2] = Vector2(1.0f-__UV_OFFSET,1.0f-__UV_OFFSET);
        uv[3] = Vector2(1.0f-__UV_OFFSET,__UV_OFFSET);

        MULTI_MONITOR_ONLY( sm_BackgroundGradient.MoveToScreenGUI(v) );
        sm_BackgroundGradient.Draw(v[0], v[1], v[2], v[3], uv[0], uv[1], uv[2], uv[3], CRGBA(255,255,255,255));
    }
}

bool cStoreScreenMgr::IsBgSpriteLoaded()
{
    bool bSpriteLoaded = false;
    strLocalIndex iTxdId = g_TxdStore.FindSlot(STOREMENU_TXD_PATH);

    if (iTxdId != -1)
    {
        // This should not be a blocking load
        bSpriteLoaded = g_TxdStore.HasObjectLoaded(iTxdId);
    }

    return bSpriteLoaded;
}

atString & cStoreScreenMgr::GetBaseCategory()
{
    return m_BaseCategory;
}

void cStoreScreenMgr::SetBaseCategory( atString &newBaseCat )
{
    m_BaseCategory = newBaseCat;
}

atString & cStoreScreenMgr::GetInitialItemID()
{
    return m_InitialProductID;
}

void cStoreScreenMgr::SetInitialItemID( const atString &newInitialItemID )
{
    m_InitialProductID = newInitialItemID;
}

bool cStoreScreenMgr::GetCheckoutInitialItem()
{
    return m_InitialProductCheckout;
}

void cStoreScreenMgr::SetCheckoutInitialItem(const bool checkoutInitialItem)
{
    m_InitialProductCheckout = checkoutInitialItem;
}

void cStoreScreenMgr::HandleXML( parTreeNode* pCommerceStoreNode )
{
	parTreeNode* pNode = NULL;

	char cBaseCoordsNode[100];

	if (CHudTools::GetWideScreen())
	{
		safecpy(cBaseCoordsNode, "baseCoords_16_9", NELEM(cBaseCoordsNode));
	}
	else
	{
		safecpy(cBaseCoordsNode, "baseCoords_4_3", NELEM(cBaseCoordsNode));
	}

	while( (pNode = pCommerceStoreNode->FindChildWithName(cBaseCoordsNode, pNode) ) != NULL)
	{
		if (pNode->GetElement().FindAttribute("posX"))
		{
			m_MovieXPos = (float)atof(pNode->GetElement().FindAttributeAnyCase("posX")->GetStringValue());
		}

		if (pNode->GetElement().FindAttribute("posY"))
		{
			m_MovieYPos = (float)atof(pNode->GetElement().FindAttributeAnyCase("posY")->GetStringValue());
		}

		if (pNode->GetElement().FindAttribute("sizeX"))
		{
			m_MovieWidth = (float)atof(pNode->GetElement().FindAttributeAnyCase("sizeX")->GetStringValue());
		}

		if (pNode->GetElement().FindAttribute("sizeY"))
		{
			m_MovieHeight = (float)atof(pNode->GetElement().FindAttributeAnyCase("sizeY")->GetStringValue());
		}
	}
	m_HasXMLBeenRead = true;
}

void cStoreScreenMgr::LoadXmlData( bool forceReload )
{
    CFrontendXMLMgr::LoadXML(forceReload);
}

void cStoreScreenMgr::ResetStoreTextureManager()
{
    m_StoreTextureManager.Shutdown();
    m_StoreTextureManager.Init();
}

void cStoreScreenMgr::DelayStoreOpen()
{
	m_StoreOpenFrameDelay += MP_STORE_FRAME_DELAY;
}

void cStoreScreenMgr::PopulateDisplayValues()
{
	// get the cash:
	if ( (CGameWorld::FindLocalPlayer()) && (!CMiniMap::GetInPrologue()) )
	{
		if(NetworkInterface::IsInFreeMode())
		{
			m_WalletCashAmountForDisplay = MoneyInterface::GetVCWalletBalance( );
		}
		else
		{
			m_WalletCashAmountForDisplay = StatsInterface::GetIntStat(STAT_TOTAL_CASH.GetStatId());
		}

		if (NetworkInterface::IsGameInProgress())  // for 1438910
		{
			m_BankCashAmountForDisplay = 0;
			if (!StatsInterface::CloudFileLoadPending(0))  // we want to default to 0 if this fails and not assert to match script
			{
				m_BankCashAmountForDisplay = MoneyInterface::GetVCBankBalance();
			}
		}
	}
	
	if (NetworkInterface::IsGameInProgress())
	{
		CNetGamePlayer* pNetPlayer = NetworkInterface::GetLocalPlayer();

		if (pNetPlayer)
		{		
			if (pNetPlayer->GetGamerInfo().HasDisplayName())
				m_PlayerNameForDisplay = pNetPlayer->GetGamerInfo().GetDisplayName();
			else
				m_PlayerNameForDisplay = pNetPlayer->GetGamerInfo().GetName();
		}
	}
	else
	{
		CMiniMapBlip *pBlip = CMiniMap::GetBlip(CMiniMap::GetUniqueCentreBlipId());

		if (pBlip)
		{
			m_PlayerNameForDisplay = CMiniMap::GetBlipNameValue(pBlip);
		}
	}
}

void cStoreScreenMgr::CheckoutCommerceProduct(const char* productID, int location GEN9_STANDALONE_ONLY(, bool launchLandingPageOnClose))
{
	atString baseCat("TOP_DEFAULT");
	SetBaseCategory(baseCat);

	atString productIDString(productID);
	SetInitialItemID(productIDString);
	SetCheckoutInitialItem(true);

	PopulateDisplayValues();
	CNetworkTelemetry::GetPurchaseMetricInformation().SaveCurrentCash();
	CNetworkTelemetry::GetPurchaseMetricInformation().SetFromLocation((eStorePurchaseLocation)location);

	Open(false GEN9_STANDALONE_ONLY(, launchLandingPageOnClose));
}

bool cStoreScreenMgr::IsMPGameReadyToOpenStore()
{
	//Moved here as this check is becoming unwieldy with all of the different save and profile tests.
	CStatsSavesMgr& saveMgr = CStatsMgr::GetStatsDataMgr().GetSavesMgr();

	bool readyToOpenStore = ( m_PendingSessionShutdownToOpen 
		&& !NetworkInterface::IsSessionActive() 
		&& m_StoreOpenFrameDelay == 0 
		&& !saveMgr.IsSaveInProgress() 
		&& !saveMgr.PendingSaveRequests()
		&& !CLiveManager::GetProfileStatsMgr().PendingFlush() 
		&& !CLiveManager::GetProfileStatsMgr().PendingMultiplayerFlushRequest() );

	return readyToOpenStore;
}

#if RSG_PC
void cStoreScreenMgr::OpenPC()
{
	g_rlPc.GetCommerceManager()->ShowCommerceStore(NULL,NULL);
}
#endif

bool cStoreScreenMgr::IsStoreMenuOpen()
{
#if RSG_PC
    //There is no current way to query for a specific SCUI panel, so I will treat the SCUI in general as being the store
    return g_rlPc.IsUiShowing();
#else
    return m_bStoreIsOpen;
#endif
}