ctr_Repair/trunk/SkipFirstLaunch/StateManager.cpp

/*---------------------------------------------------------------------------*
  Project:  Horizon
  File:     StateManager.cpp

  Copyright (C)2011 Nintendo Co., Ltd.  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.

  $Rev$
 *---------------------------------------------------------------------------*/

#include <nn/news/CTR/system/news_BossUtil.h>
#include "StateManager.h"
#include "CfgChanger.h"
#include "syokaikidou.h"

#define STATE_MANAGER_SET_RESULT_RETURN_VOID_IF_FAILED(result)\
    do\
    {\
        s_Result = result;\
        if(s_Result.IsFailure())\
        {\
            return;\
        }\
    }while(0)

#define STATE_MANAGER_CHECK_RESULT()\
    do\
    {\
        if(s_Result.IsFailure())\
        {\
            m_State = STATE_ERROR;\
            return false;\
        }\
    }while(0)

#define STATE_MANAGER_WAIT_THREAD()\
    do\
    {\
        if(s_Thread.IsAlive())\
        {\
            return false;\
        }\
        else\
        {\
            s_Thread.Join();\
            s_Thread.Finalize();\
            STATE_MANAGER_CHECK_RESULT();\
            return true;\
        }\
    }while(0)

namespace
{
const size_t THREAD_STACK_SIZE = 0xA000;
nn::os::Thread s_Thread;
nn::os::StackBuffer<THREAD_STACK_SIZE> s_ThreadStack;
nn::Result s_Result;

void ImportToBackup()
{
    CfgChanger changer;
    STATE_MANAGER_SET_RESULT_RETURN_VOID_IF_FAILED(
            changer.ImportToBackup()
    );
}

void ApplyBackuptoCfg()
{
    NN_LOG("Set SaveData\n");
    CfgChanger changer;
    STATE_MANAGER_SET_RESULT_RETURN_VOID_IF_FAILED(
            changer.RestoreFromBackup()
    );

    STATE_MANAGER_SET_RESULT_RETURN_VOID_IF_FAILED(
            nn::news::CTR::boss::Initialize()
    );

    STATE_MANAGER_SET_RESULT_RETURN_VOID_IF_FAILED(
            fnc_1st_setting()
    );

    STATE_MANAGER_SET_RESULT_RETURN_VOID_IF_FAILED(
            fnc_starting_set()
    );
}

}

StateManager::StateManager(Mode mode) : m_State(STATE_START), m_Counter(0)
{
    m_Mode = mode;

}

StateManager::~StateManager()
{
    // TODO Auto-generated destructor stub
}

bool StateManager::Exec(bool goNext, scene::TextWriter* pTextWriter)
{
    pTextWriter->SetTextColor(255, 255, 255, 255);

    switch (m_State)
    {
    case STATE_START:
        {
            return true;
        }

    case STATE_CONFIRM_OVERWRITE:
        {
            pTextWriter->Printf(0, 22, L"Press A or START Button to Update Backup");
            if(goNext)
            {
                s_Thread.Start(ImportToBackup, s_ThreadStack);
                return true;
            }
        }
        break;

    case STATE_OVERWRITING:
        {
            pTextWriter->Printf(0, 22, L"Importing current settings to Backup Memory");
            DrawBusyIcon(pTextWriter);
            STATE_MANAGER_WAIT_THREAD();
        }

    case STATE_SETTING_IMPORT:
        {
            DrawBusyIcon(pTextWriter);
            s_Thread.Start(ApplyBackuptoCfg, s_ThreadStack);
            return true;
        }

    case STATE_SETTING_IMPORTING:
        {
            pTextWriter->Printf(0, 22, L"Applying settings in Backup Memory");
            DrawBusyIcon(pTextWriter);
            STATE_MANAGER_WAIT_THREAD();
        }

    case STATE_DONE:
        {
            pTextWriter->Printf(0, 22, L"Finished");
        }
        break;

    case STATE_ERROR:
        {
            if(s_Result == nn::MakePermanentResult(nn::Result::SUMMARY_INVALID_STATE, nn::Result::MODULE_APPLICATION, nn::Result::DESCRIPTION_OUT_OF_RANGE))
            {
                pTextWriter->Printf(0, 22, L"Version Mismatch");
            }
            else
            {
                pTextWriter->Printf(0, 22, L"Error Occurred: %08X", s_Result.GetPrintableBits());
            }
        }
        break;
    }

    return false;
}

void StateManager::GoNext()
{
    switch (m_State)
    {
    case STATE_START:
        {
            if(m_Mode == MODE_OVERWITE)
            {
                m_State = STATE_CONFIRM_OVERWRITE;
            }
            else if(m_Mode == MODE_APPLY)
            {
                m_State = STATE_SETTING_IMPORT;
            }
        }
        break;

    case STATE_CONFIRM_OVERWRITE:
        {
            m_State = STATE_OVERWRITING;
        }
        break;

    case STATE_OVERWRITING:
        {
            m_State = STATE_DONE;
        }
        break;

    case STATE_SETTING_IMPORT:
        {
            m_State = STATE_SETTING_IMPORTING;
        }
        break;

    case STATE_SETTING_IMPORTING:
        {
            m_State = STATE_DONE;
        }
        break;

    case STATE_DONE:
        {

        }
        break;

    case STATE_ERROR:
        {

        }
        break;
    }
}

bool StateManager::IsFinished()
{
    return m_State == STATE_DONE;
}

bool StateManager::IsError()
{
    return m_State == STATE_ERROR;
}

void StateManager::DrawBusyIcon(scene::TextWriter* pTextWriter)
{
    scene::DrawBusyIcon(pTextWriter, 380, 0, m_Counter++);
}