/*!
    @file sysUserInfoAccessor.cpp
    @brief ユーザ情報アクセサ
 */
#ifndef MAKE_AREACHECK

//#include "sys.h"

#include "sysUserInfoAccessor.h"
//#include "sysKeyboardManager.h"
//#include "sysSystem.h"
#include "sysFile.h"
#include "sysInput.h"

//#include "sceneOtherThread.h"
//#include "sceneDataTable.h"

//#include "ImageDb.h"

#include <nn/cfg/CTR/cfg_ApiInit.h>
#include <nn/pl/CTR/pl_SharedDataTitleId.h>
#include <nn/news_System.h>
#include <nn/news/CTR/system/news_BossUtil.h>
#include <nn/hid/CTR/hid_SoundVolume.h>
#include <nn/boss/boss_UploadAction.h>
#include <nn/boss/private/boss_PrivilegedLib.h>
#include <nn/ndm.h>
#include <nn/ssl/ssl_Const.h>

#ifndef NW_RELEASE
//#include "sceneDebugLayout.h"
#endif

#define   MOUNT_SHARED_AREA
#define   MOUNT_SHARED_EULA

#include "syokaikidou.h"

namespace sys
{

//==========================================================================
//
//==========================================================================
const nn::ProgramId     cSharedAreaId[] =
{
    nn::pl::CTR::SHAREDDATA_TITLEID_COUNTRY_REGION,
};

#ifdef  MOUNT_SHARED_AREA

static const char*  cSharedCountryFile[] =
{
    "area:/JP/country_LZ.bin",
    "area:/US/country_LZ.bin",
    "area:/EU/country_LZ.bin",
    "area:/EU/country_LZ.bin",
    "area:/CN/country_LZ.bin",
    "area:/KR/country_LZ.bin",
    "area:/TW/country_LZ.bin",
};

static const char*  cSharedAreaFile[] =
{
    "area:/JP/%d_LZ.bin",
    "area:/US/%d_LZ.bin",
    "area:/EU/%d_LZ.bin",
    "area:/EU/%d_LZ.bin",
    "area:/CN/%d_LZ.bin",
    "area:/KR/%d_LZ.bin",
    "area:/TW/%d_LZ.bin",
};

#else
// 共有データにするとき不要
static const char*  cCountryFile[] =
{
    "rom:/country/JP/country_LZ.bin",
    "rom:/country/US/country_LZ.bin",
    "rom:/country/EU/country_LZ.bin",
    "rom:/country/EU/country_LZ.bin",
    "rom:/country/CN/country_LZ.bin",
    "rom:/country/KR/country_LZ.bin",
    "rom:/country/TW/country_LZ.bin",
};

static const char*  cAreaFile[] =
{
    "rom:/country/JP/%d_LZ.bin",
    "rom:/country/US/%d_LZ.bin",
    "rom:/country/EU/%d_LZ.bin",
    "rom:/country/EU/%d_LZ.bin",
    "rom:/country/CN/%d_LZ.bin",
    "rom:/country/KR/%d_LZ.bin",
    "rom:/country/TW/%d_LZ.bin",
};
#endif

#ifdef  MOUNT_SHARED_EULA
const nn::ProgramId     cSharedEulaId[] =
{
    nn::pl::CTR::SHAREDDATA_TITLEID_EULA_JP,
    nn::pl::CTR::SHAREDDATA_TITLEID_EULA_US,
    nn::pl::CTR::SHAREDDATA_TITLEID_EULA_EU,
    nn::pl::CTR::SHAREDDATA_TITLEID_EULA_EU,
    nn::pl::CTR::SHAREDDATA_TITLEID_EULA_CN,
    nn::pl::CTR::SHAREDDATA_TITLEID_EULA_KR,
    nn::pl::CTR::SHAREDDATA_TITLEID_EULA_TW,
};
#else
static const char*  cEulaCountry[] =
{
    "rom:/eula/JP/country.bin",
    "rom:/eula/US/country.bin",
    "rom:/eula/EU/country.bin",
    "rom:/eula/EU/country.bin",
    "rom:/eula/CN/country.bin",
    "rom:/eula/KR/country.bin",
    "rom:/eula/TW/country.bin",
};
#endif


//----------------------------------------------------------------
// TWLでユーザ名、コメントとして入力可能な文字コードリスト
const u16 cTwlUserInfoFontCodeTable[] =
{
    0x0020,0x0021,0x0022,0x0023,0x0024,0x0025,0x0026,0x0027,
    0x0028,0x0029,0x002A,0x002B,0x002C,0x002D,0x002E,0x002F,
    0x0030,0x0031,0x0032,0x0033,0x0034,0x0035,0x0036,0x0037,
    0x0038,0x0039,0x003A,0x003B,0x003C,0x003D,0x003E,0x003F,
    0x0040,0x0041,0x0042,0x0043,0x0044,0x0045,0x0046,0x0047,
    0x0048,0x0049,0x004A,0x004B,0x004C,0x004D,0x004E,0x004F,
    0x0050,0x0051,0x0052,0x0053,0x0054,0x0055,0x0056,0x0057,
    0x0058,0x0059,0x005A,0x005B,0x005C,0x005D,0x005E,0x005F,
    0x0060,0x0061,0x0062,0x0063,0x0064,0x0065,0x0066,0x0067,
    0x0068,0x0069,0x006A,0x006B,0x006C,0x006D,0x006E,0x006F,
    0x0070,0x0071,0x0072,0x0073,0x0074,0x0075,0x0076,0x0077,
    0x0078,0x0079,0x007A,0x007B,0x007D,0x007E,0x00A1,0x00A2,
    0x00A3,0x00A9,0x00AE,0x00B0,0x00B1,0x00BF,0x00C0,0x00C1,
    0x00C2,0x00C4,0x00C7,0x00C8,0x00C9,0x00CA,0x00CB,0x00CC,
    0x00CD,0x00CE,0x00CF,0x00D1,0x00D2,0x00D3,0x00D4,0x00D6,
    0x00D7,0x00D9,0x00DA,0x00DB,0x00DC,0x00DF,0x00E0,0x00E1,
    0x00E2,0x00E4,0x00E7,0x00E8,0x00E9,0x00EA,0x00EB,0x00EC,
    0x00ED,0x00EE,0x00EF,0x00F1,0x00F2,0x00F3,0x00F4,0x00F6,
    0x00F7,0x00F9,0x00FA,0x00FB,0x00FC,0x0152,0x0153,0x02C6,
    0x02DC,0x201C,0x201D,0x2022,0x2026,0x2033,0x203B,0x20AC,
    0x2122,0x2190,0x2191,0x2192,0x2193,0x221E,0x2234,0x25A0,
    0x25A1,0x25B2,0x25B3,0x25BC,0x25BD,0x25C6,0x25C7,0x25CB,
    0x25CE,0x25CF,0x2605,0x2606,0x266A,0x266D,0x3000,0x3001,
    0x3002,0x300C,0x300D,0x3012,0x3041,0x3042,0x3043,0x3044,
    0x3045,0x3046,0x3047,0x3048,0x3049,0x304A,0x304B,0x304C,
    0x304D,0x304E,0x304F,0x3050,0x3051,0x3052,0x3053,0x3054,
    0x3055,0x3056,0x3057,0x3058,0x3059,0x305A,0x305B,0x305C,
    0x305D,0x305E,0x305F,0x3060,0x3061,0x3062,0x3063,0x3064,
    0x3065,0x3066,0x3067,0x3068,0x3069,0x306A,0x306B,0x306C,
    0x306D,0x306E,0x306F,0x3070,0x3071,0x3072,0x3073,0x3074,
    0x3075,0x3076,0x3077,0x3078,0x3079,0x307A,0x307B,0x307C,
    0x307D,0x307E,0x307F,0x3080,0x3081,0x3082,0x3083,0x3084,
    0x3085,0x3086,0x3087,0x3088,0x3089,0x308A,0x308B,0x308C,
    0x308D,0x308E,0x308F,0x3092,0x3093,0x30A1,0x30A2,0x30A3,
    0x30A4,0x30A5,0x30A6,0x30A7,0x30A8,0x30A9,0x30AA,0x30AB,
    0x30AC,0x30AD,0x30AE,0x30AF,0x30B0,0x30B1,0x30B2,0x30B3,
    0x30B4,0x30B5,0x30B6,0x30B7,0x30B8,0x30B9,0x30BA,0x30BB,
    0x30BC,0x30BD,0x30BE,0x30BF,0x30C0,0x30C1,0x30C2,0x30C3,
    0x30C4,0x30C5,0x30C6,0x30C7,0x30C8,0x30C9,0x30CA,0x30CB,
    0x30CC,0x30CD,0x30CE,0x30CF,0x30D0,0x30D1,0x30D2,0x30D3,
    0x30D4,0x30D5,0x30D6,0x30D7,0x30D8,0x30D9,0x30DA,0x30DB,
    0x30DC,0x30DD,0x30DE,0x30DF,0x30E0,0x30E1,0x30E2,0x30E3,
    0x30E4,0x30E5,0x30E6,0x30E7,0x30E8,0x30E9,0x30EA,0x30EB,
    0x30EC,0x30ED,0x30EE,0x30EF,0x30F2,0x30F3,0x30F4,0x30F5,
    0x30F6,0x30FC,0xE000,0xE001,0xE002,0xE003,0xE004,0xE005,
    0xE006,0xE007,0xE008,0xE009,0xE00A,0xE00B,0xE00C,0xE00D,
    0xE00E,0xE00F,0xE010,0xE011,0xE012,0xE013,0xE015,0xE016,
    0xE017,0xE018,0xE019,0xE01A,0xE01B,0xE01C,0xE028,0xFF01,
    0xFF0F,0xFF1F,0xFF3C,0xFF3E,0xFF5B,0xFF5C,0xFF5D,0xFF5E
};  //計392文字

//----------------------------------------------------------------
// BOSS へ情報を送信する際のタスクID
static const char* cSendBossInfoTaskId = "sendcfg";
static const char* cSendBossMmenTaskId = "sendmgn";
static const char* cSendPhuTaskId = "phu";
static const char* cSendTiuTaskId = "tiu";
static const char* cSendSpluTaskId = "splu";
static const char* cSendBossPnoteTaskId = "URUP";

//*********************************************************************************
//                  変数
//*********************************************************************************
FirstInfo   UserInfoAccessor::msFirst;  // 初回起動用フラグ

UserInfo    UserInfoAccessor::msUserInfo;       // 更新中のデータ
UserInfo    UserInfoAccessor::msBackupUserInfo; // リセット用のバックアップデータ

TwlInfo     UserInfoAccessor::msTwlInfo;
TwlInfo     UserInfoAccessor::msBackupTwlInfo;

TwlInfo2    UserInfoAccessor::msTwlInfo2;
TwlInfo2    UserInfoAccessor::msBackupTwlInfo2;

WorkInfo    UserInfoAccessor::msWorkInfo;
WorkInfo    UserInfoAccessor::msBackupWorkInfo;

nn::cfg::CTR::ParentalControlInfo   UserInfoAccessor::msParentInfo;
nn::cfg::CTR::ParentalControlInfo   UserInfoAccessor::msBackupParentInfo;

nn::cfg::CTR::detail::CoppacsCfgData    UserInfoAccessor::msCoppaInfo;
nn::cfg::CTR::detail::CoppacsCfgData    UserInfoAccessor::msBackupCoppaInfo;

nn::cfg::CTR::detail::FirstLaunchInfoCfgData    UserInfoAccessor::msFirstInfo;

NetInfo     UserInfoAccessor::msNetInfo;
NetInfo     UserInfoAccessor::msBackupNetInfo;

int     UserInfoAccessor::msAccNum = -1;    // 接続先
int     UserInfoAccessor::msTmpNum;  // 設定先

BossSendInfo    UserInfoAccessor::msBossSendInfo;

u32     UserInfoAccessor::msDirty = 0;

u16     UserInfoAccessor::msCountryNum = 1;

u8*     UserInfoAccessor::mpSharedAreaBuf = NULL;

bool    UserInfoAccessor::msIsNetSave;
bool    UserInfoAccessor::msIsCoppa = false;

// スライダーバーで使用する要素
wchar_t UserInfoAccessor::msSlideStr[UserInfoAccessor::eFactNum][UserInfoAccessor::eStrSize];

const wchar_t* UserInfoAccessor::mspSlideFact[UserInfoAccessor::eFactNum] =
{
    msSlideStr[0],  msSlideStr[1],  msSlideStr[2],  msSlideStr[3],  msSlideStr[4],
    msSlideStr[5],  msSlideStr[6],  msSlideStr[7],  msSlideStr[8],  msSlideStr[9],
    msSlideStr[10], msSlideStr[11], msSlideStr[12], msSlideStr[13], msSlideStr[14],
    msSlideStr[15], msSlideStr[16], msSlideStr[17], msSlideStr[18], msSlideStr[19],
    msSlideStr[20], msSlideStr[21], msSlideStr[22], msSlideStr[23], msSlideStr[24],
    msSlideStr[25], msSlideStr[26], msSlideStr[27], msSlideStr[28], msSlideStr[29],
    msSlideStr[30], msSlideStr[31], msSlideStr[32], msSlideStr[33], msSlideStr[34],
    msSlideStr[35], msSlideStr[36], msSlideStr[37], msSlideStr[38], msSlideStr[39],
    msSlideStr[40], msSlideStr[41], msSlideStr[42], msSlideStr[43], msSlideStr[44],
    msSlideStr[45], msSlideStr[46], msSlideStr[47], msSlideStr[48], msSlideStr[49],
    msSlideStr[50], msSlideStr[51], msSlideStr[52], msSlideStr[53], msSlideStr[54],
    msSlideStr[55], msSlideStr[56], msSlideStr[57], msSlideStr[58], msSlideStr[59],
    msSlideStr[60], msSlideStr[61], msSlideStr[62], msSlideStr[63], msSlideStr[64],
    msSlideStr[65], msSlideStr[66], msSlideStr[67], msSlideStr[68], msSlideStr[69],
    msSlideStr[70], msSlideStr[71], msSlideStr[72], msSlideStr[73], msSlideStr[74],
    msSlideStr[75], msSlideStr[76], msSlideStr[77], msSlideStr[78], msSlideStr[79],
    msSlideStr[80], msSlideStr[81], msSlideStr[82], msSlideStr[83], msSlideStr[84],
    msSlideStr[85], msSlideStr[86], msSlideStr[87], msSlideStr[88], msSlideStr[89],
    msSlideStr[90], msSlideStr[91], msSlideStr[92], msSlideStr[93], msSlideStr[94],
    msSlideStr[95], msSlideStr[96], msSlideStr[97], msSlideStr[98], msSlideStr[99],
};


//*********************************************************************************
//                  初期化
//*********************************************************************************
//==========================================================================
//
//==========================================================================
void UserInfoAccessor::init( int flg )
{
#if 0
int     event = eUserInfo_Save1;

// 各Infoのクリア
    memset( &msUserInfo, 0, sizeof( msUserInfo ) );
    memset( &msTwlInfo, 0, sizeof( msTwlInfo ) );
    memset( &msTwlInfo2, 0, sizeof( msTwlInfo2 ) );
    memset( &msParentInfo, 0, sizeof( msParentInfo ) );
    memset( &msCoppaInfo, 0, sizeof( msCoppaInfo ) );
    memset( &msNetInfo, 0, sizeof( msNetInfo ) );
    memset( &msWorkInfo, 0, sizeof( msWorkInfo ) );
    memset( &msFirst, 0, sizeof( msFirst ) );

    msDirty = eNoneInfo;
    msIsNetSave = true;

    if( flg == 0 )
    {
        // リージョン
        {
            System::set_region_( nn::cfg::CTR::GetRegion() );
            System::set_language_( nn::cfg::CTR::GetLanguage() );
        }

        // 初回起動フラグのload
        data_user_info_( eKindFirst, 0 );
    }

    check_first_set_();

    if( msFirstInfo.mmen == 0 ) // 初回起動のとき
    {
        // 初回起動用パラメータ
        setFirstParam();

        event = eUserInfo_Save2;
    }
#ifndef NW_RELEASE
    else
    {
        // （デバッグ機能）初回起動をしないでMSETに入ったときのため
        {
            if( wcslen( msUserInfo.usr_name.userName.userName ) == 0 )
            {
                swprintf( msUserInfo.usr_name.userName.userName, 11, L"USER_NAME" );
            }

            if( msUserInfo.usr_birthday.month == 0 )
            {
                msUserInfo.usr_birthday.month = 1;
                msUserInfo.usr_birthday.day = 1;
            }

            if( msUserInfo.usr_address.regionName[0][0] == L'\0' )
            {
                swprintf( msUserInfo.usr_address.regionName[0], 10, L"-" );
            }
        }
    }

    //フォントテーブルが昇順で並んでいることを確認する
    NN_ASSERT(check_order_twl_user_info_font_table_());
#endif

    set_country_info_();

    msDirty = eAllInfo;

    // 初回起動のときは通信系プロセスが起動してないので、その部分を書き込まない
    if( msFirstInfo.mmen == 0 ) msDirty &= ~eNetInfo;

    eventProc( event );
#endif
}


//==========================================================================
//          破棄
//==========================================================================
void UserInfoAccessor::destroy()
{
    delete mpSharedAreaBuf;
}


//==========================================================================
//          共有データの読み込み
//          flg : 0 国データ、1 地域データ
//==========================================================================
u8* UserInfoAccessor::readCountryData( int flg )
{
#if 0
u8*     p_data = NULL;
u8*     mount_buf = NULL;
u32     size;

#ifdef  MOUNT_SHARED_AREA
    mount_buf = sys::File::mountShare( "area:", cSharedAreaId[0], 0, 200, 10 );

    if( mount_buf != NULL )
    {
        NN_LOG( "area data mount\n" );
    }

    if( flg == 0 )
    {
        p_data = sys::File::readLZ( cSharedCountryFile[System::getRegion()], &size );
    }
    else
    {
    char    file[40] = "";

        UT_SPRINTF( file, cSharedAreaFile[System::getRegion()], msWorkInfo.country_id );
        p_data = sys::File::readLZ( file, &size );

        NN_LOG( "file %s\n", file );
    }

    nn::fs::Unmount( "area:" );
    delete []mount_buf;
#else
    if( flg == 0 )
    {
        p_data = sys::File::readLZ( cCountryFile[System::getRegion()], &size );
    }
    else
    {
    char    file[40] = "";

        UT_SPRINTF( file, cAreaFile[System::getRegion()], msWorkInfo.country_id );
        p_data = sys::File::readLZ( file, &size );

        NN_LOG( "file %s\n", file );
    }

#endif
    return p_data;
#endif
}


//==========================================================================
//          初回起動チェック
//==========================================================================
void UserInfoAccessor::check_first_set_()
{
#if 0
#ifdef MAKE_ACCTEST
// 接続検証
    {
        // ユーザー情報をNANDから読み込み
        for( int i = eKindUserName; i <= eKindDsEula; i++ )
        {
            data_user_info_( i, 0 );
        }

        // ネット設定
        {
            nn::ac::InitializeInternal();
            nn::ac::LoadNetworkSetting( 0, msNetInfo.setting[0] );
            nn::ac::LoadNetworkSetting( 1, msNetInfo.setting[1] );
            nn::ac::LoadNetworkSetting( 2, msNetInfo.setting[2] );
            nn::ac::FinalizeInternal();

#ifndef NW_RELEASE
            print_net_save_();  // ネットワーク設定のNAND内容をデバッグ表示
#endif
        }

        setFirstAll( true );

        msBackupUserInfo = msUserInfo;
        msBackupTwlInfo = msTwlInfo;
        msBackupTwlInfo2 = msTwlInfo2;
        msBackupParentInfo = msParentInfo;
        msBackupCoppaInfo = msCoppaInfo;
        msBackupNetInfo = msNetInfo;
        msBackupWorkInfo = msWorkInfo;
    }
#else
// MSET
    if( msFirstInfo.mmen == 0 )     // 初回起動のとき
    {
        ProcessManager::rejectPowerBtn( true );
        ProcessManager::rejectSleep( true );

        setFirstAll( false );

        if( System::isSafeMode() )
        {
            msIsNetSave = false;
        }

        // TWLの初期化
        {
            scene::OtherFnc::ClearNorSetting(); // 通信プロセス起動前にNORをクリアする

            data_user_info_( eKindDsData, 0 );
        }

        // ネット設定初期化はDaemon類が起動してないので後回しにします

        // ImageDbの初期化処理
        {
        imgdb::Result   result = imgdb::SetupTwlNand( System::getSdkAllocator() );

            if( result == imgdb::ResultSuccess )
            {
                // 初期化成功
                NN_LOG( "ImageDb Initialize Success\n" );
            }
            else
            {
                // ここに来た場合は致命的なエラー
                // NANDなどが壊れていたりするとこの結果になるかもしれません
                // 詳細は未定
//              NN_PANIC( "Error! Result=%d\n", result );
                NN_WARNING( false, "Error! Result = %d\n", result);
            }
        }

        NN_LOG( "first boot( 0 )\n" );
    }
    else    // 初回起動が終わっているとき
    {
        // ユーザー情報をNANDから読み込み
        for( int i = eKindUserName; i <= eKindDsEula; i++ )
        {
            if( i != eKindCoppa )
            {
                data_user_info_( i, 0 );
            }
        }

        // ネット設定
        {
            nn::ac::InitializeInternal();
            nn::ac::LoadNetworkSetting( 0, msNetInfo.setting[0] );
            nn::ac::LoadNetworkSetting( 1, msNetInfo.setting[1] );
            nn::ac::LoadNetworkSetting( 2, msNetInfo.setting[2] );
            nn::ac::FinalizeInternal();
        }

        setFirstAll( true );

        msBackupUserInfo = msUserInfo;
        msBackupTwlInfo = msTwlInfo;
        msBackupTwlInfo2 = msTwlInfo2;
        msBackupParentInfo = msParentInfo;
        msBackupNetInfo = msNetInfo;
        msBackupWorkInfo = msWorkInfo;
    }

// COPPACSは必ずロードする
    {
        // COPPACSは必要な国か？
        setCoppacs();

        // Coppaは必ずloadする
        data_user_info_( eKindCoppa, 0 );

        msBackupCoppaInfo = msCoppaInfo;
    }
#endif
#endif
}


//==========================================================================
//          初回起動時の国情報の読み込み
//==========================================================================
void UserInfoAccessor::set_country_info_()
{
#if 0
u8*     mount_buf = NULL;

    {
    u8*     p_data = readCountryData( 0 );
    int*    p_data1 = reinterpret_cast<int*>( p_data );
    int     cid = msUserInfo.usr_address.id>>24;

        msCountryNum = *p_data1++;

        if( msCountryNum == 1 ) // 国が1つのときは、最初に国情報をセーブしておく
        {
        CountryInfo*   p_country = reinterpret_cast<CountryInfo*>( p_data1 );
        int     id = (p_country->id)>>24;

            msWorkInfo.country_id = id;
            msWorkInfo.area_num = p_country->numRegion;

            if( id != cid )
            {
                msUserInfo.usr_address.id = (id<<24);

                for( int i = 0; i < eAddrLangageNum; i++ )
                {
                    swprintf( msUserInfo.usr_address.countryName[i],
                                        eAddrNameLength, (const wchar_t*)p_country->countryName[i] );
                }

                if( p_country->newEntry )
                {
                    msTwlInfo2.ds_country.country = nn::cfg::CTR::CFG_COUNTRY_OTHERS;
                }
                else
                {
                    msTwlInfo2.ds_country.country = (u8)id;
                }
            }
        }
        else
        {
        CountryInfo*   p_country = reinterpret_cast<CountryInfo*>( p_data1 );
        int     id;

            for( int i = 0; i < msCountryNum; i++ )
            {
                id = (p_country->id)>>24;

                if( id == cid  )
                {
                    msWorkInfo.country_id = id;
                    msWorkInfo.area_num = p_country->numRegion;
                    break;
                }
                p_country++;
            }
        }

        delete []p_data;
    }

// 1言語しかないリージョンのとき
    switch( System::getRegion() )
    {
    case nn::cfg::CTR::CFG_REGION_JAPAN:
        msUserInfo.usr_language.languageCode = nn::cfg::CTR::CFG_LANGUAGE_JAPANESE;
        msTwlInfo.ds_data.option.language = nn::cfg::CTR::CFG_LANGUAGE_JAPANESE;
        msTwlInfo.ds_data_ex.language = nn::cfg::CTR::CFG_LANGUAGE_JAPANESE;
        break;

    case nn::cfg::CTR::CFG_REGION_CHINA:
        msUserInfo.usr_language.languageCode = nn::cfg::CTR::CFG_LANGUAGE_SIMP_CHINESE;
        msTwlInfo.ds_data.option.language = nn::cfg::CTR::CFG_LANGUAGE_ENGLISH;
        msTwlInfo.ds_data_ex.language = nn::cfg::CTR::CFG_LANGUAGE_SIMP_CHINESE;
        break;

    case nn::cfg::CTR::CFG_REGION_KOREA:
        msUserInfo.usr_language.languageCode = nn::cfg::CTR::CFG_LANGUAGE_KOREAN;
        msTwlInfo.ds_data.option.language = nn::cfg::CTR::CFG_LANGUAGE_ENGLISH;
        msTwlInfo.ds_data_ex.language = nn::cfg::CTR::CFG_LANGUAGE_KOREAN;
        break;

    case nn::cfg::CTR::CFG_REGION_TAIWAN:
        if( msFirstInfo.mmen == 0 ) // 初回起動のとき
        {
            msUserInfo.usr_language.languageCode = nn::cfg::CTR::CFG_LANGUAGE_TRAD_CHINESE;
            msTwlInfo.ds_data.option.language = nn::cfg::CTR::CFG_LANGUAGE_JAPANESE;
            msTwlInfo.ds_data_ex.language = nn::cfg::CTR::CFG_LANGUAGE_JAPANESE;
        }
        break;

    // US・EUリージョン
    default:
        if( msFirstInfo.mmen == 0 ) // 初回起動のとき
        {
            msUserInfo.usr_language.languageCode = nn::cfg::CTR::CFG_LANGUAGE_ENGLISH;
            msTwlInfo.ds_data.option.language = nn::cfg::CTR::CFG_LANGUAGE_ENGLISH;
            msTwlInfo.ds_data_ex.language = nn::cfg::CTR::CFG_LANGUAGE_ENGLISH;
        }
        break;
    }
#endif
}


//==========================================================================
//          初回起動用パラメータ
//==========================================================================
void UserInfoAccessor::setFirstParam()
{
    msUserInfo.usr_sound.soundOutputMode = nn::cfg::CFG_SOUND_OUTPUT_MODE_SURROUND;

    msUserInfo.usr_birthday.month = 1;
    msUserInfo.usr_birthday.day = 1;

    msTwlInfo.ds_data.owner.birthday.month = 1;
    msTwlInfo.ds_data.owner.birthday.day = 1;

    msTwlInfo.ds_data.owner.userColor = 15;

    msTwlInfo.ds_data.option.isSetBirthday = 1;
    msTwlInfo.ds_data.option.isSetUserColor = 1;
    msTwlInfo.ds_data.option.isSetLanguage = 1;
    msTwlInfo.ds_data.option.isSetNickname = 1;

    msTwlInfo2.ds_eula.agreeEulaVersion = 0xff;

    msWorkInfo.time[0] = 10;
    msWorkInfo.time[1] = 0;

    switch( System::getRegion() )
    {
    case nn::cfg::CTR::CFG_REGION_CHINA:
    case nn::cfg::CTR::CFG_REGION_KOREA:
    case nn::cfg::CTR::CFG_REGION_TAIWAN:
        msWorkInfo.date[0] = 12;
        break;

    default:
        msWorkInfo.date[0] = 11;
        break;
    }

    msWorkInfo.date[1] = 1;
    msWorkInfo.date[2] = 1;
}


//==========================================================================
//          初回起動フラグのセット・リセット
//==========================================================================
void UserInfoAccessor::setFirstAll( bool set )
{
    if( set )
    {
        msFirstInfo.mmen = 1;

        msFirst.end = 1;
        msFirst.langage = 1;
        msFirst.date = 1;
        msFirst.time = 1;

        msFirst.name = 1;
        msFirst.birthday = 1;
        msFirst.country = 1;
        msFirst.area = 1;

        msFirst.view = 1;
        msFirst.eula = 1;
    }
    else
    {
        memset( &msFirstInfo, 0, sizeof( msFirstInfo ) );
        memset( &msFirst, 0, sizeof( msFirst ) );
    }
}


//*********************************************************************************
//                  イベント
//*********************************************************************************
void UserInfoAccessor::eventProc( int info_event )
{
#if 0
int     type = 1;
bool    lang_change = false;

    switch( info_event )
    {
    case eUserInfo_Save2:
        type = 2;

    case eUserInfo_Save:
    case eUserInfo_Save1:
        if( msDirty > 0 )
        {
        bool    nand_write = false;
        bool    cop_check = false;

            if( msDirty & eUserInfo )
            {
            bool    save = false;

                // ユーザー情報のNAND書き込み
                for( int i = eKindUserName; i <= eKindSound; i++ )
                {
                    if( data_user_info_( i, type ) )
                    {
                        save = true;

                        if( i == eKindAddressCountry )
                        {
                            setBossTask();
                            cop_check = true;
                        }
                        else if( i == eKindLanguage )
                        {
                            System::set_language_( msUserInfo.usr_language.languageCode );

                            if( System::getRegion() == nn::cfg::CTR::CFG_REGION_TAIWAN )
                            {
                                scene::Table::adjustSmngTable();
                            }

                            setBossTask();
                            lang_change = true;
                        }
                    }
                }

                if( save )
                {
                    nand_write = true;
                    NN_LOG( "Save UserInfo\n" );
                }

                msBackupUserInfo = msUserInfo;
            }

            if( msDirty & eTwlInfo )
            {
                if( data_user_info_( eKindDsData, type ) )
                {
                    NN_LOG( "Save TwlInfo\n" );
                }

                msBackupTwlInfo = msTwlInfo;
            }

            if( msDirty & eTwlInfo2 )
            {
            bool    save = false;

                for( int i = eKindDsCountry; i <= eKindDsEula; i++ )
                {
                    if( data_user_info_( i, type ) )
                    {
                        save = true;
                    }
                }

                if( save )
                {
                    nand_write = true;
                    NN_LOG( "Save TwlInfo2\n" );
                }

                msBackupTwlInfo2 = msTwlInfo2;
            }

            if( msDirty & eNetInfo )
            {
                if( info_event != eUserInfo_Save1 )
                {
                    // ネットワーク設定のNAND書き込み
                    flush_net_setting_();
                }

                msBackupNetInfo = msNetInfo;
            }

            if( msDirty & eNetInfo2 )
            {
            bool    save = false;

                // NAND書き込み
                for( int i = eKindEula; i <= eKindBoss; i++ )
                {
                    if( data_user_info_( i, type ) )
                    {
                        save = true;
                    }
                }

                if( save )
                {
                    nand_write = true;
                    NN_LOG( "Save NetInfo2\n" );
                }

                msBackupNetInfo = msNetInfo;
            }

            if( msDirty & eParentInfo )
            {
                if( data_user_info_( eKindParental, type ) )
                {
                    nand_write = true;
                    NN_LOG( "Save Parental\n" );
                }

                msBackupParentInfo = msParentInfo;
            }

#ifdef NW_RELEASE
// COPPACSが必要な国だけCOPPACSのセーブあり（リリース以外は全バージョンでセーブあり）
            if( msIsCoppa )
#endif
            {
                if( msDirty & eCoppaInfo )
                {
                    if( type != 2 )
                    {
                        if( data_user_info_( eKindCoppa, type ) )
                        {
                            nand_write = true;
                            NN_LOG( "Save Coppa\n" );
                        }

                        msBackupCoppaInfo = msCoppaInfo;
                    }
                }
            }

            if( msDirty & eWorkInfo )
            {
                msBackupWorkInfo = msWorkInfo;
            }

            msDirty = eNoneInfo;

            if( nand_write )    // NAND書き込み
            {
            nn::Result  result = nn::cfg::CTR::init::FlushConfig();

                // COPPACSチェック
                if( cop_check )
                {
                    setCoppacs();
                }

#ifndef NW_RELEASE
                NN_LOG( "flush_cnf = %d\n", result.IsSuccess() );
#endif
            }
        }
        break;

    case eUserInfo_Reset:
        msUserInfo = msBackupUserInfo;
        msTwlInfo = msBackupTwlInfo;
        msTwlInfo2 = msBackupTwlInfo2;
        msParentInfo = msBackupParentInfo;
        msCoppaInfo = msBackupCoppaInfo;
        msNetInfo = msBackupNetInfo;
        msWorkInfo = msBackupWorkInfo;

        msDirty = eNoneInfo;
        break;

    default:
        break;
    }

    // 完全にFlushしてから行う
    if( lang_change )
    {
        sys::KeyboardManager::repreload();
    }
#endif
}


//*********************************************************************************
//                  ユーザー情報
//*********************************************************************************
//==========================================================================
//          セーブ準備
//==========================================================================
void UserInfoAccessor::setUserInfo( UserInfo& user_info )
{
    msUserInfo = user_info;
    msDirty |= eUserInfo;
}


//==========================================================================
//          セーブ準備
//==========================================================================
void UserInfoAccessor::setTwlInfo( TwlInfo& twl_info )
{
    msTwlInfo = twl_info;
    msDirty |= eTwlInfo;
}


//==========================================================================
//          セーブ準備
//==========================================================================
void UserInfoAccessor::setTwlInfo2( TwlInfo2& twl_info )
{
    msTwlInfo2 = twl_info;
    msDirty |= eTwlInfo2;
}


//==========================================================================
//          ワーク
//==========================================================================
void UserInfoAccessor::setWorkInfo( WorkInfo& work_info )
{
    msWorkInfo = work_info;
    msDirty |= eWorkInfo;
}


//*********************************************************************************
//                  ペアレンタル情報
//*********************************************************************************
//==========================================================================
//          セーブ準備
//==========================================================================
void UserInfoAccessor::setParentInfo( nn::cfg::CTR::ParentalControlInfo& parent_info )
{
    msParentInfo = parent_info;
    msDirty |= eParentInfo;
}


//==========================================================================
//          ペアレンタルクリア
//==========================================================================
void UserInfoAccessor::clrParentInfo( bool eula )
{
    memset( &msParentInfo, 0, sizeof( msParentInfo ) );
    memset( &msTwlInfo2.ds_pare, 0, sizeof( nn::cfg::CTR::detail::TwlParentalControlInfoCfgData ) );

    msDirty |= eParentInfo;
    msDirty |= eTwlInfo2;

    if( eula )
    {
        clrNet2();
    }
}


//==========================================================================
//          ペアレンタル設定が更新されたかチェック
//==========================================================================
bool UserInfoAccessor::isCheckParentInfo()
{
s8*     org = (s8*)( &msParentInfo );
s8*     back = (s8*)( &msBackupParentInfo );
int     size = sizeof( msParentInfo );

    for( int i = 0; i < size; i++ )
    {
        if( *org++ != *back++ )
        {
            return true;    // 変更があったらtrue
        }
    }
    return false;
}


//*********************************************************************************
//                  COPPACS情報
//*********************************************************************************
//==========================================================================
//          セーブ準備
//==========================================================================
void UserInfoAccessor::setCoppaInfo( nn::cfg::CTR::detail::CoppacsCfgData& coppa_info )
{
    msCoppaInfo = coppa_info;
    msDirty |= eCoppaInfo;
}


//==========================================================================
//          COPPACS設定が更新されたかチェック
//==========================================================================
bool UserInfoAccessor::isCheckCoppaInfo()
{
s8*     org = (s8*)( &msCoppaInfo );
s8*     back = (s8*)( &msBackupCoppaInfo );
int     size = sizeof( msCoppaInfo );

    for( int i = 0; i < size; i++ )
    {
        if( *org++ != *back++ )
        {
            return true;    // 変更があったらtrue
        }
    }
    return false;
}


//==========================================================================
//          セーブ
//==========================================================================
void UserInfoAccessor::saveCoppaInfo( nn::cfg::CTR::detail::CoppacsCfgData& coppa_info )
{
    msCoppaInfo = coppa_info;

    if( data_user_info_( eKindCoppa, 1 ) )
    {
        nn::cfg::CTR::init::FlushConfig();

        NN_LOG( "Save Coppa\n" );
    }

    msBackupCoppaInfo = msCoppaInfo;
}


//==========================================================================
//          COPPACSが必要かどうか
//==========================================================================
void UserInfoAccessor::setCoppacs()
{
#ifdef NW_RELEASE
    msIsCoppa = nn::cfg::IsCoppacsSupported();    // COPPACSある地域か？
#else
    msIsCoppa = true;
#endif
}


//*********************************************************************************
//                  ネットワーク
//*********************************************************************************
//==========================================================================
//          セーブ準備
//==========================================================================
void UserInfoAccessor::setNetInfo( NetInfo& net_info )
{
    msNetInfo = net_info;
    msDirty |= eNetInfo;
}

//==========================================================================
void UserInfoAccessor::setNetWireless( int num, nn::ac::CTR::WirelessSetting& wireless )
{
    msNetInfo.setting[num].wireless = wireless;
    msDirty |= eNetInfo;
}

//==========================================================================
void UserInfoAccessor::setNetIp( int num, nn::ac::CTR::IpSetting& ip )
{
    msNetInfo.setting[num].ip = ip;
    msDirty |= eNetInfo;
}

//==========================================================================
void UserInfoAccessor::setNetProxy( int num, nn::ac::CTR::ProxySetting& proxy )
{
    msNetInfo.setting[num].proxy = proxy;
    msDirty |= eNetInfo;
}

//==========================================================================
void UserInfoAccessor::setNetOther( int num, nn::ac::CTR::OtherSetting& other )
{
    msNetInfo.setting[num].other = other;
    msDirty |= eNetInfo;
}

//==========================================================================
// 初回起動特別API、ProcessManagerから呼ばれる
void UserInfoAccessor::set_first_boot_ac_()
{
    // ネット設定初期化
    nn::ac::CTR::InitializeInternal();

    nn::ac::CTR::RemoveNetworkSetting( 0 );
    nn::ac::CTR::RemoveNetworkSetting( 1 );
    nn::ac::CTR::RemoveNetworkSetting( 2 );

    nn::ac::FlushNetworkSetting();
    nn::ac::CTR::FinalizeInternal();

    // ネットワーク設定のNAND書き込み
    flush_net_setting_();
}

//==========================================================================
//          BOSS設定
//==========================================================================
void UserInfoAccessor::setNetBg24Get( bool used )
{
nn::Result result;
bool       optout = !used;

// BOSS の受信
    msNetInfo.net_boss.isAllowedPushApp = used;

// バショトリャーの受信
//    NN_LOG( "used:%d, optout:%d\n", used, optout );
    result = nn::news::CTR::boss::SaveBashotoryaTaskOptoutFlag( getHomePid(), optout );
    NN_ASSERT_RESULT( result );

    msDirty |= eNetInfo2;
}

void UserInfoAccessor::setNetBg24Send( bool used )
{
nn::Result result;
bool       optout = !used;

// 本体情報の送信
    msNetInfo.net_boss.isAllowedUploadPersonalData = used;

// プレイ履歴のアップロードタスク
    result = nn::news::CTR::boss::SavePlayLogUploadTaskOptoutFlag( getHomePid(), optout );
    NN_ASSERT_RESULT( result );
// BOSS へ送信する情報
    saveBossSendInfoTaskOptoutFlag( optout );

    msDirty |= eNetInfo2;
}

void UserInfoAccessor::clrNetBg24()
{
nn::Result result;
bit64      homePid = getHomePid();

    msNetInfo.net_boss.isAllowedPushApp = false;
    msNetInfo.net_boss.isAllowedUploadPersonalData = false;

// バショトリャーの受信、履歴の送信
    result = nn::news::CTR::boss::SaveBashotoryaTaskOptoutFlag( homePid, true );
    result = nn::news::CTR::boss::SavePlayLogUploadTaskOptoutFlag( homePid, true );
    NN_ASSERT_RESULT( result );

    msDirty |= eNetInfo2;
}

nn::ProgramId UserInfoAccessor::getHomePid()
{
nn::ProgramId   pid;
bit32   uid = nn::CTR::PROGRAM_ID_UNIQUE_ID_HOMEMENU;
bit8    ver = nn::CTR::PROGRAM_ID_VERSION_HOMEMENU;

    switch( System::getRegion() )
    {
    case nn::cfg::CTR::CFG_REGION_AMERICA:
        uid = nn::CTR::PROGRAM_ID_UNIQUE_ID_SYSMENU_US;
        ver = nn::CTR::PROGRAM_ID_VERSION_SYSMENU_US;
        break;

    case nn::cfg::CTR::CFG_REGION_EUROPE:
    case nn::cfg::CTR::CFG_REGION_AUSTRALIA:
        uid = nn::CTR::PROGRAM_ID_UNIQUE_ID_SYSMENU_EU;
        ver = nn::CTR::PROGRAM_ID_VERSION_SYSMENU_EU;
        break;

    case nn::cfg::CTR::CFG_REGION_CHINA:
        uid = nn::CTR::PROGRAM_ID_UNIQUE_ID_SYSMENU_CN;
        ver = nn::CTR::PROGRAM_ID_VERSION_SYSMENU_CN;
        break;

    case nn::cfg::CTR::CFG_REGION_KOREA:
        uid = nn::CTR::PROGRAM_ID_UNIQUE_ID_SYSMENU_KR;
        ver = nn::CTR::PROGRAM_ID_VERSION_SYSMENU_KR;
        break;

    case nn::cfg::CTR::CFG_REGION_TAIWAN:
        uid = nn::CTR::PROGRAM_ID_UNIQUE_ID_SYSMENU_TW;
        ver = nn::CTR::PROGRAM_ID_VERSION_SYSMENU_TW;
        break;
    }

    pid = nn::CTR::MakeProgramId( nn::CTR::PROGRAM_ID_CATEGORY_APPLET,
                                  uid,
                                  ver );  // プログラムID
    NN_LOG( "menu pid:%016llX\n", pid );

    return pid;
}

nn::ProgramId UserInfoAccessor::getMsetPid()
{
nn::ProgramId   pid;
bit32   uid = nn::CTR::PROGRAM_ID_UNIQUE_ID_MSET;
bit8    ver = nn::CTR::PROGRAM_ID_VERSION_MSET;

    switch( System::getRegion() )
    {
    case nn::cfg::CTR::CFG_REGION_AMERICA:
        uid = nn::CTR::PROGRAM_ID_UNIQUE_ID_MSET_US;
        ver = nn::CTR::PROGRAM_ID_VERSION_MSET_US;
        break;

    case nn::cfg::CTR::CFG_REGION_EUROPE:
    case nn::cfg::CTR::CFG_REGION_AUSTRALIA:
        uid = nn::CTR::PROGRAM_ID_UNIQUE_ID_MSET_EU;
        ver = nn::CTR::PROGRAM_ID_VERSION_MSET_EU;
        break;

    case nn::cfg::CTR::CFG_REGION_CHINA:
        uid = nn::CTR::PROGRAM_ID_UNIQUE_ID_MSET_CN;
        ver = nn::CTR::PROGRAM_ID_VERSION_MSET_CN;
        break;

    case nn::cfg::CTR::CFG_REGION_KOREA:
        uid = nn::CTR::PROGRAM_ID_UNIQUE_ID_MSET_KR;
        ver = nn::CTR::PROGRAM_ID_VERSION_MSET_KR;
        break;

    case nn::cfg::CTR::CFG_REGION_TAIWAN:
        uid = nn::CTR::PROGRAM_ID_UNIQUE_ID_MSET_TW;
        ver = nn::CTR::PROGRAM_ID_VERSION_MSET_TW;
        break;
    }

    pid = nn::CTR::MakeProgramId( nn::CTR::PROGRAM_ID_CATEGORY_SYSTEM_APPLICATION,
                                  uid,
                                  ver );  // プログラムID
    NN_LOG( "mset pid:%016llX\n", pid );

    return pid;
}

nn::ProgramId UserInfoAccessor::getPnotePid()
{
nn::ProgramId   pid;
bit32   uid = nn::CTR::PROGRAM_ID_UNIQUE_ID_PNOTE;
bit8    ver = nn::CTR::PROGRAM_ID_VERSION_APP;

    switch( System::getRegion() )
    {
    case nn::cfg::CTR::CFG_REGION_AMERICA:
        uid = nn::CTR::PROGRAM_ID_UNIQUE_ID_PNOTE_US;
        break;

    case nn::cfg::CTR::CFG_REGION_EUROPE:
    case nn::cfg::CTR::CFG_REGION_AUSTRALIA:
        uid = nn::CTR::PROGRAM_ID_UNIQUE_ID_PNOTE_EU;
        break;

    case nn::cfg::CTR::CFG_REGION_CHINA:
        uid = nn::CTR::PROGRAM_ID_UNIQUE_ID_PNOTE_CN;
        break;

    case nn::cfg::CTR::CFG_REGION_KOREA:
        uid = nn::CTR::PROGRAM_ID_UNIQUE_ID_PNOTE_KR;
        break;

    case nn::cfg::CTR::CFG_REGION_TAIWAN:
        uid = nn::CTR::PROGRAM_ID_UNIQUE_ID_PNOTE_TW;
        break;
    }

    pid = nn::CTR::MakeProgramId( nn::CTR::PROGRAM_ID_CATEGORY_SYSTEM_APPLICATION,
                                  uid,
                                  ver );  // プログラムID
    NN_LOG( "pnote pid:%016llX\n", pid );

    return pid;
}

const char* UserInfoAccessor::getMsetBossCode()
{
const char* ret = "H1qQXKK4O6t57mXV";

    switch( System::getRegion() )
    {
    case nn::cfg::CTR::CFG_REGION_AMERICA:
        ret = "RuVtKeBFoN25TrSW";
        break;

    case nn::cfg::CTR::CFG_REGION_EUROPE:
    case nn::cfg::CTR::CFG_REGION_AUSTRALIA:
        ret = "JoCrq7bGXiCdPfPb";
        break;

    case nn::cfg::CTR::CFG_REGION_CHINA:
        ret = "BjXT9luy7CYEvk6B";
        break;

    case nn::cfg::CTR::CFG_REGION_KOREA:
        ret = "9VBflZvACW6nC7zZ";
        break;

    case nn::cfg::CTR::CFG_REGION_TAIWAN:
        ret = "9CdgDvc3yDYx755y";
        break;
    }

    return ret;
}

//==========================================================================
void UserInfoAccessor::clrNet2()
{
    msNetInfo.net_eula.agreeVersion.version = 0;
    msDirty |= eNetInfo2;

    msTwlInfo2.ds_eula.isAgreeEula = false;
//    msTwlInfo2.ds_eula.agreeEulaVersion = 0;  // todo: 同意EULAバージョンをクリアするならここで
    msDirty |= eTwlInfo2;
}

//==========================================================================
void UserInfoAccessor::prepareBossSendInfo()
{
    memset( &msBossSendInfo, 0, sizeof( msBossSendInfo ) );

    // cfg の情報のセット
    prepare_boss_send_cfg_info_();

    // インターネット設定の情報のセット
    prepare_boss_send_net_info_();

    // 工場出荷時のキャリブ情報のセット
    prepare_boss_send_factory_cal_info_();
}

void UserInfoAccessor::prepare_boss_send_cfg_info_()
{
int     size = 0;
bit32   key  = 0;

    size = sizeof( msBossSendInfo.cfgInfo.touchPanel );
    key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_HID,
                        nn::cfg::CTR::detail::NN_CFG_HID_CAL_TOUCHPANEL );
    nn::cfg::CTR::init::GetConfig( &msBossSendInfo.cfgInfo.touchPanel, size, key );

    size = sizeof( msBossSendInfo.cfgInfo.analogStick );
    key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_HID,
                        nn::cfg::CTR::detail::NN_CFG_HID_CAL_ANALOGSTICK );
    nn::cfg::CTR::init::GetConfig( &msBossSendInfo.cfgInfo.analogStick, size, key );

    size = sizeof( msBossSendInfo.cfgInfo.gyro );
    key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_HID,
                        nn::cfg::CTR::detail::NN_CFG_HID_CAL_GYROSCOPE );
    nn::cfg::CTR::init::GetConfig( &msBossSendInfo.cfgInfo.gyro, size, key );

    size = sizeof( msBossSendInfo.cfgInfo.accel );
    key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_HID,
                        nn::cfg::CTR::detail::NN_CFG_HID_CAL_ACCELEROMETER );
    nn::cfg::CTR::init::GetConfig( &msBossSendInfo.cfgInfo.accel, size, key );

    size = sizeof( msBossSendInfo.cfgInfo.backLight );
    key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_LCD,
                        nn::cfg::CTR::detail::NN_CFG_LCD_BACKLIGHT );
    nn::cfg::CTR::init::GetConfig( &msBossSendInfo.cfgInfo.backLight, size, key );

    size = sizeof( msBossSendInfo.cfgInfo.camera );
    key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_CAMERA,
                        nn::cfg::CTR::detail::NN_CFG_CAMERA_CAL );
    nn::cfg::CTR::init::GetConfig( &msBossSendInfo.cfgInfo.camera, size, key );

    size = sizeof( msBossSendInfo.cfgInfo.sound );
    key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_SOUND,
                        nn::cfg::CTR::detail::NN_CFG_SOUND_SETTING );
    nn::cfg::CTR::init::GetConfig( &msBossSendInfo.cfgInfo.sound, size, key );

    size = sizeof( msBossSendInfo.cfgInfo.language );
    key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_USER_INFO,
                        nn::cfg::CTR::detail::NN_CFG_USER_INFO_LANGUAGE );
    nn::cfg::CTR::init::GetConfig( &msBossSendInfo.cfgInfo.language, size, key );

    size = sizeof( msBossSendInfo.cfgInfo.simpleAddress );
    key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_SIMPLE_ADDRESS,
                        nn::cfg::CTR::detail::NN_CFG_SIMPLE_ADDRESS_ID );
    nn::cfg::CTR::init::GetConfig( &msBossSendInfo.cfgInfo.simpleAddress, size, key );

    size = sizeof( msBossSendInfo.cfgInfo.parental );
    key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_PARENTAL_CONTROL,
                        nn::cfg::CTR::detail::NN_CFG_PARENTAL_CONTROL_INFO );
    nn::cfg::CTR::init::GetConfig( &msBossSendInfo.cfgInfo.parental, size, key );

    size = sizeof( msBossSendInfo.cfgInfo.eula );
    key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_EULA,
                        nn::cfg::CTR::detail::NN_CFG_EULA_INFO );
    nn::cfg::CTR::init::GetConfig( &msBossSendInfo.cfgInfo.eula, size, key );

    size = sizeof( msBossSendInfo.cfgInfo.boss );
    key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_BOSS,
                        nn::cfg::CTR::detail::NN_CFG_BOSS_SETTING );
    nn::cfg::CTR::init::GetConfig( &msBossSendInfo.cfgInfo.boss, size, key );

    msBossSendInfo.cfgInfo.svr2Vol = sys::Input::getSvr2Volume();
    nn::hid::CTR::GetSoundVolume( &msBossSendInfo.cfgInfo.sndVol );

    size = sizeof( msBossSendInfo.coppacsInfo );
    key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_PARENTAL_CONTROL,
                        nn::cfg::CTR::detail::NN_CFG_PARENTAL_CONTROL_COPPACS );
    nn::cfg::CTR::init::GetConfig( &msBossSendInfo.coppacsInfo, size, key );
}

void UserInfoAccessor::prepare_boss_send_net_info_()
{
NetInfo   netInfo;

    memset( &netInfo, 0, sizeof( netInfo ) );

    nn::ac::InitializeInternal();
    nn::ac::LoadNetworkSetting( 0, netInfo.setting[0] );
    nn::ac::LoadNetworkSetting( 1, netInfo.setting[1] );
    nn::ac::LoadNetworkSetting( 2, netInfo.setting[2] );
    nn::ac::FinalizeInternal();

    for( int i = 0; i < NetInfo::eInfoMax; ++i )
    {
        if( netInfo.setting[i].wireless.enable )
        {
            msBossSendInfo.netInfo[i].networkVersion = netInfo.setting[i].version;
            msBossSendInfo.netInfo[i].wirelessEnable = netInfo.setting[i].wireless.enable;
            msBossSendInfo.netInfo[i].wirelessEditableEssidSecrity = netInfo.setting[i].wireless.editableEssidSecurity;
            msBossSendInfo.netInfo[i].multiSsidEnable = netInfo.setting[i].wireless.multiSsid.enable;
            msBossSendInfo.netInfo[i].ipEnableDHCP = netInfo.setting[i].ip.enableDHCP;
            msBossSendInfo.netInfo[i].ipAutoDNSSetting = netInfo.setting[i].ip.autoDNSSetting;
            msBossSendInfo.netInfo[i].proxyEnable = netInfo.setting[i].proxy.enable;
            msBossSendInfo.netInfo[i].otherEnableUPnP = netInfo.setting[i].other.enableUPnP;
            msBossSendInfo.netInfo[i].essidSecurityMode = netInfo.setting[i].wireless.essidSecurity.securityMode;
            msBossSendInfo.netInfo[i].multiSsidType = netInfo.setting[i].wireless.multiSsid.multiSsidType;
            msBossSendInfo.netInfo[i].proxyAuthType = netInfo.setting[i].proxy.authType;
            msBossSendInfo.netInfo[i].padding = 0;
        }
    }
}

void UserInfoAccessor::prepare_boss_send_factory_cal_info_()
{
nn::Result   result;

    result = nn::cfg::CTR::init::GetCameraFactoryCal( &msBossSendInfo.factoryCalInfo.camera );
    if( result.IsFailure() )
    {
        // 異常状態なのでバッファをクリアしておく
        NN_LOG("get camera factory cal error!\n");
        memset( &msBossSendInfo.factoryCalInfo.camera, 0, sizeof( msBossSendInfo.factoryCalInfo.camera ) );
    }
    result = nn::cfg::CTR::init::GetAnalogStickFactoryCal( &msBossSendInfo.factoryCalInfo.analogStick );
    if( result.IsFailure() )
    {
        // 異常状態なのでバッファをクリアしておく
        NN_LOG("get analog stick factory cal error!\n");
        memset( &msBossSendInfo.factoryCalInfo.analogStick, 0, sizeof( msBossSendInfo.factoryCalInfo.analogStick ) );
    }
}

//==========================================================================
//          NET設定の「新規設定」を選択したときに作られるパラメータ
//==========================================================================
void UserInfoAccessor::setNetNewParam( int num )
{
    memset( &msNetInfo.setting[num], 0, sizeof( nn::ac::CTR::NetworkSetting ) );

    msNetInfo.setting[num].wireless.editableEssidSecurity = true;   // SSIDエディット可能
    msNetInfo.setting[num].ip.enableDHCP = true;                    // IP自動取得
    msNetInfo.setting[num].ip.autoDNSSetting = true;                // DNS自動取得
    msNetInfo.setting[num].proxy.enable = false;                    // Proxy使用しない
    msNetInfo.setting[num].proxy.authType = nn::ac::CTR::PROXY_AUTH_TYPE_NONE;  // Basic認証なし
    msNetInfo.setting[num].other.enableUPnP = false;                // UPnP無効

    msNetInfo.setting[num].proxy.port = 1;      // port = 1
    msNetInfo.setting[num].other.mtu = 1400;    // MTU = 1400

// バックアップにも書き込む
    msBackupNetInfo.setting[num] = msNetInfo.setting[num];

    msDirty |= eNetInfo;
}


//==========================================================================
//          接続設定の消去
//==========================================================================
void UserInfoAccessor::delNetSetInfo( int num )
{
nn::Result  result;

    nn::ac::InitializeInternal();

    result = nn::ac::RemoveNetworkSetting( num );

#ifndef NW_RELEASE
    NN_DBG_PRINT_RESULT( result );
#endif

    nn::ac::FlushNetworkSetting();
    nn::ac::FinalizeInternal();

    memset( &msNetInfo.setting[num], 0, sizeof( nn::ac::CTR::NetworkSetting ) );
    msBackupNetInfo = msNetInfo;
}


//==========================================================================
//          ネット設定が更新されたかチェック
//==========================================================================
bool UserInfoAccessor::isCheckNetworkInfo()
{
s8*     org = (s8*)( &msNetInfo.setting[msAccNum] );
s8*     back = (s8*)( &msBackupNetInfo.setting[msAccNum] );
int     size = sizeof( nn::ac::CTR::NetworkSetting )/*-sizeof( msNetInfo.setting[msAccNum].reserve )*/; // reserve分引く

    for( int i = 0; i < size; i++ )
    {
        if( *org++ != *back++ )
        {
            return false;
        }
    }
    return true;
}


//==========================================================================
//          ネットワーク設定のNAND書き込み
//==========================================================================
void UserInfoAccessor::flush_net_setting_()
{
    NN_LOG("flush_net_setting_\n");

    if( ( msAccNum >= 0 ) && ( msAccNum <= 2 ) )
    {
        memset( &msNetInfo.setting[msAccNum].scanlessConnect, 0, sizeof( nn::ac::ScanlessConnectSetting ) );
    }

    nn::ac::InitializeInternal();

    for( int i = 0; i < 3; i++ )
    {
        if( msNetInfo.setting[i].wireless.enable )
        {
            nn::ac::UpdateNetworkSetting( i, msNetInfo.setting[i] );

            NN_LOG( "net set save = %d\n", i );
        }
    }

    nn::ac::FlushNetworkSetting();
    nn::ac::FinalizeInternal();

    NN_LOG( "Save NetInfo\n" );
}


//*********************************************************************************
//                  CFG
//*********************************************************************************
//==========================================================================
//          CFGデータ（ユーザー設定）の Load / Save
//              type 0: Load / 1: save / 2: 強制save
//==========================================================================
bool UserInfoAccessor::data_user_info_( int kind, int type )
{
bool    ret = ( type == 2 );
u8*     org = NULL;
u8*     back = NULL;
int     size;
bit32   key;

    switch( kind )
    {
    case eKindUserName:
        org = (u8*)( &msUserInfo.usr_name );
        back = (u8*)( &msBackupUserInfo.usr_name );
        size = sizeof( nn::cfg::CTR::detail::UserNameCfgData );
        key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_USER_INFO,
                            nn::cfg::CTR::detail::NN_CFG_USER_INFO_USER_NAME );
        break;

    case eKindAddressId:
        org = (u8*)( &msUserInfo.usr_address.id );
        back = (u8*)( &msBackupUserInfo.usr_address.id );
        size = sizeof( nn::cfg::CTR::detail::SimpleAddressIdCfgData );
        key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_SIMPLE_ADDRESS,
                            nn::cfg::CTR::detail::NN_CFG_SIMPLE_ADDRESS_ID );
        break;

    case eKindAddressCountry:
        org = (u8*)( &msUserInfo.usr_address.countryName[0][0] );
        back = (u8*)( &msBackupUserInfo.usr_address.countryName[0][0] );
        size = sizeof( nn::cfg::CTR::detail::SimpleAddressCountryNameCfgData );
        key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_SIMPLE_ADDRESS,
                            nn::cfg::CTR::detail::NN_CFG_SIMPLE_ADDRESS_COUNTRY_NAME );
        break;

    case eKindAddressRegion:
        org = (u8*)( &msUserInfo.usr_address.regionName[0][0] );
        back = (u8*)( &msBackupUserInfo.usr_address.regionName[0][0] );
        size = sizeof( nn::cfg::CTR::detail::SimpleAddressRegionNameCfgData );
        key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_SIMPLE_ADDRESS,
                            nn::cfg::CTR::detail::NN_CFG_SIMPLE_ADDRESS_REGION_NAME );
        break;

    case eKindAddressPosition:
        org = (u8*)( &msUserInfo.usr_address.latitude );
        back = (u8*)( &msBackupUserInfo.usr_address.latitude );
        size = sizeof( nn::cfg::CTR::detail::SimpleAddressPositionCfgData );
        key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_SIMPLE_ADDRESS,
                            nn::cfg::CTR::detail::NN_CFG_SIMPLE_ADDRESS_POSITION );
        break;

    case eKindBirthday:
        org = (u8*)( &msUserInfo.usr_birthday );
        back = (u8*)( &msBackupUserInfo.usr_birthday );
        size = sizeof( nn::cfg::CTR::detail::BirthdayCfgData );
        key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_USER_INFO,
                            nn::cfg::CTR::detail::NN_CFG_USER_INFO_BIRTHDAY );
        break;

    case eKindLanguage:
        org = (u8*)( &msUserInfo.usr_language );
        back = (u8*)( &msBackupUserInfo.usr_language );
        size = sizeof( nn::cfg::CTR::detail::LanguageCfgData );
        key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_USER_INFO,
                            nn::cfg::CTR::detail::NN_CFG_USER_INFO_LANGUAGE );
        break;

    case eKindSound:
        org = (u8*)( &msUserInfo.usr_sound );
        back = (u8*)( &msBackupUserInfo.usr_sound );
        size = sizeof( nn::cfg::CTR::detail::SoundSettingCfgData );
        key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_SOUND,
                            nn::cfg::CTR::detail::NN_CFG_SOUND_SETTING );
        break;

    case eKindEula:
        org = (u8*)( &msNetInfo.net_eula );
        back = (u8*)( &msBackupNetInfo.net_eula );
        size = sizeof( nn::cfg::CTR::detail::EulaInfoCfgData );
        key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_EULA,
                            nn::cfg::CTR::detail::NN_CFG_EULA_INFO );
        break;

    case eKindBoss:
        org = (u8*)( &msNetInfo.net_boss );
        back = (u8*)( &msBackupNetInfo.net_boss );
        size = sizeof( nn::cfg::CTR::detail::BossSettingCfgData );
        key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_BOSS,
                            nn::cfg::CTR::detail::NN_CFG_BOSS_SETTING );
        break;

    case eKindParental:
        org = (u8*)( &msParentInfo );
        back = (u8*)( &msBackupParentInfo );
        size = sizeof( nn::cfg::CTR::ParentalControlInfo );
        key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_PARENTAL_CONTROL,
                            nn::cfg::CTR::detail::NN_CFG_PARENTAL_CONTROL_INFO );
        break;

    case eKindCoppa:
        org = (u8*)( &msCoppaInfo );
        back = (u8*)( &msBackupCoppaInfo );
        size = sizeof( nn::cfg::CTR::detail::CoppacsCfgData );
        key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_PARENTAL_CONTROL,
                            nn::cfg::CTR::detail::NN_CFG_PARENTAL_CONTROL_COPPACS );
        break;

    case eKindDsData:
        org = (u8*)( &msTwlInfo );
        back = (u8*)( &msBackupTwlInfo );
        size = sizeof( TwlInfo );
        break;

    case eKindDsCountry:
        org = (u8*)( &msTwlInfo2.ds_country );
        back = (u8*)( &msBackupTwlInfo2.ds_country );
        size = sizeof( nn::cfg::CTR::detail::TwlCountryCodeCfgData );
        key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_TWL,
                            nn::cfg::CTR::detail::NN_CFG_TWL_COUNTRY_CODE );
        break;

    case eKindDsParental:
        org = (u8*)( &msTwlInfo2.ds_pare );
        back = (u8*)( &msBackupTwlInfo2.ds_pare );
        size = sizeof( nn::cfg::CTR::detail::TwlParentalControlInfoCfgData );
        key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_TWL,
                            nn::cfg::CTR::detail::NN_CFG_TWL_PARENTAL_CONTROL_INFO );
        break;

    case eKindDsEula:
        org = (u8*)( &msTwlInfo2.ds_eula );
        back = (u8*)( &msBackupTwlInfo2.ds_eula );
        size = sizeof( nn::cfg::CTR::detail::TwlEulaInfoCfgData );
        key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_TWL,
                            nn::cfg::CTR::detail::NN_CFG_TWL_EULA_INFO );
        break;

    case eKindFirst:
        org = (u8*)( &msFirstInfo.mmen );
        size = sizeof( nn::cfg::CTR::detail::FirstLaunchInfoCfgData );
        key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_MENU,
                            nn::cfg::CTR::detail::NN_CFG_MENU_FIRST_LAUNCH );
        ret = true;
        break;

    default:
        return ret;
    }

    if( type >= 1 ) // save
    {
        if( !ret && ( back != NULL ) )
        {
            for( int i = 0; i < size; i++ )
            {
                if( org[i] != back[i] )
                {
                    ret = true;
                    break;
                }
            }
        }

        if( ret )
        {
        nn::Result  result;

            if( kind == eKindDsData )
            {
                result = nn::cfg::nor::CTR::SetNtrSetting( &msTwlInfo.ds_data, &msTwlInfo.ds_data_ex );
            }
            else
            {
                result = nn::cfg::CTR::init::SetConfig( key, org, size );
            }

            ret = result.IsSuccess();

#ifndef NW_RELEASE
            //scene::DebugLayout::setSaveScc( ret, kind );
#endif
            NN_LOG( "save %d ( %d )\n", kind, result.IsSuccess() );
        }
    }
    else    // load
    {
    nn::Result  result;

        if( kind == eKindDsData )
        {
            result = nn::cfg::nor::CTR::GetNtrSetting( &msTwlInfo.ds_data, &msTwlInfo.ds_data_ex );
        }
        else
        {
            result = nn::cfg::CTR::init::GetConfig( org, size, key );
        }

        NN_LOG( "load %d ( %d )\n", kind, result.IsSuccess() );
    }

    return ret;
}


#ifndef NW_RELEASE
//==========================================================================
//          初回起動の最後にもう一度Ds設定をNANDから読み込む
//==========================================================================
void UserInfoAccessor::getLastDsData()
{
nn::Result  result = nn::cfg::nor::CTR::GetNtrSetting( &msTwlInfo.ds_data, &msTwlInfo.ds_data_ex );

    NN_LOG( "ds_name = %ls ( %d ) (%d)\n", msTwlInfo.ds_data.owner.nickname.buffer,
                                           msTwlInfo.ds_data.owner.nickname.length , result.IsSuccess() );
}
#endif


//==========================================================================
//          スライドパッドのデータ取得
//==========================================================================
void UserInfoAccessor::getAnalogData( nn::cfg::CTR::detail::AnalogStickCfgData* para, int flg )
{
int     size = sizeof( nn::cfg::CTR::detail::AnalogStickCfgData );
bit32   key = get_cfg_key_( nn::cfg::CTR::detail::NN_CFG_HID,
                            nn::cfg::CTR::detail::NN_CFG_HID_CAL_ANALOGSTICK );

    if( flg == 0 )
    {
        nn::cfg::CTR::init::GetConfig( para, size, key );
    }
    else
    {
        nn::cfg::CTR::init::SetConfig( key, para, size );
        nn::cfg::CTR::init::FlushConfig();
    }
}


//==========================================================================
//          CTR->TWLに文字列の変換
//==========================================================================
void UserInfoAccessor::replaceUnusableString( wchar_t* buffer, int len )
{
    replaceUnusableStringWithTwlUserInfoFontTable(buffer,len);
}

void UserInfoAccessor::replaceUnusableStringWithTwlUserInfoFontTable(wchar_t* buffer, int len)
{
#ifndef NW_RELEASE
//    NN_LOG( "twl user info font table size = %d\n", sizeof( cTwlUserInfoFontCodeTable )/sizeof( u16 ) );
#endif
    for( int i = 0; i < len; i++ )
    {
        if( buffer[i] == L'\0' )
        {
            break;
        }
        else
        {
            if(binarySearchFromTwlUserInfoFontTable(buffer[i]))
            {
                //表示可能文字なので何もしない
            }
            else
            {
                //表示不可能文字なので置換する
                buffer[i] = L'?';
            }
        }
    }
}

bool UserInfoAccessor::binarySearchFromTwlUserInfoFontTable(u16 wc)
{
    //二分探索
    int begin = 0;
    int end = sizeof( cTwlUserInfoFontCodeTable )/sizeof( u16 ) - 1;

    while(begin <= end)
     {
         int idx = (begin+end)/2;

         if(cTwlUserInfoFontCodeTable[idx] == wc)
         {
             //見つかった
             return true;
         }
         else if(cTwlUserInfoFontCodeTable[idx] < wc)
         {
             //wcがあるとしたらidxより後ろ
             begin = idx+1;
         }
         else
         {
             //wcがあるとしたらidxより前
             end = idx-1;
         }
     }

    return false;
}


//==========================================================================
//          初回起動フラグのセーブ
//==========================================================================
void UserInfoAccessor::saveFirstInfo( int mmen, u8 net )
{
    if( mmen >= 0 )
    {
        msFirstInfo.mmen = (u16)mmen;
    }

    msFirstInfo.internet = net;

    if( msIsNetSave )
    {
        if( data_user_info_( eKindFirst, 1 ) )
        {
            nn::cfg::CTR::init::FlushConfig();

            NN_LOG( "Save FirstInfo\n" );
        }
    }
}


//==========================================================================
//          EULAのチェック
//==========================================================================
int UserInfoAccessor::checkEula()
{
EulaDef eula_data;
u8*     mount_buf = NULL;
int     region = System::getRegion();

#ifdef  MOUNT_SHARED_EULA
// Eula情報のマウント
    {
        mount_buf = sys::File::mountShare( "eula:", cSharedEulaId[region], 0, 40, 2 );
        if( mount_buf != NULL )
        {
            NN_LOG( "Eula data mount\n" );
        }
    }
#endif

// EULAデータの読み込み
    {
    u32     size;
#ifdef  MOUNT_SHARED_EULA
    u8*     p_file = sys::File::read( "eula:/country.bin", &size, false, false );
#else
    u8*     p_file = sys::File::read( cEulaCountry[region], &size, false, false );
#endif
    int     country_num = p_file[0];
    int     country_id = (msUserInfo.usr_address.id>>24);

        memset( &eula_data, 0, sizeof( EulaDef ) );

        NN_LOG( "country_id = %d ( %d )\n", country_id, country_num );

        {
        EulaDef*    p_eula = (EulaDef*)&p_file[16];

            for( int i = 0; i < country_num; i++ )
            {
                if( country_id == p_eula[i].id )
                {
                    eula_data = p_eula[i];
                    break;
                }
            }
        }

        delete []p_file;
    }

#ifdef  MOUNT_SHARED_EULA
    nn::fs::Unmount( "eula:" );
    delete []mount_buf;
#endif

    msWorkInfo.eula_minor = eula_data.minorVersion;
    msWorkInfo.eula_major = eula_data.majorVersion;
    msBackupWorkInfo = msWorkInfo;

// その国にEULAがあるか？
    if( ( eula_data.majorVersion == 0 ) && ( eula_data.minorVersion == 0 ) )
    {
        NN_LOG( "No EULA\n" );
        return -1;  // EULAがない
    }

// EULAに同意しているか？
    else if( msNetInfo.net_eula.agreeVersion.version == 0 )
    {
        NN_LOG( "Not agree\n" );
        return 0;   // 同意していない
    }

// 同意バージョンより新しいEULAがあるか？
    else if( ( msNetInfo.net_eula.agreeVersion.version == ((eula_data.majorVersion<<8) | eula_data.minorVersion)) )
    {
        NN_LOG( "old agree\n" );
        return 1;   // 新しいEULAがなかった
    }

    NN_LOG( "new agree\n" );
    return 2;       // 新しいEULAがある
}


//==========================================================================
//          EULAデータ読み直し
//==========================================================================
void UserInfoAccessor::loadEula()
{
    data_user_info_( eKindEula, 0 );
    data_user_info_( eKindBoss, 0 );
    data_user_info_( eKindDsEula, 0 );

    msBackupNetInfo.net_eula = msNetInfo.net_eula;
    msBackupNetInfo.net_boss = msNetInfo.net_boss;
    msBackupTwlInfo2.ds_eula = msTwlInfo2.ds_eula;
}


//==========================================================================
//          bossタスクセット
//==========================================================================
void UserInfoAccessor::setBossTask()
{
    if( msFirstInfo.mmen != 0 ) // 初回起動のときセットしない
    {
    const char* lang = nn::cfg::CTR::GetLanguageCodeA2( (nn::cfg::CTR::CfgLanguageCode)System::getCfgLanguage() );
    const char* country = nn::cfg::CTR::GetCountryCodeA2( (nn::cfg::CTR::CfgCountryCode)( msUserInfo.usr_address.id>>24 ) );
    const char* boss_code = nn::news::CTR::boss::GetBossCodeA3( (nn::cfg::CTR::CfgRegionCode)System::getRegion() );

        nn::news::CTR::boss::RegisterSystemTask( boss_code, country, lang );

        NN_LOG( "Boss Task Set\n" );
    }
}


void UserInfoAccessor::setBossSendInfoTask()
{
    // 初回起動シーケンスを通っていなかったら何もしない
    if( isFirst() )
    {
        NN_LOG("not initialize mset\n");
        return;
    }

    // BOSS への送信がオプトアウトされてたら何もしない
    data_user_info_( eKindBoss, 0 );
    if( !msNetInfo.net_boss.isAllowedUploadPersonalData )
    {
        NN_LOG("not allow upload\n");
        return;
    }

    if( !save_boss_send_info_() )
    {
        // 更新がなかったので情報は送信しない
        NN_LOG("no change send boss info\n");
        return;
    }

    // タスクの登録
    set_boss_send_info_task_();
}

void UserInfoAccessor::setBossSendInfoTaskFirst()
{
    // 初回起動シーケンスのときは EULA に同意していたらセットする
    if( !isEula() )
    {
        return;
    }

    if( !save_boss_send_info_() )
    {
        // 更新がなかったので情報は送信しない
        NN_LOG("no change send boss info\n");
        return;
    }

    // タスクの登録
    set_boss_send_info_task_();
}

void UserInfoAccessor::set_boss_send_info_task_()
{
const u16 cTaskExecuteTime  = 1;
const u16 cTaskExecuteCount = 1;
const char* cTaskUrl = "https://npul.c.app.nintendowifi.net/p01/recv/%s/%s";
const nn::boss::TaskPermission permission = nn::boss::TASK_PERMISSION_IN_PARENTAL_CONTROL;
const wchar_t* filePath = sys::File::getMsetSysSaveDataPath( sys::File::eSysSaveDataTypeBoss );
const int setSha1HashLen = 41;

nn::Result              result;
nn::fs::FileReader      file;
nn::boss::Task          task;
nn::boss::TaskPolicy    policy;
nn::boss::UploadAction  action;
u8*                     readData = NULL;
u8*                     readDataSha1 = NULL;
char                    setSha1Hash[ setSha1HashLen ];
size_t                  readDataSize = 0;

    // システムセーブデータのマウント
    sys::File::initializeMsetSys();

    result = task.Initialize( cSendBossInfoTaskId );
    NN_RESULT_ASSERT( result );

    result = policy.Initialize( cTaskExecuteTime, cTaskExecuteCount );
    NN_RESULT_ASSERT( result );
    result = policy.SetProperty( nn::boss::TASK_PERMISSION, &permission, sizeof( permission ) );
    NN_RESULT_ASSERT( result );

    // すでに登録されていた場合を考慮してタスクを削除します。
    // デーモンをとめていないと失敗する可能性がありますが、
    // MSET では起動時にデーモンを止めているため、
    // ここでデーモンを止める処理は呼びません。
    // また、失敗しても作業を続けるため、戻り値のチェックはしません。
    // ファイルがクローズされないようにファイルオープンよりも先に
    // タスクは削除します。
    nn::boss::UnregisterTask( &task );

    // ファイルの読み込み
    result = file.TryInitialize( filePath );
    if( result.IsFailure() )
    {
        // ここにきた際にファイルが読み込めないことはないはず
        // 読み込めなかったらこの先の処理も意味がなくなるのでリターンしてしまう
        file.Finalize();
        NN_LOG("can't initialize sendBossInfo file\n");
        sys::File::finalizeMsetSys();
        return;
    }

    {
        const int len = 100;
        char url[ len ];
        snprintf( url, len, cTaskUrl, getMsetBossCode(), cSendBossInfoTaskId );
        NN_LOG("url:%s\n", url);
        result = action.InitializeForBossDb( url, file.GetHandle() );
    }
    NN_RESULT_ASSERT( result );

    // クライアント証明書の設定
    result = action.SetClientCert( NNSSL_CLIENTCERT_DEFAULT );
    NN_RESULT_ASSERT( result );

    // SSL証明書を設定します.
    result = action.SetRootCa( nn::ssl::CACERT_PUBLIC_CA_1 );
    NN_RESULT_ASSERT( result );
    result = action.SetRootCa( nn::ssl::CACERT_NINTENDO_CA_G3 );
    NN_RESULT_ASSERT( result );

    // 読み込んだファイルの中身をsha-1でハッシュ値計算
    {
        // ファイル読み込み
        // 中で fileReader のinitialize が再び行われるのが少し冗長だが安全に読み込むため
        readData = sys::File::read( filePath, &readDataSize, false, false );
        if( readData == NULL )
        {
            // 読み込み失敗
            file.Finalize();
            NN_LOG("can't read sendBossInfo file\n");
            sys::File::finalizeMsetSys();
            return;
        }
        //readDataSha1 = new( sys::Mem::getMainHeap(), 4 ) u8[ nn::crypto::Sha1Context::HASH_SIZE ];
        nn::crypto::CalculateSha1( readDataSha1, readData, readDataSize );
        snprintf( setSha1Hash, setSha1HashLen,
                  "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n",
                  readDataSha1[ 0 ], readDataSha1[ 1 ], readDataSha1[ 2 ],
                  readDataSha1[ 3 ], readDataSha1[ 4 ], readDataSha1[ 5 ],
                  readDataSha1[ 6 ], readDataSha1[ 7 ], readDataSha1[ 8 ],
                  readDataSha1[ 9 ], readDataSha1[ 10 ], readDataSha1[ 11 ],
                  readDataSha1[ 12 ], readDataSha1[ 13 ], readDataSha1[ 14 ],
                  readDataSha1[ 15 ], readDataSha1[ 16 ], readDataSha1[ 17 ],
                  readDataSha1[ 18 ], readDataSha1[ 19 ] );
        NN_LOG("setSha1Hash:%s\n", setSha1Hash);

        result = action.AddHeaderField( "X-Boss-Digest", setSha1Hash );
        delete[] readDataSha1;
        delete[] readData;
        NN_RESULT_ASSERT( result );
    }

    result = nn::boss::RegisterTask( &task, &policy, &action );
    NN_RESULT_ASSERT( result );

    result = task.Start();
    NN_RESULT_ASSERT( result );

    file.Finalize();
    sys::File::finalizeMsetSys();

    NN_LOG("task set send boss info\n");
}


void UserInfoAccessor::saveBossSendInfoTaskOptoutFlag( bool optoutFlag )
{
nn::Result      result;

    if( optoutFlag )
    {
        NN_LOG("send boss info task cancel\n");
        result = nn::boss::CancelTask( getMsetPid(), cSendBossInfoTaskId );
        NN_LOG("mset cancel task\n");
        NN_DBG_PRINT_RESULT( result );
        result = nn::boss::CancelTask( getHomePid(), cSendBossMmenTaskId );
        NN_LOG("mmen cancel task\n");
        NN_DBG_PRINT_RESULT( result );
        result = nn::boss::CancelTask( getHomePid(), cSendPhuTaskId );
        NN_LOG("pedometer cancel task\n");
        NN_DBG_PRINT_RESULT( result );
        result = nn::boss::CancelTask( getHomePid(), cSendTiuTaskId );
        NN_LOG("task info cancel task\n");
        NN_DBG_PRINT_RESULT( result );
        result = nn::boss::CancelTask( getHomePid(), cSendSpluTaskId );
        NN_LOG("street pass cancel task\n");
        NN_DBG_PRINT_RESULT( result );
        result = nn::boss::CancelTask( getPnotePid(), cSendBossPnoteTaskId );
        NN_LOG("pnote cancel task\n");
        NN_DBG_PRINT_RESULT( result );
    }
    else
    {
        NN_LOG("send boss info task start\n");
        result = nn::boss::StartTask( getMsetPid(), cSendBossInfoTaskId );
        NN_LOG("mset start task\n");
        NN_DBG_PRINT_RESULT( result );
        result = nn::boss::StartTask( getHomePid(), cSendBossMmenTaskId );
        NN_LOG("mmen start task\n");
        NN_DBG_PRINT_RESULT( result );
        result = nn::boss::StartTask( getHomePid(), cSendPhuTaskId );
        NN_LOG("pedometer start task\n");
        NN_DBG_PRINT_RESULT( result );
        result = nn::boss::StartTask( getHomePid(), cSendTiuTaskId );
        NN_LOG("task info start task\n");
        NN_DBG_PRINT_RESULT( result );
        result = nn::boss::StartTask( getHomePid(), cSendSpluTaskId );
        NN_LOG("street pass start task\n");
        NN_DBG_PRINT_RESULT( result );
        result = nn::boss::StartTask( getPnotePid(), cSendBossPnoteTaskId );
        NN_LOG("pnote start task\n");
        NN_DBG_PRINT_RESULT( result );
    }
    // 消尽回数１回のタスクがあるので、すでにタスクがなかったときのためにアサートしない
    //NN_RESULT_ASSERT( result );
}


bool UserInfoAccessor::save_boss_send_info_()
{
size_t size = sizeof( BossSendInfo );
//BossSendInfo* pSaveData = new( sys::Mem::getMainHeap() ) BossSendInfo;
BossSendInfo* pSaveData;
bool ret = false;

    sys::File::initializeMsetSys();
    sys::File::readMsetFile( (u8*)pSaveData, size, sys::File::eSysSaveDataTypeBoss );

    // 送信情報の取得
    prepareBossSendInfo();
    if( checkUpdateBossSendInfo( pSaveData ) )
    {
        // 更新があったときのみセーブする
        NN_LOG("save send boss info\n");
        memcpy( pSaveData, &msBossSendInfo, size );
        sys::File::saveMsetSys( (u8*)pSaveData, size, sys::File::eSysSaveDataTypeBoss );
        ret = true;
    }
    sys::File::finalizeMsetSys();

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

    return ret;
}


bool UserInfoAccessor::checkUpdateBossSendInfo( BossSendInfo* pSaveData )
{
bool ret = false;

    // BossSendInfo のサイズが4で割り切れることを利用して実装しているため
    // 4で割り切れなかったときは警告
    NN_LOG("sizeof( BossSendInfo ):%d\n", sizeof( BossSendInfo ));
    NN_ASSERT( sizeof( BossSendInfo ) % sizeof( u32 ) == 0 );

#if 0
    for( int i = 0; i < NetInfo::eInfoMax; ++i )
    {
        NN_LOG("[%d]networkVersion:%d %d\n", i,
               pSaveData->netInfo[i].networkVersion, msBossSendInfo.netInfo[i].networkVersion);
        NN_LOG("[%d]wirelessEnable:%d %d\n", i,
               pSaveData->netInfo[i].wirelessEnable, msBossSendInfo.netInfo[i].wirelessEnable);
        NN_LOG("[%d]wirelessEditableEssidSecrity:%d %d\n", i,
               pSaveData->netInfo[i].wirelessEditableEssidSecrity, msBossSendInfo.netInfo[i].wirelessEditableEssidSecrity);
        NN_LOG("[%d]multiSsidEnable:%d %d\n", i,
               pSaveData->netInfo[i].multiSsidEnable, msBossSendInfo.netInfo[i].multiSsidEnable);
        NN_LOG("[%d]ipEnableDHCP:%d %d\n", i,
               pSaveData->netInfo[i].ipEnableDHCP, msBossSendInfo.netInfo[i].ipEnableDHCP);
        NN_LOG("[%d]ipAutoDNSSetting:%d %d\n", i,
               pSaveData->netInfo[i].ipAutoDNSSetting, msBossSendInfo.netInfo[i].ipAutoDNSSetting);
        NN_LOG("[%d]proxyEnable:%d %d\n", i,
               pSaveData->netInfo[i].proxyEnable, msBossSendInfo.netInfo[i].proxyEnable);
        NN_LOG("[%d]otherEnableUPnP:%d %d\n", i,
               pSaveData->netInfo[i].otherEnableUPnP, msBossSendInfo.netInfo[i].otherEnableUPnP);
        NN_LOG("[%d]essidSecurityMode:%d %d\n", i,
               pSaveData->netInfo[i].essidSecurityMode, msBossSendInfo.netInfo[i].essidSecurityMode);
        NN_LOG("[%d]multiSsidType:%d %d\n", i,
               pSaveData->netInfo[i].multiSsidType, msBossSendInfo.netInfo[i].multiSsidType);
        NN_LOG("[%d]proxyAuthType:%d %d\n", i,
               pSaveData->netInfo[i].proxyAuthType, msBossSendInfo.netInfo[i].proxyAuthType);
        NN_LOG("[%d]padding:%d %d\n", i,
               pSaveData->netInfo[i].padding, msBossSendInfo.netInfo[i].padding);
    }
#endif

    u32* pSave = (u32*)pSaveData;
    u32* pCfg = (u32*)(&msBossSendInfo);

    for( int i = 0; i < ( sizeof( BossSendInfo ) / sizeof( u32 ) ); ++i )
    {
        if( pSave[ i ] != pCfg[ i ] )
        {
            NN_LOG("i:%d change %08x != %08x\n", i, pSave[ i ], pCfg[ i ]);
            ret = true;
            break;
        }
    }

    return ret;
}


#ifdef MAKE_ACCTEST
#ifndef NW_RELEASE
//==========================================================================
//          CFGデータ（ネット設定）のモニタ
//==========================================================================
void UserInfoAccessor::print_net_save_()
{
    NN_LOG( "****** Net wireless SAVE DATA ******\n" );

    for( int i = 0; i < 3; i++ )
    {
        NN_LOG( "--- Setting %d ---\n", i+1 );
        if( !msNetInfo.setting[i].wireless.enable )
        {
            NN_LOG( "  no set\n\n" );
            continue;
        }

        NN_LOG( "version : %d\n", msNetInfo.setting[i].version );
        NN_LOG( "wireless\n" );
        NN_LOG( "  editable : %d\n\n", msNetInfo.setting[i].wireless.editableEssidSecurity );
        NN_LOG( "essidSecurity\n" );

        {
        char    ssid[40] = "";

            for( int j = 0; j < 32; j++ )
            {
                ssid[j] = msNetInfo.setting[i].wireless.essidSecurity.ssid[j];
            }
            NN_LOG( "  ssid : %s\n", ssid );
        }

        NN_LOG( "  ssidLength : %d\n", msNetInfo.setting[i].wireless.essidSecurity.ssidLength );
        NN_LOG( "  securityMode = %d\n", msNetInfo.setting[i].wireless.essidSecurity.securityMode );

        {
        char    pass[70] = "";

            for( int j = 0; j < 64; j++ )
            {
                pass[j] = msNetInfo.setting[i].wireless.essidSecurity.passphrase[j];
            }
            NN_LOG( "  passphrase : %s\n", pass );
        }

        NN_LOG( "  key :\n" );
        for( int j = 0; j < 64; j++ )
        {
            NN_LOG( "%02x ", msNetInfo.setting[i].wireless.essidSecurity.key[j] );
            if( (j%16) == 15 )
            {
                NN_LOG( "\n" );
            }
        }

        if( !msNetInfo.setting[i].wireless.multiSsid.enable )
        {
            NN_LOG( "  Multi no set\n\n" );
            continue;
        }

        NN_LOG( "  Multi Setting type : %d\n", msNetInfo.setting[i].wireless.multiSsid.multiSsidType );
        NN_LOG( "    Setting num = %d\n", msNetInfo.setting[i].wireless.multiSsid.settingNum );

        for( int n = 0; n < 4; n++ )
        {
            {
            char    ssid[40] = "";

                for( int j = 0; j < 32; j++ )
                {
                    ssid[j] = msNetInfo.setting[i].wireless.multiSsid.setting[n].ssid[j];
                }
                NN_LOG( "    ssid : %s\n", ssid );
            }

            NN_LOG( "    ssidLength : %d\n", msNetInfo.setting[i].wireless.multiSsid.setting[n].ssidLength );
            NN_LOG( "    securityMode = %d\n", msNetInfo.setting[i].wireless.multiSsid.setting[n].securityMode );

            {
            char    pass[70] = "";

                for( int j = 0; j < 64; j++ )
                {
                    pass[j] = msNetInfo.setting[i].wireless.multiSsid.setting[n].passphrase[j];
                }
                NN_LOG( "    passphrase : %s\n", pass );
            }

            NN_LOG( "    key :\n" );
            for( int j = 0; j < 64; j++ )
            {
                NN_LOG( "%02x ", msNetInfo.setting[i].wireless.multiSsid.setting[n].key[j] );
                if( (j%16) == 15 )
                {
                    NN_LOG( "\n" );
                }
            }

            NN_LOG( "\n" );
        }

        NN_LOG( "\n" );
    }

    NN_LOG( "****** Net wireless SAVE DATA END ******\n" );
}
#endif
#endif

#ifndef NW_RELEASE
    bool UserInfoAccessor::check_order_twl_user_info_font_table_()
    {
        int size = sizeof( cTwlUserInfoFontCodeTable )/sizeof( u16 );
        //データが昇順であることを確認する
        for(s32 i=1;i<size;i++)
        {
            if(cTwlUserInfoFontCodeTable[i] <= cTwlUserInfoFontCodeTable[i-1])
            {
                return false;
            }
        }
        return true;
    }
#endif

}

#endif // MAKE_AREACHECK