/*---------------------------------------------------------------------------*
  Project:  WiiConnect24 API demos
  File:     FLViewerUpdate.c

  Copyright 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: FLViewerUpdate.c,v $
  Revision 1.3  2007/01/24 06:25:42  torigoe_nobutaka
  Added processing for when the Home Button is pressed.

  Revision 1.2  2006/10/26 10:42:56  hirose_kazuki
  Modification to accept user ID of the console itself. (due to library changes)

  Revision 1.1  2006/09/27 08:56:17  torigoe_nobutaka
  Moved from nwc24demo/src.

  Revision 1.1  2006/09/13 10:07:05  torigoe_nobutaka
  Initial check in.

  $NoKeywords: $
 *---------------------------------------------------------------------------*/
#include <revolution.h>
#include <revolution/nwc24.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#include "FLViewer.h"
#include "FLViewerUpdate.h"

/*---------------------------------------------------------------------------*
   Static constants
 *---------------------------------------------------------------------------*/
static const char*  STR_SAMPLE_WII_ID       =   "4016576553504409";

/*---------------------------------------------------------------------------*
   Local functions
 *---------------------------------------------------------------------------*/
static u32          GetSelectedNameIdx  ( void );
static void         UpdateSelectFriend  ( const KPADStatus* input );
static void         UpdateSelectEditItem( const KPADStatus* input );
static void         UpdateEditType      ( const KPADStatus* input );
static void         UpdateEditStatus    ( const KPADStatus* input );
static void         UpdateEditFdId      ( const KPADStatus* input );
static void         UpdateEditName      ( const KPADStatus* input );
static void         UpdateEditWiiId     ( const KPADStatus* input );
static void         UpdateEditMailAddr  ( const KPADStatus* input );
static void         UpdateDeleteFriend  ( const KPADStatus* input );
static void         InputAlpha          ( char* dst, const KPADStatus* input, BOOL bCaps, BOOL bStart );
static void         InputNumber         ( char* dst, const KPADStatus* input, BOOL bStart );
static void         InputHexNumber      ( char* dst, const KPADStatus* input, BOOL bStart );
static void         InputSymbol         ( char* dst, const KPADStatus* input, BOOL bStart );
static void         InputMailSymbol     ( char* dst, const KPADStatus* input, BOOL bStart );
static char         GetInputChar        ( u8* idxChar, const KPADStatus* input, const char* charList, u8 listLen, BOOL bStart );

/*---------------------------------------------------------------------------*
   Scene update processing besides rendering
 *---------------------------------------------------------------------------*/
void Update( const KPADStatus* input )
{
    /* (1) button */
    if ( input->trig & KPAD_BUTTON_1 )
    {
        g_bHelp = !g_bHelp;
    }
    
    /* (Home) button */
    if ( input->trig & KPAD_BUTTON_HOME )
    {
        OSReturnToMenu();
    }
    
    switch ( g_state )
    {
        case STATE_SELECT_FRIEND:    UpdateSelectFriend( input );   break;
        case STATE_SELECT_EDIT_ITEM: UpdateSelectEditItem( input ); break;
        case STATE_EDIT_TYPE:        UpdateEditType( input );       break;
        case STATE_EDIT_STATUS:      UpdateEditStatus( input );     break;
        case STATE_EDIT_FD_ID:       UpdateEditFdId( input );       break;
        case STATE_EDIT_NAME:        UpdateEditName( input );       break;
        case STATE_EDIT_WII_ID:      UpdateEditWiiId( input );      break;
        case STATE_EDIT_MAIL_ADDR:   UpdateEditMailAddr( input );   break;
        case STATE_DELETE_FRIEND:    UpdateDeleteFriend( input );   break;
    }
    return;
}

/*---------------------------------------------------------------------------*/
static u32 GetSelectedNameIdx( void )
{
    return (u32)((g_idxNameBufStart + g_idxSelectedFriend - g_idxTopOfFriendList) % LIST_BOX_ROWS);
}

/*---------------------------------------------------------------------------*
   Selection of friend
 *---------------------------------------------------------------------------*/
static void UpdateSelectFriend( const KPADStatus* input )
{
    NWC24Err    err;
    
    /* (Up) button */
    if ( (input->trig & KPAD_BUTTON_UP) || (g_longHold & KPAD_BUTTON_UP) )
    {
        /* Selection of friend */
        if ( 0 < g_idxSelectedFriend )
        {
            if ( g_idxSelectedFriend == g_idxTopOfFriendList )
            {
                --g_idxTopOfFriendList;
                g_idxNameBufStart = (g_idxNameBufStart + LIST_BOX_ROWS - 1) % LIST_BOX_ROWS;
                if ( TRUE == NWC24IsFriendInfoThere( g_idxTopOfFriendList ) )
                {
                    err = NWC24ReadFriendInfo( g_tempInfo, g_idxTopOfFriendList );
                    CheckError( "NWC24ReadFriendInfo()", err );
                    
                    ConvNameUtf16ToSjis( g_nameBuf[g_idxNameBufStart], g_tempInfo->attr.name );
                }
                else
                {
                    (void)sprintf( g_nameBuf[g_idxNameBufStart], "%s", STR_NOT_REGISTERED );
                }
            }
            --g_idxSelectedFriend;
        }
    }
    
    /* (Down) button */
    if ( (input->trig & KPAD_BUTTON_DOWN) || (g_longHold & KPAD_BUTTON_DOWN) )
    {
        /* Selection of friend */
        if ( g_idxSelectedFriend < g_numFriendInfos - 1 )
        {
            u32     idxBottomOfFriendList   = g_idxTopOfFriendList + LIST_BOX_ROWS - 1;
            
            if ( g_idxSelectedFriend == idxBottomOfFriendList )
            {
                ++g_idxTopOfFriendList;
                ++idxBottomOfFriendList;
                if ( TRUE == NWC24IsFriendInfoThere( idxBottomOfFriendList ) )
                {
                    err = NWC24ReadFriendInfo( g_tempInfo, idxBottomOfFriendList );
                    CheckError( "NWC24ReadFriendInfo()", err );
                    
                    ConvNameUtf16ToSjis( g_nameBuf[g_idxNameBufStart], g_tempInfo->attr.name );
                }
                else
                {
                    (void)sprintf( g_nameBuf[g_idxNameBufStart], "%s", STR_NOT_REGISTERED );
                }
                g_idxNameBufStart = (g_idxNameBufStart + 1) % LIST_BOX_ROWS;
            }
            ++g_idxSelectedFriend;
        }
    }
    
    /* (A) button */
    if ( input->trig & KPAD_BUTTON_A )
    {
        /* Determination of friend */
        g_state = STATE_SELECT_EDIT_ITEM;
        if ( TRUE == NWC24IsFriendInfoThere( g_idxSelectedFriend ) )
        {
            NWC24Err    err;
            u8          i;
            
            err = NWC24ReadFriendInfo( g_tempInfo, g_idxSelectedFriend );
            CheckError( "NWC24ReadFriendInfo()", err );
            
            InitEditFriendInfo( g_tempInfo );
            for ( i = 0; i < NUM_EDIT_ITEMS; ++i )
            {
                if ( UPDATABLE_ITEM_TABLE[i] )
                {
                    g_selectedEditItem = i;
                    break;
                }
            }
        }
        else
        {
            InitEditFriendInfo( NULL );
            g_selectedEditItem = EDIT_ITEM_TYPE;
        }
    }
    
    /* (B) button */
    if ( input->trig & KPAD_BUTTON_B )
    {
        /* Delete friend information */
        if ( TRUE == NWC24IsFriendInfoThere( g_idxSelectedFriend ) )
        {
            g_state = STATE_DELETE_FRIEND;
        }
    }
    return;
}

/*---------------------------------------------------------------------------*
   Select friend information item to edit
 *---------------------------------------------------------------------------*/
static void UpdateSelectEditItem( const KPADStatus* input )
{
    BOOL    bRegistered = (BOOL)(TRUE == NWC24IsFriendInfoThere( g_idxSelectedFriend ));
    
    /* (Up) button */
    if ( (input->trig & KPAD_BUTTON_UP) || (g_longHold & KPAD_BUTTON_UP) )
    {
        /* Selection of edit item */
        if ( bRegistered )
        {
            s32     i;
            for ( i = g_selectedEditItem - 1; 0 <= i; --i )
            {
                if ( UPDATABLE_ITEM_TABLE[i] )
                {
                    g_selectedEditItem = (u8)i;
                    break;
                }
            }
        }
        else if ( 0 < g_selectedEditItem )
        {
            --g_selectedEditItem;
        }
    }
    
    /* (Down) button */
    if ( (input->trig & KPAD_BUTTON_DOWN) || (g_longHold & KPAD_BUTTON_DOWN) )
    {
        /* Selection of edit item */
        if ( bRegistered )
        {
            s32     i;
            for ( i = g_selectedEditItem + 1; i < (s32)NUM_EDIT_ITEMS; ++i )
            {
                if ( UPDATABLE_ITEM_TABLE[i] )
                {
                    g_selectedEditItem = (u8)i;
                    break;
                }
            }
        }
        else if ( g_selectedEditItem < NUM_EDIT_ITEMS - 1 )
        {
            ++g_selectedEditItem;
        }
    }
    
    /* (A) button */
    if ( input->trig & KPAD_BUTTON_A )
    {
        /* Determination of edit item */
        (void)memcpy( &g_backupFriendInfo, &g_editFriendInfo, sizeof(EditFriendInfo) );
        switch ( g_selectedEditItem )
        {
            case EDIT_ITEM_TYPE:     g_state = STATE_EDIT_TYPE;     break;
            case EDIT_ITEM_STATUS:   g_state = STATE_EDIT_STATUS;   break;
            case EDIT_ITEM_FD_ID:    g_state = STATE_EDIT_FD_ID;    break;
            case EDIT_ITEM_NAME:     g_state = STATE_EDIT_NAME;     break;
            case EDIT_ITEM_ADDRESS:
            {
                if ( g_editFriendInfo.type == NWC24_FI_TYPE_WII )
                {
                    g_state = STATE_EDIT_WII_ID;
                }
                else if ( g_editFriendInfo.type == NWC24_FI_TYPE_PUBLIC )
                {
                    g_state = STATE_EDIT_MAIL_ADDR;
                }
                break;
            }
        }
    }
    
    /* (B) button */
    if ( input->trig & KPAD_BUTTON_B )
    {
        /* Cancel change and return to friend selection */
        g_state = STATE_SELECT_FRIEND;
    }
    
    /* (Plus) button */
    if ( input->trig & KPAD_BUTTON_PLUS )
    {
        /* Register friend information and return to friend selection */
        while ( TRUE )
        {
            if ( g_editFriendInfo.type == NWC24_FI_TYPE_WII )
            {
                NWC24UserId     userId  = ConvStringTo16Digits( g_editFriendInfo.wiiId );
                NWC24Err        err;
                
                err = NWC24CheckUserId( userId );
                /* Valid ID or your own ID */
                if ( err != NWC24_OK && err != NWC24_ERR_ID_GENERATED )
                {
                    /* Don't register if the Wii number is invalid */
                    g_selectedEditItem = EDIT_ITEM_ADDRESS;
                    (void)memset( g_editFriendInfo.wiiId, 0, WII_ID_BUF_SIZE );
                    break;
                }
            }
            
            g_state = STATE_SELECT_FRIEND;
            RegisterFriendInfo( g_idxSelectedFriend );
            (void)sprintf( g_nameBuf[ GetSelectedNameIdx() ], "%s", g_editFriendInfo.name );
            break;
        }
    }
    return;
}

/*---------------------------------------------------------------------------*
   Edit address type
 *---------------------------------------------------------------------------*/
static void UpdateEditType( const KPADStatus* input )
{
    /* (Up) or (Down) button */
    if ( input->trig & (KPAD_BUTTON_UP | KPAD_BUTTON_DOWN) )
    {
        /* Selection of address type*/
        g_editFriendInfo.type = (u32)((g_editFriendInfo.type == NWC24_FI_TYPE_WII)
                                      ? NWC24_FI_TYPE_PUBLIC : NWC24_FI_TYPE_WII);
    }
    
    /* (A) button */
    if ( input->trig & KPAD_BUTTON_A )
    {
        /* Change address type and return to edit item selection. */
        g_state = STATE_SELECT_EDIT_ITEM;
        (void)memcpy( &g_backupFriendInfo, &g_editFriendInfo, sizeof(EditFriendInfo) );
    }
    
    /* (B) button */
    if ( input->trig & KPAD_BUTTON_B )
    {
        /* Cancel change and return to edit item selection */
        g_state = STATE_SELECT_EDIT_ITEM;
        (void)memcpy( &g_editFriendInfo, &g_backupFriendInfo, sizeof(EditFriendInfo) );
    }
    return;
}

/*---------------------------------------------------------------------------*
   Edit communication capable/incapable information
 *---------------------------------------------------------------------------*/
static void UpdateEditStatus( const KPADStatus* input )
{
    /* (Up) or (Down) button */
    if ( input->trig & (KPAD_BUTTON_UP | KPAD_BUTTON_DOWN) )
    {
        /* Selection of communication capable/incapable */
        g_editFriendInfo.status = (u32)((g_editFriendInfo.status == NWC24_FI_STAT_PENDING)
                                        ? NWC24_FI_STAT_ESTABLISHED : NWC24_FI_STAT_PENDING);
        /* This is forcibly changed to Pending when registering to friend list */
    }
    
    /* (A) button */
    if ( input->trig & KPAD_BUTTON_A )
    {
        /* Change communication capable/incapable information and return to edit item selection */
        g_state = STATE_SELECT_EDIT_ITEM;
        (void)memcpy( &g_backupFriendInfo, &g_editFriendInfo, sizeof(EditFriendInfo) );
    }
    
    /* (B) button */
    if ( input->trig & KPAD_BUTTON_B )
    {
        /* Cancel change and return to edit item selection */
        g_state = STATE_SELECT_EDIT_ITEM;
        (void)memcpy( &g_editFriendInfo, &g_backupFriendInfo, sizeof(EditFriendInfo) );
    }
    return;
}

/*---------------------------------------------------------------------------*
   Editing FDID
 *---------------------------------------------------------------------------*/
static void UpdateEditFdId( const KPADStatus* input )
{
    static BOOL     bStart      = TRUE;
    u8              idxEdit;
    char*           pChar       = NULL;
    
    if ( bStart )
    {
        idxEdit = 0;
        (void)memset( g_editFriendInfo.fdId, 0, FD_ID_BUF_SIZE );
    }
    else
    {
        idxEdit = (u8)(strlen( g_editFriendInfo.fdId ) - 1);
    }
    
    pChar = &g_editFriendInfo.fdId[idxEdit];
    
    /* Input character selection*/
    InputNumber( pChar, input, bStart );
    bStart = FALSE;
    
    /* (A) button */
    if ( input->trig & KPAD_BUTTON_A )
    {
        /* Character input*/
        if ( FD_ID_BUF_SIZE - 2 <= idxEdit )
        {
            /* If the character count has reached the maximum value, change FDID and return to the edit item selection */
            g_state = STATE_SELECT_EDIT_ITEM;
            bStart = TRUE;
            g_editFriendInfo.fdId[FD_ID_BUF_SIZE - 1] = '\0';
            (void)memcpy( &g_backupFriendInfo, &g_editFriendInfo, sizeof(EditFriendInfo) );
        }
        else
        {
            *(pChar + 1) = *pChar;
            *(pChar + 2) = '\0';
        }
    }
    
    /* (B) button */
    if ( (input->trig & KPAD_BUTTON_B) || (g_longHold & KPAD_BUTTON_B) )
    {
        /* Delete one character*/
        if ( idxEdit < 1 )
        {
            /* Cancel change and return to edit item selection if all characters are deleted */
            g_state = STATE_SELECT_EDIT_ITEM;
            bStart = TRUE;
            (void)memcpy( &g_editFriendInfo, &g_backupFriendInfo, sizeof(EditFriendInfo) );
        }
        else
        {
            *pChar = '\0';
        }
    }
    
    return;
}

/*---------------------------------------------------------------------------*
   Edit nickname
 *---------------------------------------------------------------------------*/
static void UpdateEditName( const KPADStatus* input )
{
    static const u8     NUM_INPUT_MODES         =   4;
    static const u8     INPUT_LOWER             =   0;
    static const u8     INPUT_UPPER             =   1;
    static const u8     INPUT_NUMBER            =   2;
    static const u8     INPUT_SYMBOL            =   3;
    static BOOL         bStart                  =   TRUE;
    static BOOL         bHexMode                =   FALSE;
    static u8           inputMode;
    u8                  idxEdit;
    u8                  idxHex;
    char*               pChar                   =   NULL;
    
    if ( bStart )
    {
        inputMode = INPUT_LOWER;
        bHexMode = FALSE;
        (void)memset( g_hexBuf, 0, HEX_BUF_SIZE );
        
        if ( NAME_LEN <= SjisStrLen( g_editFriendInfo.name ) )
        {
            u8      i;
            
            idxEdit = 0;
            for ( i = 0; i < NAME_LEN - 1; ++i )
            {
                idxEdit += SjisIsMultibyte( &g_editFriendInfo.name[idxEdit] ) ? 2 : 1;
            }
            
            g_editFriendInfo.name[idxEdit + 1] = '\0';
        }
        else
        {
            idxEdit = (u8)strlen( g_editFriendInfo.name );
        }
    }
    else
    {
        idxEdit = (u8)(strlen( g_editFriendInfo.name ) - 1);
    }
    
    pChar = &g_editFriendInfo.name[idxEdit];
    
    /* Input character selection*/
    if ( bHexMode )
    {
        u32     hexLen      = strlen( g_hexBuf );
        BOOL    bHexStart   = (hexLen == 0);
        
        idxHex = (u8)(bHexStart ? hexLen : hexLen - 1);
        InputHexNumber( &g_hexBuf[idxHex], input, bHexStart );
    }
    else
    {
        switch ( inputMode )
        {
            case INPUT_LOWER:  InputAlpha( pChar, input, FALSE, bStart ); break;
            case INPUT_UPPER:  InputAlpha( pChar, input, TRUE, bStart );  break;
            case INPUT_NUMBER: InputNumber( pChar, input, bStart );       break;
            case INPUT_SYMBOL: InputSymbol( pChar, input, bStart );       break;
        }
    }
    
    bStart = FALSE;
    
    /* (Right) button */
    if ( (input->trig & KPAD_BUTTON_RIGHT) || (g_longHold & KPAD_BUTTON_RIGHT) )
    {
        /* Change character type */
        inputMode = (u8)((inputMode + 1) % NUM_INPUT_MODES);
    }
    
    /* (Left) button */
    if ( (input->trig & KPAD_BUTTON_LEFT) || (g_longHold & KPAD_BUTTON_LEFT) )
    {
        /* Change character type */
        inputMode = (u8)((inputMode + NUM_INPUT_MODES - 1) % NUM_INPUT_MODES);
    }
    
    /* (A) button */
    if ( input->trig & KPAD_BUTTON_A )
    {
        /* Character input*/
        char    temp    = *pChar;
        
        if ( bHexMode )
        {
            if ( HEX_BUF_SIZE - 2 <= idxHex )
            {
                s32     code;
                
                g_hexBuf[HEX_BUF_SIZE - 1] = '\0';
                code = strtol( g_hexBuf, NULL, 16 );
                *pChar = (char)(code / 0x100);
                
                if ( SjisIsMultibyte( pChar ) )
                {
                    *(pChar + 1) = (char)(code % 0x100);
                    *(pChar + 2) = '\0';
                }
                else
                {
                    if ( *pChar == 0x00 )
                    {
                        *pChar = (char)(code % 0x100);
                    }
                    
                    if ( !isprint( *pChar ) )
                    {
                        *pChar = ' ';
                    }
                    
                    *(pChar + 1) = '\0';
                }
                
                bHexMode = FALSE;
                (void)memset( g_hexBuf, 0, HEX_BUF_SIZE );
            }
            else
            {
                g_hexBuf[idxHex + 1] = g_hexBuf[idxHex];
            }
        }
        
        if ( !bHexMode ) 
        {
            if ( NAME_LEN <= SjisStrLen( g_editFriendInfo.name ) )
            {
                /* If the character count has reached the maximum value, change nickname and return to the edit item selection */
                g_state = STATE_SELECT_EDIT_ITEM;
                bStart = TRUE;
                *(pChar + 1) = '\0';
                (void)memcpy( &g_backupFriendInfo, &g_editFriendInfo, sizeof(EditFriendInfo) );
            }
            else
            {
                if ( SjisIsMultibyte( pChar ) )
                {
                    *(pChar + 2) = temp;
                    *(pChar + 3) = '\0';
                }
                else
                {
                    *(pChar + 1) = temp;
                    *(pChar + 2) = '\0';
                }
            }
        }
    }
    
    /* (B) button */
    if ( (input->trig & KPAD_BUTTON_B) || (g_longHold & KPAD_BUTTON_B) )
    {
        /* Delete one character*/
        if ( bHexMode )
        {
            g_hexBuf[idxHex] = '\0';
        }
        else if ( idxEdit < 1 )
        {
            /* Cancel change and return to edit item selection if all characters are deleted */
            g_state = STATE_SELECT_EDIT_ITEM;
            bStart = TRUE;
            (void)memcpy( &g_editFriendInfo, &g_backupFriendInfo, sizeof(EditFriendInfo) );
        }
        else
        {
            *pChar = '\0';
            if ( 1 < idxEdit )
            {
                char*   curr    = g_editFriendInfo.name;
                char*   next    = g_editFriendInfo.name;
                while ( next != pChar )
                {
                    curr = next;
                    next = (char*)(curr + (SjisIsMultibyte( curr ) ? 2 : 1));
                }
                
                if ( next - curr == 2 )
                {
                    *(pChar - 1) = '\0';
                }
            }
        }
    }
    
    /* (Plus) */
    if ( input->trig & KPAD_BUTTON_PLUS )
    {
        /* Change the nickname and return to edit item selection.*/
        g_state = STATE_SELECT_EDIT_ITEM;
        *pChar = '\0';
        bStart = TRUE;
        (void)memcpy( &g_backupFriendInfo, &g_editFriendInfo, sizeof(EditFriendInfo) );
    }
    
    /* (Minus) */
    if ( input->trig & KPAD_BUTTON_MINUS )
    {
        /* Hexadecimal character code input mode switch */
        bHexMode = !bHexMode;
        (void)memset( g_hexBuf, 0, HEX_BUF_SIZE );
    }
    return;
}

/*---------------------------------------------------------------------------*
   Edit Wii number
 *---------------------------------------------------------------------------*/
static void UpdateEditWiiId( const KPADStatus* input )
{
    static BOOL     bStart      = TRUE;
    u8              idxEdit;
    char*           pChar       = NULL;
    
    if ( bStart )
    {
        idxEdit = 0;
        (void)memset( g_editFriendInfo.wiiId, 0, WII_ID_BUF_SIZE );
    }
    else
    {
        idxEdit = (u8)(strlen( g_editFriendInfo.wiiId ) - 1);
    }
    
    pChar = &g_editFriendInfo.wiiId[idxEdit];
    
    /* Input character selection*/
    InputNumber( pChar, input, bStart );
    bStart = FALSE;
    
    /* (A) button */
    if ( input->trig & KPAD_BUTTON_A )
    {
        /* Character input*/
        if ( WII_ID_BUF_SIZE - 2 <= idxEdit )
        {
            /* If the character count has reached the maximum value, change Wii number and return to the edit item selection */
            g_state = STATE_SELECT_EDIT_ITEM;
            bStart = TRUE;
            g_editFriendInfo.wiiId[WII_ID_BUF_SIZE - 1] = '\0';
            (void)memcpy( &g_backupFriendInfo, &g_editFriendInfo, sizeof(EditFriendInfo) );
        }
        else
        {
            *(pChar + 1) = *pChar;
            *(pChar + 2) = '\0';
        }
    }
    
    /* (B) button */
    if ( (input->trig & KPAD_BUTTON_B) || (g_longHold & KPAD_BUTTON_B) )
    {
        /* Delete one character*/
        if ( idxEdit < 1 )
        {
            /* Cancel change and return to edit item selection if all characters are deleted */
            g_state = STATE_SELECT_EDIT_ITEM;
            bStart = TRUE;
            (void)memcpy( &g_editFriendInfo, &g_backupFriendInfo, sizeof(EditFriendInfo) );
        }
        else
        {
            *pChar = '\0';
        }
    }
    
    /* (Plus) button */
    if ( input->trig & KPAD_BUTTON_PLUS )
    {
        /* Input the sample Wii number */
        g_state = STATE_SELECT_EDIT_ITEM;
        bStart = TRUE;
        (void)sprintf( g_editFriendInfo.wiiId, "%s", STR_SAMPLE_WII_ID );
        (void)memcpy( &g_backupFriendInfo, &g_editFriendInfo, sizeof(EditFriendInfo) );
    }
    return;
}

/*---------------------------------------------------------------------------*
   Edit e-mail address
 *---------------------------------------------------------------------------*/
static void UpdateEditMailAddr( const KPADStatus* input )
{
    static const u8     NUM_INPUT_MODES = 4;
    static const u8     INPUT_LOWER     = 0;
    static const u8     INPUT_UPPER     = 1;
    static const u8     INPUT_NUMBER    = 2;
    static const u8     INPUT_SYMBOL    = 3;
    static BOOL         bStart          = TRUE;
    static u8           inputMode;
    u8                  idxEdit;
    char*               pChar           = NULL;
    
    if ( bStart )
    {
        inputMode = INPUT_LOWER;
        idxEdit = (u8)strlen( g_editFriendInfo.mailAddr );
        if ( MAIL_ADDR_BUF_SIZE - 1 <= idxEdit )
        {
            idxEdit = MAIL_ADDR_BUF_SIZE - 2;
        }
    }
    else
    {
        idxEdit = (u8)(strlen( g_editFriendInfo.mailAddr ) - 1);
    }

    pChar = &g_editFriendInfo.mailAddr[idxEdit];
    
    /* Input character selection*/
    switch ( inputMode )
    {
        case INPUT_LOWER:  InputAlpha( pChar, input, FALSE, bStart ); break;
        case INPUT_UPPER:  InputAlpha( pChar, input, TRUE, bStart );  break;
        case INPUT_NUMBER: InputNumber( pChar, input, bStart );       break;
        case INPUT_SYMBOL: InputMailSymbol( pChar, input, bStart );   break;
    }
    
    bStart = FALSE;
    
    /* (Right) button */
    if ( (input->trig & KPAD_BUTTON_RIGHT) || (g_longHold & KPAD_BUTTON_RIGHT) )
    {
        /* Change character type */
        inputMode = (u8)((inputMode + 1) % NUM_INPUT_MODES);
    }
    
    /* (Left) button */
    if ( (input->trig & KPAD_BUTTON_LEFT) || (g_longHold & KPAD_BUTTON_LEFT) )
    {
        /* Change character type */
        inputMode = (u8)((inputMode + NUM_INPUT_MODES - 1) % NUM_INPUT_MODES);
    }
    
    /* (A) button */
    if ( input->trig & KPAD_BUTTON_A )
    {
        /* Character input*/
        if ( MAIL_ADDR_BUF_SIZE - 2 <= idxEdit )
        {
            /* If the character count has reached the maximum value, change e-mail address and return to the edit item selection */
            g_state = STATE_SELECT_EDIT_ITEM;
            bStart = TRUE;
            g_editFriendInfo.mailAddr[MAIL_ADDR_BUF_SIZE - 1] = '\0';
            (void)memcpy( &g_backupFriendInfo, &g_editFriendInfo, sizeof(EditFriendInfo) );
        }
        else
        {
            *(pChar + 1) = *pChar;
            *(pChar + 2) = '\0';
        }
    }
    
    /* (B) button */
    if ( (input->trig & KPAD_BUTTON_B) || (g_longHold & KPAD_BUTTON_B) )
    {
        /* Delete one character*/
        if ( idxEdit < 1 )
        {
            /* Cancel change and return to edit item selection if all characters are deleted */
            g_state = STATE_SELECT_EDIT_ITEM;
            bStart = TRUE;
            (void)memcpy( &g_editFriendInfo, &g_backupFriendInfo, sizeof(EditFriendInfo) );
        }
        else
        {
            *pChar = '\0';
        }
    }
    
    /* (Plus) */
    if ( input->trig & KPAD_BUTTON_PLUS )
    {
        /* Change e-mail address and return to edit item selection. */
        g_state = STATE_SELECT_EDIT_ITEM;
        *pChar = '\0';
        bStart = TRUE;
        (void)memcpy( &g_backupFriendInfo, &g_editFriendInfo, sizeof(EditFriendInfo) );
    }
    return;
}

/*---------------------------------------------------------------------------*
   Delete friend information
 *---------------------------------------------------------------------------*/
static void UpdateDeleteFriend( const KPADStatus* input )
{
    /* (A) button */
    if ( input->trig & KPAD_BUTTON_A )
    {
        /* Execute deletion of friend information */
        NWC24Err    err;
        
        g_state = STATE_SELECT_FRIEND;
        err = NWC24DeleteFriendInfo( g_idxSelectedFriend );
        CheckError( "NWC24DeleteFriendInfo()", err );
        (void)sprintf( g_nameBuf[ GetSelectedNameIdx() ], "%s", STR_NOT_REGISTERED );
    }
    
    /* (B) button */
    if ( input->trig & KPAD_BUTTON_B )
    {
        /* Return to friend selection without deleting friend information */
        g_state = STATE_SELECT_FRIEND;
    }
    return;
}

/*---------------------------------------------------------------------------*/
static void InputAlpha( char* dst, const KPADStatus* input, BOOL bCaps, BOOL bStart )
{
    static const char*  ALPHA_LIST  = "abcdefghijklmnopqrstuvwxyz";
    static u8           idxAlphas   = 0;
    u8                  numAlphas   = (u8)strlen( ALPHA_LIST );
    
    *dst = GetInputChar( &idxAlphas, input, ALPHA_LIST, numAlphas, bStart );
    
    if ( bCaps )
    {
        *dst = (char)(*dst - 'a' + 'A');
    }
    return;
}

/*---------------------------------------------------------------------------*/
static void InputNumber( char* dst, const KPADStatus* input, BOOL bStart )
{
    static const char*  NUMBER_LIST = "0123456789";
    static u8           idxNumber   = 0;
    u8                  numNumbers  = (u8)strlen( NUMBER_LIST );
    
    *dst = GetInputChar( &idxNumber, input, NUMBER_LIST, numNumbers, bStart );
    return;
}

/*---------------------------------------------------------------------------*/
static void InputHexNumber( char* dst, const KPADStatus* input, BOOL bStart )
{
    static const char*  NUMBER_LIST = "0123456789ABCDEF";
    static u8           idxNumber   = 0;
    u8                  numNumbers  = (u8)strlen( NUMBER_LIST );
    
    *dst = GetInputChar( &idxNumber, input, NUMBER_LIST, numNumbers, bStart );
    return;
}

/*---------------------------------------------------------------------------*/
static void InputSymbol( char* dst, const KPADStatus* input, BOOL bStart )
{
    static const char*  SYMBOL_LIST = "!\"#$%&\'()*+,-./:;<=>\?@[\\]^_`{|}~ ";
    static u8           idxSymbol   = 0;
    u8                  numSymbols  = (u8)strlen( SYMBOL_LIST );
    
    *dst = GetInputChar( &idxSymbol, input, SYMBOL_LIST, numSymbols, bStart );
    return;
}

/*---------------------------------------------------------------------------*/
static void InputMailSymbol( char* dst, const KPADStatus* input, BOOL bStart )
{
    static const char*  SYMBOL_LIST = "@.-_";
    static u8           idxSymbol   = 0;
    u8                  numSymbols  = (u8)strlen( SYMBOL_LIST );
    
    *dst = GetInputChar( &idxSymbol, input, SYMBOL_LIST, numSymbols, bStart );
    return;
}

/*---------------------------------------------------------------------------*/
static char GetInputChar
(
    u8*                 idxChar,
    const KPADStatus*   input,
    const char*         charList,
    u8                  listLen,
    BOOL                bStart
)
{
    if ( bStart )
    {
        *idxChar = 0;
    }
    
    /* (Up) button */
    if ( (input->trig & KPAD_BUTTON_UP) || (g_longHold & KPAD_BUTTON_UP) )
    {
        *idxChar = (u8)((*idxChar == listLen - 1) ? 0 : *idxChar + 1);
    }
        
    /* (Down) button */
    if ( (input->trig & KPAD_BUTTON_DOWN) || (g_longHold & KPAD_BUTTON_DOWN) )
    {
        *idxChar = (u8)((*idxChar == 0) ? listLen - 1 : *idxChar - 1);
    }
    
    return charList[*idxChar];
}

/*======== End of FLViewerUpdate.c ========*/