//===========================================================================
// Copyright (C) 2000 Radical Entertainment Ltd.  All rights reserved.
//
// Component:   CardGallery
//
// Description: Implementation of the CardGallery class.
//
// Authors:     Tony Chu
//
// Revisions		Date			Author	    Revision
//                  2002/08/06      TChu        Created for SRR2
//
//===========================================================================

//===========================================================================
// Includes
//===========================================================================
#include <cards/cardgallery.h>
#include <cards/cardsdb.h>
#include <cards/card.h>

#include <data/gamedatamanager.h>
#include <memory/srrmemory.h>

#include <raddebugwatch.hpp>

// Static pointer to instance of singleton.
CardGallery* CardGallery::spInstance = NULL;

#ifdef DEBUGWATCH
    static const char* WATCHER_NAMESPACE = "Card Gallery";
    static unsigned int s_wAddCollectedCard;
    static void AddCardToGallery()
    {
        GetCardGallery()->AddCollectedCardByID( s_wAddCollectedCard );
    }

    static void AddAllCardsToGallery()
    {
        GetCardGallery()->AddAllCollectedCards();
    }

    static void RemoveAllCardsFromGallery()
    {
        GetCardGallery()->RemoveAllCollectedCards();
    }
#endif

//===========================================================================
// Local Constants
//===========================================================================

const unsigned int NUM_BITS_PER_BYTE = 8;

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

CardList::CardList()
:   m_numCards( 0 )
{
    memset( m_cards, 0, sizeof( m_cards ) );
}

void
CardList::Add( Card* card )
{
    rAssert( card != NULL );
    rAssert( m_numCards < static_cast<int>( NUM_CARDS_PER_LEVEL ) );

    unsigned int slot = card->GetLevelID() - 1;
    rAssert( slot < NUM_CARDS_PER_LEVEL );

    if( m_cards[ slot ] == NULL )
    {
        m_cards[ slot ] = card;
        m_numCards++;
    }
    else
    {
        rAssertMsg( 0, "WARNING: *** Card already collected!" );
    }
}

bool
CardList::Remove( unsigned int cardID )
{
    bool cardFound = false;

    // find card with cardID
    //
    for( int i = 0; i < m_numCards; i++ )
    {
        rAssert( m_cards[ i ] );

        if( m_cards[ i ]->GetID() == cardID )
        {
            // found it! now remove it
            m_cards[ i ] = NULL;
            m_numCards--;

            cardFound = true;
            break;
        }
    }

    return cardFound;
}

void
CardList::Empty()
{
    memset( m_cards, 0, sizeof( m_cards ) );
    m_numCards = 0;
}

//==============================================================================
// CardGallery::CreateInstance
//==============================================================================
//
// Description: - Creates the Card Gallery.
//
// Parameters:	None.
//
// Return:      Pointer to the CardGallery.
//
// Constraints: This is a singleton so only one instance is allowed.
//
//==============================================================================
CardGallery* CardGallery::CreateInstance()
{
MEMTRACK_PUSH_GROUP( "CardGallery" );
    #ifdef RAD_GAMECUBE
        HeapMgr()->PushHeap( GMA_GC_VMM );
    #else
        HeapMgr()->PushHeap( GMA_PERSISTENT );
    #endif
        spInstance = new(GMA_PERSISTENT) CardGallery;
    rAssert( spInstance != NULL );

    #ifdef RAD_GAMECUBE
        HeapMgr()->PopHeap( GMA_GC_VMM );
    #else
        HeapMgr()->PopHeap( GMA_PERSISTENT );
    #endif
 MEMTRACK_POP_GROUP( "CardGallery" );
    return spInstance;
}

//==============================================================================
// CardGallery::DestroyInstance
//==============================================================================
//
// Description: Destroy the GUI system.
//
// Parameters:	None.
//
// Return:      None.
//
//==============================================================================
void CardGallery::DestroyInstance()
{
    rAssert( spInstance != NULL );

    delete spInstance;
    spInstance = NULL;
}

//==============================================================================
// CardGallery::GetInstance
//==============================================================================
//
// Description: - Access point for the CardGallery singleton.  
//              - Creates the CardGallery if needed.
//
// Parameters:	None.
//
// Return:      Pointer to the CardGallery.
//
// Constraints: This is a singleton so only one instance is allowed.
//
//==============================================================================
CardGallery* CardGallery::GetInstance()
{
    rAssert( spInstance != NULL );

    return spInstance;
}

//===========================================================================
// CardGallery::CardGallery
//===========================================================================
// Description: 
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      
//
//===========================================================================
CardGallery::CardGallery()
:   m_cardsDB( NULL ),
    m_numCollectedCards( 0 )
{
#ifdef RAD_GAMECUBE
    HeapMgr()->PushHeap( GMA_GC_VMM );
#else
    HeapMgr()->PushHeap( GMA_PERSISTENT );
#endif

    m_cardsDB = new CardsDB();
    rAssert( m_cardsDB );

#ifdef RAD_GAMECUBE
    HeapMgr()->PopHeap( GMA_GC_VMM );
#else
    HeapMgr()->PopHeap( GMA_PERSISTENT );
#endif
}

//===========================================================================
// CardGallery::~CardGallery
//===========================================================================
// Description: 
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      
//
//===========================================================================
CardGallery::~CardGallery()
{
    GetCheatInputSystem()->UnregisterCallback( this );

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

//===========================================================================
// CardGallery::Init
//===========================================================================
// Description: 
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      
//
//===========================================================================
void
CardGallery::Init()
{
    // load cards into database
    //
    rAssert( m_cardsDB );
    m_cardsDB->LoadCards();

    // determine number of bytes needed for loading/saving
    //
    unsigned int numDataBytes = m_cardsDB->GetNumCards() / NUM_BITS_PER_BYTE;
    if( m_cardsDB->GetNumCards() % NUM_BITS_PER_BYTE > 0 )
    {
        numDataBytes++; // round up number of bytes
    }

    // register collected cards data for loading/saving
    //
    GetGameDataManager()->RegisterGameData( this, numDataBytes, "Card Gallery" );

    // register callback for "Collect All Cards" cheat
    //
    GetCheatInputSystem()->RegisterCallback( this );

#ifdef DEBUGWATCH
    radDbgWatchAddUnsignedInt( &s_wAddCollectedCard,
                               "Add Collectible Card",
                               WATCHER_NAMESPACE,
                               (RADDEBUGWATCH_CALLBACK)AddCardToGallery,
                               NULL,
                               0,
                               MAX_NUM_CARDS - 1 );

    radDbgWatchAddFunction( "Add All Collectible Cards",
                            (RADDEBUGWATCH_CALLBACK)AddAllCardsToGallery,
                            NULL,
                            WATCHER_NAMESPACE );

    radDbgWatchAddFunction( "Remove All Collectible Cards",
                            (RADDEBUGWATCH_CALLBACK)RemoveAllCardsFromGallery,
                            NULL,
                            WATCHER_NAMESPACE );
#endif
}

//===========================================================================
// CardGallery::AddCollectedCardByID
//===========================================================================
// Description: 
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      
//
//===========================================================================
Card*
CardGallery::AddCollectedCardByID( unsigned int cardID )
{
    rAssert( m_cardsDB );

    // get card by ID from DB, and add it to collected cards
    //
    Card* collectedCard = m_cardsDB->GetCardByID( cardID );
    if( collectedCard != NULL )
    {
        this->AddCollectedCard( collectedCard );
    }

    return collectedCard;
}

//===========================================================================
// CardGallery::AddCollectedCardByName
//===========================================================================
// Description: 
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      
//
//===========================================================================
Card*
CardGallery::AddCollectedCardByName( tUID cardName )
{
    rAssert( m_cardsDB );

    // get card by name from DB, and add it to collected cards
    //
    Card* collectedCard = m_cardsDB->GetCardByName( cardName );
    if( collectedCard != NULL )
    {
        this->AddCollectedCard( collectedCard );
    }
    else
    {
        rAssertMsg( false, "ERROR: *** Card not found!" );
    }

    return collectedCard;
}

//===========================================================================
// CardGallery::AddAllCollectedCards
//===========================================================================
// Description: 
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      
//
//===========================================================================
void
CardGallery::AddAllCollectedCards()
{
    for( unsigned int i = 0; i < MAX_NUM_CARDS; i++ )
    {
        rAssert( m_cardsDB != NULL );
        Card* card = m_cardsDB->GetCardByID( i );
        if( card != NULL )
        {
            this->AddCollectedCard( card );
        }
    }
}

//===========================================================================
// CardGallery::RemoveAllCollectedCards
//===========================================================================
// Description: 
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      
//
//===========================================================================
void
CardGallery::RemoveAllCollectedCards()
{
    for( unsigned int i = 0; i < NUM_LEVELS; i++ )
    {
        m_collectedCards[ i ].Empty();
    }

    m_numCollectedCards = 0;
}

//===========================================================================
// CardGallery::GetCollectedCards
//===========================================================================
// Description: 
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      
//
//===========================================================================
const CardList*
CardGallery::GetCollectedCards( unsigned int level ) const
{
    rAssert( level < NUM_LEVELS );
    return( &(m_collectedCards[ level ]) );
}

//=============================================================================
// CardGallery::IsCardCollected
//=============================================================================
// Description: Comment
//
// Parameters:  ( tUID cardName )
//
// Return:      bool 
//
//=============================================================================
bool CardGallery::IsCardCollected( tUID cardName ) const
{
    bool cardCollected = false;

    rAssert( m_cardsDB );
    Card* card = m_cardsDB->GetCardByName( cardName );
    if( card != NULL )
    {
        int level = card->GetLevel() - 1;
        int levelID = card->GetLevelID() - 1;
        if( m_collectedCards[ level ].m_cards[ levelID ] != NULL )
        {
            cardCollected = true;
        }
    }

    return cardCollected;
}

//=============================================================================
// CardGallery::GetNumCardDecksCompleted
//=============================================================================
// Description: Get number of card decks completed.  Collecting all cards in
//              a given level constitutes a complete deck.
//
// Parameters:  none
//
// Return:      number of card decks completed
//
//=============================================================================
int CardGallery::GetNumCardDecksCompleted() const
{
    int numDecksCompleted = 0;

    for( unsigned int i = 0; i < NUM_LEVELS; i++ )
    {
        if( this->IsCardDeckComplete( i ) )
        {
            numDecksCompleted++;
        }
    }

    return numDecksCompleted;
}

//=============================================================================
// CardGallery::IsCardDeckComplete
//=============================================================================
// Description: Query whether or not a card deck is complete for a given level.
//
// Parameters:  level index
//
// Return:      true/false
//
//=============================================================================
bool CardGallery::IsCardDeckComplete( unsigned int level ) const
{
    rAssert( level < NUM_LEVELS );

    return( m_collectedCards[ level ].m_numCards == static_cast<int>( NUM_CARDS_PER_LEVEL ) );
}

//===========================================================================
// CardGallery::LoadData
//===========================================================================
// Description: 
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      
//
//===========================================================================
void
CardGallery::LoadData( const GameDataByte* dataBuffer,
                       unsigned int numBytes )
{
    // remove all collected cards first
    //
    this->RemoveAllCollectedCards();

    // add new set of collected cards from loaded data
    //
    for( unsigned int i = 0; i < numBytes * NUM_BITS_PER_BYTE; i++ )
    {
        unsigned int dataBufferIndex = i / NUM_BITS_PER_BYTE;
        if( (dataBuffer[ dataBufferIndex ] & (1 << i % NUM_BITS_PER_BYTE)) > 0 )
        {
            this->AddCollectedCardByID( i );
        }
    }
}

//===========================================================================
// CardGallery::SaveData
//===========================================================================
// Description: 
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      
//
//===========================================================================
void
CardGallery::SaveData( GameDataByte* dataBuffer,
                       unsigned int numBytes )
{
    if( CommandLineOptions::Get( CLO_MEMCARD_CHEAT ) )
    {
        // turn on all bits, and save
        //
        memset( dataBuffer, ~0, numBytes );
    }
    else
    {
        // clear data buffer first
        //
        for( unsigned int byteIndex = 0; byteIndex < numBytes; byteIndex++ )
        {
            dataBuffer[ byteIndex ] = 0;
        }

        // save collected cards using bit-masking algorithm
        //
        for( unsigned int i = 0; i < NUM_LEVELS; i++ )
        {
            for( unsigned int j = 0; j < NUM_CARDS_PER_LEVEL; j++ )
            {
                if( m_collectedCards[ i ].m_cards[ j ] != NULL )
                {
                    unsigned int cardID = m_collectedCards[ i ].m_cards[ j ]->GetID();

                    unsigned int dataBufferIndex = cardID / NUM_BITS_PER_BYTE;
                    dataBuffer[ dataBufferIndex ] |= (1 << (cardID % NUM_BITS_PER_BYTE));
                }
            }
        }
    }
}

//===========================================================================
// CardGallery::OnCheatEntered
//===========================================================================
// Description: 
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      
//
//===========================================================================
void
CardGallery::OnCheatEntered( eCheatID cheatID, bool isEnabled )
{
    if( cheatID == CHEAT_ID_UNLOCK_CARDS )
    {
        // remove all cards from gallery first
        //
        this->RemoveAllCollectedCards();

        // now add all collectible cards to gallery
        //
        this->AddAllCollectedCards();
    }
}

//===========================================================================
// Private Member Functions
//===========================================================================

//===========================================================================
// CardGallery::AddCollectedCard
//===========================================================================
// Description: 
//
// Constraints:	None.
//
// Parameters:	None.
//
// Return:      
//
//===========================================================================
void
CardGallery::AddCollectedCard( Card* newCard )
{
    rAssert( newCard != NULL );
    unsigned int level = newCard->GetLevel() - 1;
    rAssert( level < NUM_LEVELS );
    m_collectedCards[ level ].Add( newCard );

    rDebugPrintf( "Card Gallery: Collected Card %d-%d\n",
                    newCard->GetLevel(), newCard->GetLevelID() );

    m_numCollectedCards++;
}