/*---------------------------------------------------------------------------*
  Project:    WPAD demo program
  File:       sync.c

  Copyright (C) 2006 Nintendo.  All rights reserved.

  These coded instructions, statements, and computer programs contain
  proprietary information of Nintendo of America Inc. and/or Nintendo
  Company Ltd., and are protected by Federal copyright law.  They may
  not be disclosed to third parties or copied or duplicated in any form,
  in whole or in part, without the prior written consent of Nintendo.

  $Log: sync.c,v $
  Revision 1.8.2.1  2007/12/11 01:18:54  tojo
  Modified to handle the status code of WPADProbe.

  Revision 1.8  2007/07/11 11:54:22  tojo
  Fixed the message handling.

  Revision 1.7  2007/07/10 12:14:46  tojo
  (none)

  Revision 1.6  2007/04/23 09:02:45  tojo
  (none)

  Revision 1.5  2006/10/23 01:19:08  tojo
  Called WPADSetSyncCallback before initialization complete.

  Revision 1.4  2006/10/02 07:00:21  takano_makoto
  fix PrintIntro messages.

  Revision 1.3  2006/09/19 02:16:19  tojo
  Added fast sync.

  Revision 1.2  2006/09/08 09:44:18  tojo
  (none)

  Revision 1.1  2006/09/06 03:13:43  tojo
  (none)


 *---------------------------------------------------------------------------*/

#define DEMO_USE_MEMLIB = 1
#include <revolution/mem.h>
#include <revolution/wpad.h>
#include <demo.h>
#include <string.h>

#define SCREEN_WIDTH  320
#define SCREEN_HEIGHT 240

/*---------------------------------------------------------------------------*
 * Private function prototypes
 *---------------------------------------------------------------------------*/
void *myAlloc( u32 size  );
u8    myFree ( void *ptr );

/*---------------------------------------------------------------------------*
 * Globals
 *---------------------------------------------------------------------------*/
static const s16 LINE = 8;

static u8 standard = 0;
static u8 simple   = 0;
static s32 stdNum   = 0;
static s32 smpNum   = 0;

/*---------------------------------------------------------------------------*
 * For WPAD testing
 *---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*
 * Name        : myAlloc()
 * Description : 
 * Arguments   : None.
 * Returns     : None.
 *---------------------------------------------------------------------------*/
void *myAlloc( u32 size )
{
    void *ptr;
    
    ptr = MEMAllocFromAllocator(&DemoAllocator2, size);
    ASSERTMSG(ptr, "Memory allocation failed\n");

    return(ptr);
} 

/*---------------------------------------------------------------------------*
 * Name        : myFree()
 * Description : 
 * Arguments   : None.
 * Returns     : None.
 *---------------------------------------------------------------------------*/
u8 myFree( void *ptr )
{
    MEMFreeToAllocator(&DemoAllocator2, ptr);

    return(1);
}


/*---------------------------------------------------------------------------*
 * Name        : RenderConsoleStatus()
 * Description : 
 * Arguments   : None.
 * Returns     : None.
 *---------------------------------------------------------------------------*/
static void RenderConsoleStatus( void )
{
    s16 y = 16;
    s32 chan;
    u8 devAddr[6];
    u32 dev_type;
    u8 sync_type;

    const char *std[] = {"----", "start", "busy", "done"};
    const char *smp[] = {"----", "start", "busy", "stopping", "done"};

    DEMOPrintf( 16, y+=LINE, 0, "WPAD Demo -- Sync");

    y += LINE;

    DEMOPrintf( 16, y+=LINE, 0, "Registered Device Number: %d", WPADGetRegisteredDevNum());
    DEMOPrintf( 16, y+=LINE, 0, "Temporary  Device Number: %d", WPADGetTemporaryDevNum());

    y += LINE;

    for(chan=0; chan<WPAD_MAX_CONTROLLERS; chan++)
    {
        if (WPADProbe(chan, &dev_type) != WPAD_ERR_NO_CONTROLLER)
        {
            WPADGetAddress(chan, devAddr);
            WPADGetSyncType(chan, &sync_type);
            DEMOPrintf( 16, y += LINE, 0, "chan%d: %02x:%02x:%02x:%02x:%02x:%02x [%s]", 
                chan,
                devAddr[0],
                devAddr[1],
                devAddr[2],
                devAddr[3],
                devAddr[4],
                devAddr[5],
                (sync_type == WPAD_SYNC_TYPE_STD) ? "Standard" : "Simple"
            );
        }
        else
        {
            DEMOPrintf( 16, y += LINE, 0, "chan%d: not connected", chan);
        }
    }
    
    DEMOPrintf( 16, y+=LINE*3, 0, "standard: %s [%d device(s)]", std[standard], stdNum);
    DEMOPrintf( 16, y+=LINE,   0, "simple  : %s [%d device(s)]", smp[simple], smpNum);
}

/*---------------------------------------------------------------------------*
 * Name        : initialize()
 * Description : 
 * Arguments   : None.
 * Returns     : None.
 *---------------------------------------------------------------------------*/
static void initialize( void )
{
    const GXColor DARKBLUE = { 0, 0, 64, 255 };

    OSInit();

    DEMOInit( &GXNtsc480IntDf );
    GXSetCopyClear( DARKBLUE, GX_MAX_Z24 );
    GXCopyDisp( DEMOGetCurrentBuffer(), GX_TRUE );
    DEMOInitCaption( DM_FT_XLU, SCREEN_WIDTH, SCREEN_HEIGHT );
    GXSetZMode( GX_ENABLE, GX_ALWAYS, GX_ENABLE );                       // Set pixel processing mode
    GXSetBlendMode( GX_BM_BLEND, GX_BL_ONE, GX_BL_ONE, GX_LO_CLEAR );    // Translucent mode

    DEMOPadInit();

} /* end initialize() */

static void SyncCallback( s32 result, s32 num )
{
    switch (result)
    {
        case WPAD_SYNC_EVT_START:
            if (WPADStartSyncDevice())
            {
                standard = 1;
                simple = 0;
            }
            break;
            
        case WPAD_SYNC_EVT_DONE:
            standard = 3;
            stdNum = num;
            break;
    }
    OSReport("SYNC STD EVT: %d, %d\n", result, num);
}

static void SyncSmpCallback( s32 result, s32 num )
{
    switch (result)
    {
        case WPAD_SYNC_EVT_DONE:
            simple = 4;
            smpNum = num;
            break;
    }

    OSReport("SYNC SMP EVT: %d, %d\n", result, num);
}

/*---------------------------------------------------------------------------*
 * Name        : PrintIntro()
 * Description : 
 * Arguments   : None.
 * Returns     : None.
 *---------------------------------------------------------------------------*/
static void PrintIntro( void )
{
    OSReport("+------------ WPAD Sample Demo Program ---------------+\n");
    OSReport(" MENU:                                               \n");
    OSReport("  A button: Start standard pairing.                   \n");
    OSReport("  B button: Start deleting all controllers.           \n");
    OSReport("  X button: Start simple pairing.                     \n");
    OSReport("  Y button: Stop  simple pairing.                     \n");
    OSReport(" Trigger L: Start fast standard pairing.              \n");
    OSReport(" Trigger R: Start fast simple pairing.                \n");
    OSReport("+-----------------------------------------------------+\n");

}

/*---------------------------------------------------------------------------*
 * Name        : main()
 * Description : 
 * Arguments   : None.
 * Returns     : None.
 *---------------------------------------------------------------------------*/
int main( void )
{
    s32 bb_stat;
    u32 curr = 0;
    u32 prev = 0;

    initialize();
    
    // register allocator for stack before WPADInit().
    WPADRegisterAllocator(myAlloc, myFree);
    
    // Initialize WPAD.
    WPADInit();

    WPADSetSyncDeviceCallback(SyncCallback);
    WPADSetSimpleSyncCallback(SyncSmpCallback);

    // wait that BT stack is enabled
    do {
        bb_stat = WPADGetStatus();
    } while (bb_stat != WPAD_STATE_SETUP);

    PrintIntro();

    // Main loop
    while( 1 )
    {
        DEMOPadRead();

        curr = DEMOPadGetButton(0);
        
        if (PADButtonDown(prev, curr) & PAD_BUTTON_A)
        {
            if (WPADStartSyncDevice())
            {
                standard = 1;
                simple = 0;
            }
        }
        if (PADButtonDown(prev, curr) & PAD_BUTTON_B)
        {
            WPADStartClearDevice();
        }
        if (PADButtonDown(prev, curr) & PAD_BUTTON_X)
        {
            if (WPADStartSimpleSync())
            {
                standard = 0;
                simple = 1;
            }
        }
        if (PADButtonDown(prev, curr) & PAD_BUTTON_Y)
        {
            if (simple == 1 || simple == 2)
            {
                simple = 3;
                WPADStopSimpleSync();
            }
        }
        if (PADButtonDown(prev, curr) & PAD_TRIGGER_L)
        {
            if (WPADStartFastSyncDevice())
            {
                standard = 1;
                simple = 0;
            }
        }
        if (PADButtonDown(prev, curr) & PAD_TRIGGER_R)
        {
            if (WPADStartFastSimpleSync())
            {
                standard = 0;
                simple = 1;
            }
        }
        prev = curr;

        DEMOBeforeRender();
        RenderConsoleStatus();
        DEMODoneRender();
        
    }

    return 0;
}