//===========================================================================
// Copyright (C) 2000 Radical Entertainment Ltd.  All rights reserved.
//
// Component:   CGuiScreenMainMenu
//
// Description: Implementation of the CGuiScreenMainMenu class.
//
// Authors:     Darwin Chau
//              Tony Chu
//
// Revisions		Date			Author	    Revision
//                  2000/11/20		DChau		Created
//                  2002/06/06      TChu        Modified for SRR2
//
//===========================================================================

//===========================================================================
// Includes
//===========================================================================
#include <presentation/gui/frontend/guiscreenmainmenu.h>
#include <presentation/gui/frontend/guiscreenplaymovie.h>
#include <presentation/gui/guimenu.h>
#include <presentation/gui/guisystem.h>
#include <presentation/gui/guiscreenmemorycard.h>
#include <presentation/gui/guimanager.h>
#include <presentation/gui/guiscreenprompt.h>

#include <constants/movienames.h>
#include <data/gamedatamanager.h>
#include <data/persistentworldmanager.h>
#include <events/eventmanager.h>
#include <input/inputmanager.h>
#include <memory/srrmemory.h>
#include <mission/charactersheet/charactersheetmanager.h>
#include <mission/rewards/rewardsmanager.h>
#include <render/rendermanager/rendermanager.h>
#include <render/rendermanager/renderlayer.h>

#include <p3d/view.hpp>

#include <raddebug.hpp>     // Foundation
#include <radtime.hpp>
#include <radkey.hpp>
#include <radmath/random.hpp>
#include <p3d/anim/multicontroller.hpp>

#include <stdlib.h>
#include <group.h>
#include <layer.h>
#include <page.h>
#include <pure3dobject.h>
#include <screen.h>
#include <text.h>

#include <string.h>

//===========================================================================
// Global Data, Local Data, Local Classes
//===========================================================================

//#define PLAY_GAGS_SEQUENTIALLY
//#define PLAY_ONLY_HOMER_GAGS

const float FIRST_TIME_FADE_IN_TIME = 500.0f;

const unsigned int MIN_GAGS_CYCLE_TIME = 15; // in seconds
const unsigned int MAX_GAGS_CYCLE_TIME = 30; // in seconds
const unsigned int GAGS_RANDOM_NUMBER_MODULO = 97;

const tColour FE_BLUE_SKY_COLOUR( 128, 255, 255 );

struct HomerGagAnimation
{
    float startFrame;
    float endFrame;
};

HomerGagAnimation HOMER_GAG_ANIMATION[] =
{
    {   0.0f,  75.0f },
    {  75.0f, 145.0f },
    { 145.0f, 215.0f },
    { 215.0f, 355.0f },
    { 355.0f, 475.0f },

    { -1.0f, -1.0f } // dummy terminator
};

int NUM_HOMER_GAG_ANIMATIONS =
    sizeof( HOMER_GAG_ANIMATION ) / sizeof( HOMER_GAG_ANIMATION[ 0 ] ) - 1;

const radKey32 FE_GAGS[] =
{
    ::radMakeKey32( "FE_Gag_Homer" ),
    ::radMakeKey32( "FE_Gag_Grandpa" ),
    ::radMakeKey32( "FE_Gag_Moleman" ),
    ::radMakeKey32( "FE_Gag_Frink" ),
    ::radMakeKey32( "FE_Gag_Barney" ),
    ::radMakeKey32( "FE_Gag_Nick" ),
    ::radMakeKey32( "FE_Gag_Snake" ),
    ::radMakeKey32( "FE_Gag_Maggie" ),

    ::radMakeKey32( "FE_Gag_UNKNOWN" )
};

const radKey32 FE_GAGS_FOR_HOMER[] =
{
    ::radMakeKey32( "FE_Gag_Homer_ScratchHead" ),
    ::radMakeKey32( "FE_Gag_Homer_ScratchBum" ),
    ::radMakeKey32( "FE_Gag_Homer_Yawn" ),
    ::radMakeKey32( "FE_Gag_Homer_Nightmare" ),
    ::radMakeKey32( "FE_Gag_Homer_Stretch" ),

    ::radMakeKey32( "FE_Gag_UNKNOWN" )
};

enum eMainMenuItem
{
    MENU_ITEM_MAIN_MENU,
/*
    MENU_ITEM_NEW_GAME,
    MENU_ITEM_RESUME_GAME,
    MENU_ITEM_LOAD_GAME,
    MENU_ITEM_COLLECTIBLE_CARDS,
    MENU_ITEM_OPTIONS,
*/

#ifdef SRR2_LEVEL_SELECTION
    MENU_ITEM_LEVEL,
#endif

    NUM_MAIN_MENU_ITEMS
};

//===========================================================================
// Public Member Functions
//===========================================================================

//===========================================================================
// CGuiScreenMainMenu::CGuiScreenMainMenu
//===========================================================================
// Description: Constructor.
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      N/A.
//
//===========================================================================
CGuiScreenMainMenu::CGuiScreenMainMenu
(
	Scrooby::Screen* pScreen,
	CGuiEntity* pParent
)
:
	CGuiScreen( pScreen, pParent, GUI_SCREEN_ID_MAIN_MENU ),
    m_pMenu( NULL ),
    m_gags( NULL ),
    m_currentGagIndex( -1 ),
    m_nextGagIndex( -1 ),
    m_nextHomerGagIndex( -1 ),
    m_gagsElapsedTime( 0 ),
    m_gagsCycleTime( 1000 * MIN_GAGS_CYCLE_TIME ),
    m_homer( NULL ),
    m_raceCar( NULL ),
    m_homerIdleAnim( NULL ),
    m_tvFrame( NULL )
{
MEMTRACK_PUSH_GROUP( "CGUIScreenMainMenu" );
    memset( m_glowingItems, 0, sizeof( m_glowingItems ) );

    // Retrieve the Scrooby drawing elements.
    //
    Scrooby::Page* pPage = m_pScroobyScreen->GetPage( "MainMenu" );
    rAssert( pPage != NULL );

/*
    // get accept button icon
    //
    if( m_buttonIcons[ BUTTON_ICON_ACCEPT ] == NULL )
    {
        m_buttonIcons[ BUTTON_ICON_ACCEPT ] = pPage->GetGroup( "AcceptLabel" );
        rAssert( m_buttonIcons[ BUTTON_ICON_ACCEPT ] != NULL );
    }
*/

    // Create a menu.
    //
    m_pMenu = new CGuiMenu( this, NUM_MAIN_MENU_ITEMS, GUI_TEXT_MENU );
    rAssert( m_pMenu != NULL );

    // Add menu items
    //
    Scrooby::Text* otherMainMenu = NULL;

#ifdef RAD_WIN32
    m_pMenu->AddMenuItem( pPage->GetText( "MainMenu_PC" ),
                          pPage->GetText( "MainMenu_PC" ),
                          NULL,
                          NULL,
                          pPage->GetSprite( "MainMenu_LArrow" ),
                          pPage->GetSprite( "MainMenu_RArrow" ) );

    otherMainMenu = pPage->GetText( "MainMenu" );
#else
    m_pMenu->AddMenuItem( pPage->GetText( "MainMenu" ),
                          pPage->GetText( "MainMenu" ),
                          NULL,
                          NULL,
                          pPage->GetSprite( "MainMenu_LArrow" ),
                          pPage->GetSprite( "MainMenu_RArrow" ) );

    otherMainMenu = pPage->GetText( "MainMenu_PC" );
#endif

    if( otherMainMenu != NULL )
    {
        otherMainMenu->SetVisible( false );
    }

    // wrap main menu text
    //
    Scrooby::Text* mainMenuText = dynamic_cast<Scrooby::Text*>( m_pMenu->GetMenuItem( MENU_ITEM_MAIN_MENU )->GetItem() );
    rAssert( mainMenuText != NULL );
    mainMenuText->SetTextMode( Scrooby::TEXT_WRAP );

#ifdef RAD_DEMO
    m_pMenu->SetSelectionValueCount( MENU_ITEM_MAIN_MENU, NUM_MAIN_MENU_SELECTIONS );
    m_pMenu->SetSelectionValue( MENU_ITEM_MAIN_MENU, MAIN_MENU_PLAY_LEVEL_2 );

    HeapMgr()->PushHeap( GMA_LEVEL_FE );
    mainMenuText->SetString( MAIN_MENU_PLAY_LEVEL_2, "PLAY LEVEL 2" ); // TC: [TODO] localization??
    mainMenuText->SetString( MAIN_MENU_PLAY_LEVEL_7, "PLAY LEVEL 7" ); // TC: [TODO] localization??
    HeapMgr()->PopHeap( GMA_LEVEL_FE );
#endif

    // scale up main menu text a bit
    //
//    m_pMenu->GetMenuItem( MENU_ITEM_MAIN_MENU )->GetItem()->ScaleAboutCenter( 1.2f );

    Scrooby::Page* levelPage = m_pScroobyScreen->GetPage( "Level" );
    if( levelPage != NULL )
    {
#ifdef SRR2_LEVEL_SELECTION
        m_pMenu->AddMenuItem( levelPage->GetText( "Level" ),
                              levelPage->GetText( "Level" ),
                              NULL,
                              NULL,
                              NULL,
                              NULL,
                              SELECTION_ENABLED | VALUES_WRAPPED | TEXT_OUTLINE_ENABLED );

    #ifndef RAD_DEBUG
        // hide level/car selection menu by default
        // in Tune and Release builds
        //
        this->ToggleLevelMenu();
    #endif
#else
        Scrooby::Group* levelMenu = levelPage->GetGroup( "Menu" );
        rAssert( levelMenu != NULL );
        levelMenu->SetVisible( false );
#endif
    }

    // Retrieve drawing elements from 3dFE page
    //
	pPage = m_pScroobyScreen->GetPage( "3dFE" );
	rAssert( pPage != NULL );
    m_homer = pPage->GetPure3dObject( "Homer" );
    m_raceCar = pPage->GetPure3dObject( "RaceCar" );

    // get glowing items
    //
#ifdef RAD_DEMO
    m_glowingItems[ MAIN_MENU_PLAY_LEVEL_2 ] = pPage->GetPure3dObject( "Glow4" );
    m_glowingItems[ MAIN_MENU_PLAY_LEVEL_7 ] = pPage->GetPure3dObject( "Glow4" );
    m_glowingItems[ MAIN_MENU_OPTIONS ] = pPage->GetPure3dObject( "Glow2" );

    Scrooby::Pure3dObject* glowingItem = NULL;

    glowingItem = pPage->GetPure3dObject( "Glow0" );
    rAssert( glowingItem != NULL );
    glowingItem->SetVisible( false );

    glowingItem = pPage->GetPure3dObject( "Glow1" );
    rAssert( glowingItem != NULL );
    glowingItem->SetVisible( false );

    glowingItem = pPage->GetPure3dObject( "Glow3" );
    rAssert( glowingItem != NULL );
    glowingItem->SetVisible( false );

    glowingItem = pPage->GetPure3dObject( "Glow5" );
    rAssert( glowingItem != NULL );
    glowingItem->SetVisible( false );
#else
    for( int i = 0; i < NUM_MAIN_MENU_SELECTIONS; i++ )
    {
        char name[ 16 ];
        sprintf( name, "Glow%d", i );
        m_glowingItems[ i ] = pPage->GetPure3dObject( name );
    }
#endif

    this->TurnOnGlowItems( 0 ); // all off, by default

    // 3D FE Gags
    //
    m_gags = m_pScroobyScreen->GetPage( "3dFEGags" );
    rAssert( m_gags );

    // Retrieve drawing elements from TVFrame page
    //
	pPage = m_pScroobyScreen->GetPage( "TVFrame" );
	rAssert( pPage );
    m_tvFrame = pPage->GetLayer( "TVFrame" );

    // correct TV frame proportion and size on GC and PS2 and pc
    //
    Scrooby::Sprite* tvFrame = pPage->GetSprite( "TVFrame" );
    if( tvFrame != NULL )
    {
        tvFrame->ResetTransformation();

#ifdef RAD_GAMECUBE
        tvFrame->ScaleAboutCenter( 1.1f, 1.0f, 1.0f );
#endif

#ifdef RAD_PS2
        tvFrame->ScaleAboutCenter( 1.07f );
#endif

#ifdef RAD_WIN32
        tvFrame->ScaleAboutCenter( 1.03f );
#endif
    }
MEMTRACK_POP_GROUP( "CGUIScreenMainMenu" );
}


//===========================================================================
// CGuiScreenMainMenu::~CGuiScreenMainMenu
//===========================================================================
// Description: Destructor.
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      N/A.
//
//===========================================================================
CGuiScreenMainMenu::~CGuiScreenMainMenu()
{
    if( m_nextGagIndex == -1 )
    {
        // stop any FE gag dialog that was triggered and may still be playing
        //
        GetEventManager()->TriggerEvent( EVENT_FE_GAG_STOP );
    }

    if( m_homerIdleAnim != NULL )
    {
        m_homerIdleAnim->Release();
        m_homerIdleAnim = NULL;
    }

    if( m_pMenu != NULL )
    {
        delete m_pMenu;
        m_pMenu = NULL;
    }

    // restore black clear colour
    //
    GetRenderManager()->mpLayer(RenderEnums::GUI)->pView( 0 )->SetClearColour( tColour( 0, 0, 0 ) );
}


//===========================================================================
// CGuiScreenMainMenu::HandleMessage
//===========================================================================
// Description: 
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      N/A.
//
//===========================================================================
void CGuiScreenMainMenu::HandleMessage
(
	eGuiMessage message, 
	unsigned int param1,
	unsigned int param2 
)
{
    if( message == GUI_MSG_MENU_PROMPT_RESPONSE )
    {
#ifndef RAD_WIN32
        rAssert( param1 == PROMPT_CONFIRM_NEW_GAME );
#endif

        if( param1 == PROMPT_CONFIRM_NEW_GAME )
        {            
            switch( param2 )
            {
                case CGuiMenuPrompt::RESPONSE_YES:
                {
#ifdef SRR2_LEVEL_SELECTION
                    int level = m_pMenu->GetSelectionValue( MENU_ITEM_LEVEL );
                    this->OnNewGameSelected( static_cast<RenderEnums::LevelEnum>( level ) );
#else
                    this->OnNewGameSelected();
#endif // SRR2_LEVEL_SELECTION

                    CGuiScreen* pScreen = static_cast<CGuiScreen*>( m_guiManager->FindWindowByID( GUI_SCREEN_ID_GENERIC_PROMPT ) );
                    rAssert( pScreen != NULL );
                    pScreen->StartTransitionAnimation( 0, 53 );

                    break;
                }
                case CGuiMenuPrompt::RESPONSE_NO:
                {
                    this->ReloadScreen();

                    break;
                }
                default:
                {
                    rAssertMsg( false, "Invalid prompt response!" );

                    break;
                }
            }
        }
#ifdef RAD_WIN32
        else if( param1 == PROMPT_CONFIRM_QUIT )
        {
            switch( param2 )
            {
                case (CGuiMenuPrompt::RESPONSE_YES):
                {
                    // send message to front-end manager to quit front-end and
                    // exit the game.
                    //
                    m_pParent->HandleMessage( GUI_MSG_QUIT_GAME );

                    break;
                }

                case (CGuiMenuPrompt::RESPONSE_NO):
                {
                    this->ReloadScreen();

                    break;
                }

                default:
                {
                    rAssertMsg( 0, "WARNING: *** Invalid prompt response!\n" );

                    break;
                }
            }
        }
#endif
    }

    if( m_firstTimeEntered &&
        message == GUI_MSG_WINDOW_ENTER )
    {
        if( CGuiScreenIntroTransition::s_introTransitionPlayed )
        {
            this->SetFadingEnabled( false );
        }
    }

    if( m_state == GUI_WINDOW_STATE_RUNNING )
    {
        switch( message )
        {
            case GUI_MSG_UPDATE:
            {
                this->UpdateRunning( param1 );

                break;
            }
#ifdef SRR2_LEVEL_SELECTION
            // show/hide level and car selection menu (for Tune and Release)
            //
            case GUI_MSG_CONTROLLER_L1:
            case GUI_MSG_CONTROLLER_R1:
            {
                this->ToggleLevelMenu();

                break;
            }
            case GUI_MSG_CONTROLLER_START:
            {
                if( m_pMenu->GetSelection() == MENU_ITEM_LEVEL )
                {
                    rAssert( m_pMenu != NULL );
                    m_pMenu->Reset();
                    m_pMenu->SetSelectionValue( 0, MAIN_MENU_NEW_GAME );
                }

                break;
            }
#endif
            case GUI_MSG_MENU_SELECTION_VALUE_CHANGED:
            {
                if( param1 == MENU_ITEM_MAIN_MENU )
                {
                    // turn on new glow item
                    //
                    this->TurnOnGlowItems( (1 << param2) );

#ifndef RAD_DEMO
                    if( param2 == MAIN_MENU_MINI_GAME ) // special case for mini-game
                    {
                        if( !GetCharacterSheetManager()->IsMiniGameUnlocked() &&
                            !CommandLineOptions::Get( CLO_SKIP_FE ) )
                        {
                            // don't turn on glowing track
                            //
                            this->TurnOnGlowItems( 0 );

                            // grey out selection
                            //
                            m_pMenu->GetMenuItem( MENU_ITEM_MAIN_MENU )->GetItemValue()->SetColour( tColour( 128, 128, 128 ) );

                            // hide accept button icon
                            //
                            this->SetButtonVisible( BUTTON_ICON_ACCEPT, false );
#ifdef RAD_WIN32
                            GetInputManager()->GetFEMouse()->SetClickable( false );
#endif
                            
                        }
                    }
                    else
                    {
                        // restore menu selection colour and accept button icon
                        //
                        tColour menuHighlightColour = m_pMenu->GetHighlightColour();
                        m_pMenu->GetMenuItem( MENU_ITEM_MAIN_MENU )->GetItemValue()->SetColour( menuHighlightColour );

                        this->SetButtonVisible( BUTTON_ICON_ACCEPT, true );
#ifdef RAD_WIN32
                        GetInputManager()->GetFEMouse()->SetClickable( true );
#endif
                    }
#endif // !RAD_DEMO
                }

                break;
            }
            case GUI_MSG_CONTROLLER_SELECT:
            {
                if( !this->IsButtonVisible( BUTTON_ICON_ACCEPT ) )
                {
                    return;
                }
#ifdef RAD_DEMO
                if( m_pMenu->GetSelectionValue( MENU_ITEM_MAIN_MENU ) == MAIN_MENU_PLAY_LEVEL_2 ||
                    m_pMenu->GetSelectionValue( MENU_ITEM_MAIN_MENU ) == MAIN_MENU_PLAY_LEVEL_7 )
#else
                if( m_pMenu->GetSelectionValue( MENU_ITEM_MAIN_MENU ) == MAIN_MENU_NEW_GAME ||
                    m_pMenu->GetSelectionValue( MENU_ITEM_MAIN_MENU ) == MAIN_MENU_RESUME_GAME )
#endif
                {
                    GetInputManager()->RegisterControllerID( 0, param1 );
                    GetGuiSystem()->SetPrimaryController(param1);
                }

#ifndef RAD_DEMO
                if( m_pMenu->GetSelectionValue( MENU_ITEM_MAIN_MENU ) == MAIN_MENU_MINI_GAME )
                {
                    GetGuiSystem()->SetPrimaryController(param1);
                }
#endif // !RAD_DEMO

                break;
            }
#ifdef RAD_WIN32
            case GUI_MSG_CONTROLLER_BACK:
            {
                this->OnQuitGameSelected();

                break;
            }
#endif
            case GUI_MSG_MENU_SELECTION_MADE:
            {
                rAssert( param1 == MENU_ITEM_MAIN_MENU );
                rAssert( m_pMenu != NULL );
                int menuSelection = m_pMenu->GetSelectionValue( param1 );

                switch( menuSelection )
                {
#ifdef RAD_DEMO
                    case MAIN_MENU_PLAY_LEVEL_2:
                    {
                        this->OnNewGameSelected( RenderEnums::L2, RenderEnums::M1 );

                        break;
                    }
                    case MAIN_MENU_PLAY_LEVEL_7:
                    {
                        this->OnNewGameSelected( RenderEnums::L7, RenderEnums::M1 );

                        break;
                    }
#else
                    case MAIN_MENU_NEW_GAME:
                    {
                        if( GetGameDataManager()->IsGameLoaded() )
                        {
                            // prompt user to confirm first
                            //
                            m_guiManager->DisplayPrompt( PROMPT_CONFIRM_NEW_GAME, this );
                        }
                        else
                        {
#ifdef SRR2_LEVEL_SELECTION
                            int level = m_pMenu->GetSelectionValue( MENU_ITEM_LEVEL );
                            this->OnNewGameSelected( static_cast<RenderEnums::LevelEnum>( level ) );
#else
                            this->OnNewGameSelected();
#endif // SRR2_LEVEL_SELECTION
                        }

                        break;
                    }
                    case MAIN_MENU_RESUME_GAME:
                    {
                        this->OnResumeGameSelected();

                        break;
                    }
                    case MAIN_MENU_MINI_GAME:
                    {
                        this->OnMiniGameSelected();

                        break;
                    }
                    case MAIN_MENU_LOAD_GAME:
                    {
#ifdef RAD_XBOX
                        // Xbox TCR Requirement: always prompt user to select memory
                        // device before loading/saving
                        //
                        CGuiScreenLoadSave::s_forceGotoMemoryCardScreen = true;
#endif // RAD_XBOX
                        m_pParent->HandleMessage( GUI_MSG_GOTO_SCREEN, GUI_SCREEN_ID_LOAD_GAME );

                        this->StartTransitionAnimation( 200, 230 );

                        break;
                    }
                    case MAIN_MENU_CARD_GALLERY:
                    {
                        m_pParent->HandleMessage( GUI_MSG_GOTO_SCREEN, GUI_SCREEN_ID_SCRAP_BOOK );

                        this->StartTransitionAnimation( 320, 350 );

                        break;
                    }
#endif // RAD_DEMO
                    case MAIN_MENU_OPTIONS:
                    {
                        m_pParent->HandleMessage( GUI_MSG_GOTO_SCREEN, GUI_SCREEN_ID_OPTIONS );

                        this->StartTransitionAnimation( 80, 110 );

                        break;
                    }
#ifdef RAD_WIN32
                    case MAIN_MENU_QUIT_GAME:
                    {
                        this->OnQuitGameSelected();

                        break;
                    }
#endif
                    default:
                    {
                        rAssertMsg( false, "Invalid main menu selection!" );

                        break;
                    }
                }

                break;
            }
            default:
            {
                break;
            }
        }

        if( m_pMenu != NULL )
        {
            // relay message to menu
            m_pMenu->HandleMessage( message, param1, param2 );
        }
    }
    else if( m_state == GUI_WINDOW_STATE_INTRO )
    {
        switch( message )
        {
            case GUI_MSG_UPDATE:
            {
                this->UpdateIntro( param1 );

                break;
            }
            default:
            {
                break;
            }
        }
    }
    else if( m_state == GUI_WINDOW_STATE_OUTRO )
    {
        switch( message )
        {
            case GUI_MSG_UPDATE:
            {
                this->UpdateOutro( param1 );

                break;
            }
            default:
            {
                break;
            }
        }
    }

	// Propogate the message up the hierarchy.
	//
	CGuiScreen::HandleMessage( message, param1, param2 );
}

void
CGuiScreenMainMenu::InitMenu()
{
#ifndef RAD_DEMO
    bool isGameLoaded = GetGameDataManager()->IsGameLoaded();

    rAssert( m_pMenu != NULL );
    m_pMenu->SetSelectionValueCount( MENU_ITEM_MAIN_MENU,
                                     isGameLoaded ? NUM_MAIN_MENU_SELECTIONS : NUM_MAIN_MENU_SELECTIONS - 1 );

    m_pMenu->SetSelectionValue( MENU_ITEM_MAIN_MENU,
                                isGameLoaded ? MAIN_MENU_RESUME_GAME : MAIN_MENU_NEW_GAME );
#endif // !RAD_DEMO
}

//===========================================================================
// CGuiScreenMainMenu::InitIntro
//===========================================================================
// Description: 
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      N/A.
//
//===========================================================================
void CGuiScreenMainMenu::InitIntro()
{
    if( m_firstTimeEntered )
    {
        this->SetFadeTime( FIRST_TIME_FADE_IN_TIME );
        this->InitMenu();

        // set clear colour to a blue sky colour
        //
        GetRenderManager()->mpLayer(RenderEnums::GUI)->pView( 0 )->SetClearColour( FE_BLUE_SKY_COLOUR );
    }
}

//===========================================================================
// CGuiScreenMainMenu::InitRunning
//===========================================================================
// Description: 
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      N/A.
//
//===========================================================================
void CGuiScreenMainMenu::InitRunning()
{
    if( m_firstTimeEntered )
    {
        this->SetFadingEnabled( true );
        this->RestoreDefaultFadeTime();

        m_screenCover = NULL;
    }

    // turn on current glow item
    //
    rAssert( m_pMenu != NULL );
    this->TurnOnGlowItems( (1 << m_pMenu->GetSelectionValue( MENU_ITEM_MAIN_MENU )) );
}

//===========================================================================
// CGuiScreenMainMenu::InitOutro
//===========================================================================
// Description: 
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      N/A.
//
//===========================================================================
void CGuiScreenMainMenu::InitOutro()
{
    if( m_nextGagIndex == -1 )
    {
        // stop any FE gag dialog that was triggered and may still be playing
        //
        GetEventManager()->TriggerEvent( EVENT_FE_GAG_STOP );
    }

    // turn off all glow items
    //
    this->TurnOnGlowItems( 0 );
}

//===========================================================================
// CGuiScreenMainMenu::UpdateIntro
//===========================================================================
// Description: 
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      N/A.
//
//===========================================================================
void CGuiScreenMainMenu::UpdateIntro( unsigned int elapsedTime )
{
    if( m_firstTimeEntered )
    {
        // hide duplicate homer
        //
        if( m_gags != NULL )
        {
            Scrooby::Pure3dObject* p3dGag = m_gags->GetPure3dObject( "Gag0" );
            rAssert( p3dGag );
            if( p3dGag->GetMultiController() != NULL )
            {
                p3dGag->SetVisible( false );
            }
        }
    }
}

//===========================================================================
// CGuiScreenMainMenu::UpdateRunning
//===========================================================================
// Description: 
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      N/A.
//
//===========================================================================
void CGuiScreenMainMenu::UpdateRunning( unsigned int elapsedTime )
{
    GetMemoryCardManager()->Update( elapsedTime );
    this->UpdateGags( elapsedTime );
}

//===========================================================================
// CGuiScreenMainMenu::UpdateOutro
//===========================================================================
// Description: 
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      N/A.
//
//===========================================================================
void CGuiScreenMainMenu::UpdateOutro( unsigned int elapsedTime )
{
    int currentMenuSelection = m_pMenu->GetSelectionValue( MENU_ITEM_MAIN_MENU );

#ifdef RAD_DEMO
    if( currentMenuSelection == MAIN_MENU_PLAY_LEVEL_2 ||
        currentMenuSelection == MAIN_MENU_PLAY_LEVEL_7 )
#else
    if( currentMenuSelection == MAIN_MENU_NEW_GAME ||
        currentMenuSelection == MAIN_MENU_RESUME_GAME ||
        currentMenuSelection == MAIN_MENU_MINI_GAME )
#endif
    {
        rAssert( m_p3dObject != NULL );

        tMultiController* multiController = m_p3dObject->GetMultiController();
        if( multiController != NULL )
        {
            const float NUM_FADE_OUT_FRAMES = 15.0f;
            float currentFrame = multiController->GetFrame();
            float numRemainingFrames = multiController->GetNumFrames() - currentFrame;

            if( numRemainingFrames < NUM_FADE_OUT_FRAMES )
            {
                // fade out TV frame
                //
                if( m_tvFrame != NULL )
                {
                    float alpha = numRemainingFrames / NUM_FADE_OUT_FRAMES;

                    // decrease fade rate for low alpha values
                    alpha *= alpha;

                    if( alpha > 0.0f && alpha < 1.0f )
                    {
                        m_tvFrame->SetAlpha( alpha );
                    }
                    else
                    {
                        m_tvFrame->SetAlpha( 0.0f );
                    }
                }

                // TC [HACK]: To prevent any clipping in homer's mouth
                //            in the last few frames.
                //
                if( numRemainingFrames < 1.0f )
                {
                    this->RestoreScreenCover();
                }
            }

#ifndef RAD_DEMO
            if( currentMenuSelection == MAIN_MENU_MINI_GAME )
            {
                const float NUM_RACE_CAR_FRAMES_FOR_BLENDING = 11.0f;

                rAssert( m_raceCar != NULL );
                if( currentFrame < 1.0f )
                {
                    // get number of frames remaining in race car animation
                    //
                    tMultiController* raceMultiController = m_raceCar->GetMultiController();
                    rAssert( raceMultiController != NULL );

                    int currentRaceFrame = (int)raceMultiController->GetFrame() % (int)raceMultiController->GetNumFrames();
                    float numRemainingRaceFrames = raceMultiController->GetNumFrames() - currentRaceFrame;
                    raceMultiController->SetRelativeSpeed( numRemainingRaceFrames / NUM_RACE_CAR_FRAMES_FOR_BLENDING );
                }
                else if( currentFrame > NUM_RACE_CAR_FRAMES_FOR_BLENDING )
                {
                    // hide duplicate race car
                    //
                    m_raceCar->SetVisible( false );
                }
            }
#endif // !RAD_DEMO
        }
    }
}

//---------------------------------------------------------------------
// Private Functions
//---------------------------------------------------------------------

//===========================================================================
// CGuiScreenMainMenu::UpdateGags
//===========================================================================
// Description: 
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      N/A.
//
//===========================================================================
void CGuiScreenMainMenu::UpdateGags( unsigned int elapsedTime )
{
    static float NUM_BLEND_FRAMES = 10.0f;

    // if the homer gag animation is running
    //
    if( m_homerIdleAnim != NULL && m_homer != NULL )
    {
        // check if homer gag animation is done
        //
        tMultiController* homerMultiController = m_homer->GetMultiController();
        if( homerMultiController != NULL )
        {
            tAnimationFrameController* homerFrameController =
                (tAnimationFrameController*)homerMultiController->GetTrack( 0 );
            rAssert( homerFrameController );

            if( homerFrameController->LastFrameReached() > 0 )
            {
                // ok, last frame has been reached on homer gag animation;
                // restore the homer idle animation
                //
                if( m_homerIdleAnim != NULL )
                {
                    homerFrameController->SetAnimation( m_homerIdleAnim, 0.0f, 0.0f );

                    m_homerIdleAnim->Release();
                    m_homerIdleAnim = NULL;
                }

                // restore homer idle animation frame range
                //
                homerMultiController->SetFrameRange( 0.0f, 60.0f );
                homerMultiController->Reset();
            }
        }
    }

    // advance gag timer
    //
    m_gagsElapsedTime += elapsedTime;

    const unsigned int FE_GAG_PREP_TIME = 2000; // in msec
    if( m_gagsElapsedTime > (m_gagsCycleTime - FE_GAG_PREP_TIME) )
    {
        if( m_nextGagIndex == -1 )
        {
            // prepare for next gag
            //
#ifdef PLAY_ONLY_HOMER_GAGS
            m_nextGagIndex = 0;
#else
    #ifdef PLAY_GAGS_SEQUENTIALLY
            m_nextGagIndex = (m_currentGagIndex + 1) % m_gags->GetNumberOfLayers();
    #else
            int random = (rand() / 10) % GAGS_RANDOM_NUMBER_MODULO;
            m_nextGagIndex = random % m_gags->GetNumberOfLayers();

            if( CommandLineOptions::Get( CLO_FE_GAGS_TEST ) )
            {
                rReleasePrintf( "Next FE Gag Index = %d (Random Number = %d)\n", m_nextGagIndex, random );
            }
    #endif
#endif
            if( m_nextGagIndex != 0 )
            {
                GetEventManager()->TriggerEvent( EVENT_FE_GAG_INIT, reinterpret_cast<void*>( FE_GAGS[ m_nextGagIndex ] ) );
            }
            else // multiple homer gags
            {
                // pick a random homer animation
                //
#ifdef PLAY_GAGS_SEQUENTIALLY
                m_nextHomerGagIndex = (m_nextHomerGagIndex + 1) % NUM_HOMER_GAG_ANIMATIONS;
#else
                int random = (rand() / 10) % GAGS_RANDOM_NUMBER_MODULO;
                m_nextHomerGagIndex = random % NUM_HOMER_GAG_ANIMATIONS;

                if( CommandLineOptions::Get( CLO_FE_GAGS_TEST ) )
                {
                    rReleasePrintf( "  Next Homer Gag Index = %d (Random Number = %d)\n", m_nextHomerGagIndex, random );
                }
#endif

                GetEventManager()->TriggerEvent( EVENT_FE_GAG_INIT, reinterpret_cast<void*>( FE_GAGS_FOR_HOMER[ m_nextHomerGagIndex ] ) );
            }
        }
    }

    if( m_gagsElapsedTime > m_gagsCycleTime )
    {
        if( m_gags != NULL )
        {
            Scrooby::Layer* currentGagLayer = NULL;

            // hide previous gag layer, if exists
            //
            if( m_currentGagIndex != -1 )
            {
                currentGagLayer = m_gags->GetLayerByIndex( m_currentGagIndex );
                currentGagLayer->SetVisible( false );
            }

            m_currentGagIndex = m_nextGagIndex;
            m_nextGagIndex = -1;

            // get the pure3d gag
            //
            char objectName[ 8 ];
            sprintf( objectName, "Gag%d", m_currentGagIndex );
            Scrooby::Pure3dObject* p3dGag = m_gags->GetPure3dObject( objectName );

            // reset gag animation
            //
            rAssert( p3dGag );
            tMultiController* multiController =  p3dGag->GetMultiController();
            if( multiController != NULL )
            {
                multiController->Reset();
            }

            // show current gag layer
            //
            currentGagLayer = m_gags->GetLayerByIndex( m_currentGagIndex );
            rAssert( currentGagLayer );
            currentGagLayer->SetVisible( true );

            // start FE gag dialog
            //
            GetEventManager()->TriggerEvent( EVENT_FE_GAG_START );

            if( m_currentGagIndex == 0 )
            {
                // special case for homer gag animation
                //
                if( m_homer != NULL && multiController != NULL )
                {
                    tAnimationFrameController* frameController =
                        (tAnimationFrameController*)multiController->GetTrack( 0 );
                    rAssert( frameController );

                    // get homer gag animation
                    tAnimation* homerAnim = frameController->GetAnimation();
                    rAssert( homerAnim );
                    homerAnim->SetCyclic( false ); // don't cycle when done

                    tMultiController* homerMultiController = m_homer->GetMultiController();
                    if( homerMultiController != NULL )
                    {
                        homerMultiController->SetFrameRange( HOMER_GAG_ANIMATION[ m_nextHomerGagIndex ].startFrame,
                                                             HOMER_GAG_ANIMATION[ m_nextHomerGagIndex ].endFrame );

                        tAnimationFrameController* homerFrameController =
                            (tAnimationFrameController*)homerMultiController->GetTrack( 0 );
                        rAssert( homerFrameController );

                        // save reference to homer idle animation
                        //
                        m_homerIdleAnim = homerFrameController->GetAnimation();
                        rAssert( m_homerIdleAnim != NULL );
                        m_homerIdleAnim->AddRef();

                        // switch to the homer gag animation
                        homerFrameController->SetAnimation( homerAnim, 0.0f, NUM_BLEND_FRAMES );
                    }
                }
            }
        }

        // set new random gag cycle time
        //
        if( CommandLineOptions::Get( CLO_FE_GAGS_TEST ) )
        {
            m_gagsCycleTime = 1000 * MIN_GAGS_CYCLE_TIME;
        }
        else
        {
            m_gagsCycleTime = 1000 * (MIN_GAGS_CYCLE_TIME + rand() % (MAX_GAGS_CYCLE_TIME - MIN_GAGS_CYCLE_TIME + 1));
        }

        // reset gag timer
        //
        m_gagsElapsedTime = 0;
    }
}

//===========================================================================
// CGuiScreenMainMenu::StopHomerIdleAnimation
//===========================================================================
// Description: 
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      N/A.
//
//===========================================================================
void CGuiScreenMainMenu::StopHomerIdleAnimation()
{
/*
    if( m_homer != NULL )
    {
        // reset Homer's snoring animation so that the camera
        // can pan right into his mouth
        //
        tMultiController* multiController = m_homer->GetMultiController();
        if( multiController != NULL )
        {
            tAnimationFrameController* frameController = (tAnimationFrameController*)multiController->GetTrack( 0 );
            rAssert( frameController );

            if( m_homerIdleAnim == NULL )
            {
                m_homerIdleAnim = frameController->GetAnimation();
                rAssert( m_homerIdleAnim );
            }

            m_homerIdleAnim->SetCyclic( false );

            static float NUM_BLEND_FRAMES = 10.0f;
            frameController->SetAnimation( m_homerIdleAnim,
                                           m_homerIdleAnim->GetNumFrames() - NUM_BLEND_FRAMES,
                                           NUM_BLEND_FRAMES );

            m_homerIdleAnim = NULL;
        }
    }
*/
}

//===========================================================================
// CGuiScreenMainMenu::TurnOnGlowItems
//===========================================================================
// Description: 
//
// Constraints:	None.
//
// Parameters:	items - bitmask representing which ones to turn on glowing
//
// Return:      N/A.
//
//===========================================================================
void CGuiScreenMainMenu::TurnOnGlowItems( unsigned int items )
{
#ifdef RAD_DEMO
    if( items > 0 )
    {
        bool isOptionsSelected = ( (items & (1 << MAIN_MENU_OPTIONS)) > 0 );
        m_glowingItems[ MAIN_MENU_PLAY_LEVEL_2 ]->SetVisible( !isOptionsSelected );
        m_glowingItems[ MAIN_MENU_OPTIONS ]->SetVisible( isOptionsSelected );

        return;
    }
#endif

#ifdef RAD_WIN32
    for( int i = 0; i < NUM_MAIN_MENU_SELECTIONS; i++ )
    {
        bool isOn = (items & (1 << i)) > 0;
        int which = i < MAIN_MENU_QUIT_GAME ? i : i - 1;
        if( m_glowingItems[ which ] != NULL && i != MAIN_MENU_QUIT_GAME )
        {
            m_glowingItems[ which ]->SetVisible( isOn );
        }
    }
#else
    for( int i = 0; i < NUM_MAIN_MENU_SELECTIONS; i++ )
    {
        bool isOn = (items & (1 << i)) > 0;
        if( m_glowingItems[ i ] != NULL )
        {
            m_glowingItems[ i ]->SetVisible( isOn );
        }
    }
#endif
}

void
CGuiScreenMainMenu::OnNewGameSelected( RenderEnums::LevelEnum level,
                                       RenderEnums::MissionEnum mission )
{
    bool showNewGameMovie = false;

#ifdef RAD_RELEASE
  #ifndef RAD_DEMO
    showNewGameMovie = !CommandLineOptions::Get( CLO_SKIP_MOVIE );
  #endif
#endif

    if( showNewGameMovie )
    {
        // play new game movie
        //
        rAssert( m_guiManager );
        CGuiScreenPlayMovie* playMovieScreen = static_cast<CGuiScreenPlayMovie*>( m_guiManager->FindWindowByID( GUI_SCREEN_ID_PLAY_MOVIE_NEW_GAME ) );
        rAssert( playMovieScreen );

        playMovieScreen->SetMovieToPlay( MovieNames::MOVIE1, false, true );

        m_pParent->HandleMessage( GUI_MSG_GOTO_SCREEN, GUI_SCREEN_ID_PLAY_MOVIE_NEW_GAME );
    }
    else
    {
        // send message to front-end manager to quit front-end and
        // start single player story mode
        //
        m_pParent->HandleMessage( GUI_MSG_QUIT_FRONTEND, 1 ); // 1 = one player
    }

    this->StartTransitionAnimation( 0, 53 );

    this->StopHomerIdleAnimation();

    if( GetGameDataManager()->IsGameLoaded() )
    {
        // reset all game data
        //
        GetGameDataManager()->ResetGame();

        //reset the rewards manager and relock the rewards
        //
        GetRewardsManager()->ClearRewards();
    }

    GetCharacterSheetManager()->SetCurrentMission( level, mission );

    // restore black clear colour
    //
    GetRenderManager()->mpLayer(RenderEnums::GUI)->pView( 0 )->SetClearColour( tColour( 0, 0, 0 ) );
}

void
CGuiScreenMainMenu::OnResumeGameSelected()
{
    // send message to front-end manager to quit front-end and
    // start single player story mode
    //
    m_pParent->HandleMessage( GUI_MSG_QUIT_FRONTEND, 1 ); // 1 = one player

    this->StartTransitionAnimation( 140, 170 );
}

void
CGuiScreenMainMenu::OnMiniGameSelected()
{
    // send message to front-end manager to quit front-end and
    // start mini-game mode
    //
    m_pParent->HandleMessage( GUI_MSG_QUIT_FRONTEND, 2 ); // 2 = mini-game

    this->StartTransitionAnimation( 880, 913 );
}

#ifdef RAD_WIN32
void
CGuiScreenMainMenu::OnQuitGameSelected()
{
    rAssert( m_guiManager != NULL );
    m_guiManager->DisplayPrompt( PROMPT_CONFIRM_QUIT, this );
}
#endif

#ifdef SRR2_LEVEL_SELECTION
void
CGuiScreenMainMenu::ToggleLevelMenu()
{
    Scrooby::Page* levelPage = m_pScroobyScreen->GetPage( "Level" );
    if( levelPage != NULL )
    {
        Scrooby::Group* levelMenu = levelPage->GetGroup( "Menu" );
        rAssert( levelMenu );

        bool toggle = !levelMenu->IsVisible();

        // display menu on/off
        levelMenu->SetVisible( toggle );

        // enable/disable menu selections
        for( int i = MENU_ITEM_LEVEL; i <= MENU_ITEM_LEVEL; i++ )
        {
            m_pMenu->SetMenuItemEnabled( i, toggle );
        }
    }
}
#endif // SRR2_LEVEL_SELECTION

//===========================================================================
// Public Member Functions (for CGuiScreenIntroTransition)
//===========================================================================

bool CGuiScreenIntroTransition::s_introTransitionPlayed = false;

//===========================================================================
// CGuiScreenIntroTransition::CGuiScreenIntroTransition
//===========================================================================
// Description: Constructor.
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      N/A.
//
//===========================================================================
CGuiScreenIntroTransition::CGuiScreenIntroTransition
(
	Scrooby::Screen* pScreen,
	CGuiEntity* pParent
)
:   CGuiScreen( pScreen, pParent, GUI_SCREEN_ID_INTRO_TRANSITION ),
    m_introState( WAITING_FOR_MULTICONTROLLER ),
    m_homer( NULL ),
    m_tvFrame( NULL ),
    m_gags( NULL )
{
    this->SetFadingEnabled( false );

    // Retrieve drawing elements from 3dFE page
    //
    Scrooby::Page* pPage = m_pScroobyScreen->GetPage( "3dFE" );
    rAssert( pPage );
    m_homer = pPage->GetPure3dObject( "Homer" );

    // Retrieve drawing elements from TVFrame page
    //
    pPage = m_pScroobyScreen->GetPage( "TVFrame" );
    rAssert( pPage );
    m_tvFrame = pPage->GetLayer( "TVFrame" );

    // 3D FE Gags
    //
    m_gags = m_pScroobyScreen->GetPage( "3dFEGags" );
    rAssert( m_gags );

    s_introTransitionPlayed = false;
}


//===========================================================================
// CGuiScreenIntroTransition::~CGuiScreenIntroTransition
//===========================================================================
// Description: Destructor.
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      N/A.
//
//===========================================================================
CGuiScreenIntroTransition::~CGuiScreenIntroTransition()
{
}


//===========================================================================
// CGuiScreenIntroTransition::HandleMessage
//===========================================================================
// Description: 
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      N/A.
//
//===========================================================================
void CGuiScreenIntroTransition::HandleMessage
(
	eGuiMessage message, 
	unsigned int param1,
	unsigned int param2 
)
{
	// Propogate the message up the hierarchy.
	//
	CGuiScreen::HandleMessage( message, param1, param2 );

    if( m_state == GUI_WINDOW_STATE_INTRO &&
        message == GUI_MSG_UPDATE )
    {
        switch( m_introState )
        {
            case WAITING_FOR_MULTICONTROLLER:
            {
                if( s_p3dMultiController != NULL )
                {
                    m_numTransitionsPending--;

                    this->StartTransitionAnimation( 721, 770, false );

                    if( m_screenCover != NULL )
                    {
                        m_screenCover->SetVisible( false );
                    }

                    m_introState = RUNNING_INTRO_ANIMATION;
                }
                else
                {
                    if( m_screenCover != NULL )
                    {
                        m_screenCover->SetAlpha( 1.0f );
                    }
                }

                break;
            }

            default:
            {
                if( m_tvFrame != NULL )
                {
                    rAssert( m_p3dObject );

                    tMultiController* multiController = m_p3dObject->GetMultiController();
                    rAssert( multiController );

                    const float NUM_FADE_IN_FRAMES = 20.0f;
                    float numRemainingFrames = multiController->GetNumFrames() -
                                               multiController->GetFrame();

                    if( numRemainingFrames < NUM_FADE_IN_FRAMES )
                    {
                        float alpha = 1.0f - numRemainingFrames / NUM_FADE_IN_FRAMES;

                        // decrease fade rate for low alpha values
                        alpha *= alpha;

                        if( alpha < 1.0f )
                        {
                            // fade in TV frame
                            //
                            if( m_tvFrame != NULL )
                            {
                                m_tvFrame->SetAlpha( alpha );
                            }

                            // fade in foreground layers
                            //
                            this->SetAlphaForLayers( alpha,
                                                     m_foregroundLayers,
                                                     m_numForegroundLayers );
                        }
                    }
                }

                break;
            }
        }

        // hide duplicate homer
        //
        if( m_gags != NULL )
        {
            Scrooby::Pure3dObject* p3dGag = m_gags->GetPure3dObject( "Gag0" );
            rAssert( p3dGag );
            if( p3dGag->GetMultiController() != NULL )
            {
                p3dGag->SetVisible( false );
            }
        }
    }
}


//===========================================================================
// CGuiScreenIntroTransition::InitIntro
//===========================================================================
// Description: 
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      N/A.
//
//===========================================================================
void CGuiScreenIntroTransition::InitIntro()
{
    // wait for retrieval of pure3d multicontroller
    m_numTransitionsPending++;

    if( m_tvFrame != NULL )
    {
        m_tvFrame->SetAlpha( 0.0f );

        this->SetAlphaForLayers( 0.0f,
                                 m_foregroundLayers,
                                 m_numForegroundLayers );
    }

    CGuiScreenMainMenu* pScreen = static_cast<CGuiScreenMainMenu*>( m_guiManager->FindWindowByID( GUI_SCREEN_ID_MAIN_MENU ) );
    rAssert( pScreen != NULL );
    pScreen->InitMenu();
}


//===========================================================================
// CGuiScreenIntroTransition::InitRunning
//===========================================================================
// Description: 
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      N/A.
//
//===========================================================================
void CGuiScreenIntroTransition::InitRunning()
{
    s_introTransitionPlayed = true;

    if( m_tvFrame != NULL )
    {
        m_tvFrame->SetAlpha( 1.0f );

        this->SetAlphaForLayers( 1.0f,
                                 m_foregroundLayers,
                                 m_numForegroundLayers );
    }

    // goto main menu
    //
    rAssert( m_pParent );
    m_pParent->HandleMessage( GUI_MSG_GOTO_SCREEN,
                              GUI_SCREEN_ID_MAIN_MENU,
                              CLEAR_WINDOW_HISTORY );
}


//===========================================================================
// CGuiScreenIntroTransition::InitOutro
//===========================================================================
// Description: 
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      N/A.
//
//===========================================================================
void CGuiScreenIntroTransition::InitOutro()
{
}