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

 Copyright (C)2013 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 "ActCompleter.h"
#include "Util.h"
#include "CommonLogger.h"
#include <nn/ac/CTR/private/ac_InternalApi.h>
#include <nn/act/act_ApiAdmin.h>
#include <nn/act/act_ApiTransfer.h>
#include <nn/act/act_ResultPrivate.h>
#include <nn/actslv/actslv_Api.h>

namespace ConsoleRestore
{
nn::Result ActCompleter::s_Result;
const size_t ActCompleter::STACK_SIZE;
nn::os::Thread ActCompleter::s_Thread;
nn::os::Thread ActCompleter::s_UnmountThread;
nn::os::StackBuffer<ActCompleter::STACK_SIZE> ActCompleter::s_ThreadStack;
nn::os::StackBuffer<ActCompleter::STACK_SIZE> ActCompleter::s_UnmountThreadStack;
nn::os::Event ActCompleter::s_BeginEvent;
nn::os::Event ActCompleter::s_EndEvent;
u32 ActCompleter::s_ApprovalId;
ActCompleter::CompleteMode ActCompleter::s_Mode;


ActCompleter::ActCompleter()
{
}

ActCompleter::~ActCompleter()
{
}

nn::Result ActCompleter::GetResult()
{
    return s_Result;
}

void ActCompleter::Start(CompleteMode mode)
{
    s_Mode = mode;
    s_ApprovalId = 0;
    if(s_Mode == ACT_COMPLETE_TRANSFER_WITH_SALVEGE)
    {
        s_BeginEvent.Initialize(false);
        s_EndEvent.Initialize(false);
    }

    s_Thread.Start(Exec, s_ThreadStack);
}

bool ActCompleter::IsFinished()
{
    return s_Thread.IsValid() && !s_Thread.IsAlive();
}

void ActCompleter::Finish()
{
    if(s_Thread.IsValid())
    {
        s_Thread.Join();
        s_Thread.Finalize();
    }
    if(s_Mode == ACT_COMPLETE_TRANSFER_WITH_SALVEGE)
    {
        if(s_UnmountThread.IsValid())
        {
            s_UnmountThread.Join();
            s_UnmountThread.Finalize();
        }
        s_BeginEvent.Finalize();
        s_EndEvent.Finalize();
    }
}

void ActCompleter::Exec()
{
    s_Result = ExecImpl();
}

void ActCompleter::UnmountThreadFunc()
{
    nn::act::KeepUnmountAndBlock( &s_BeginEvent, &s_EndEvent );
}

nn::Result ActCompleter::ExecImpl()
{
    if(!nn::ac::IsConnected())
    {
        NN_UTIL_RETURN_IF_FAILED(
                common::InitializeNetwork());
    }

    NN_UTIL_RETURN_IF_FAILED(
            nn::act::InitializeAdmin());

    if (s_Mode == ACT_COMPLETE_TRANSFER_WITH_SALVEGE)
    {
        // アンマウント
        s_UnmountThread.Start(UnmountThreadFunc, s_UnmountThreadStack);
        s_BeginEvent.Wait();

        // アンマウントできたのでアカウントサルベージを実行
        nn::Result result = nn::act::SalvageAccounts();
        if(result.IsFailure())
        {
            if(nn::act::ResultRequestNotFound().Includes(result))
            {
                //NNAが無い場合に起こるので無視
            }
            else
            {
                s_EndEvent.Signal();
                NN_UTIL_RETURN_IF_FAILED_1(
                        nn::act::FinalizeAdmin(),
                        common::FinalizeNetwork());

                NN_UTIL_RETURN_IF_FAILED(
                        common::FinalizeNetwork());
            }
        }

        s_ApprovalId = nn::act::GetSalvagedApprovalId();
        COMMON_LOGGER("ApprovalId = %d\n", s_ApprovalId);

        // サルベージ終了をシステムに通知
        s_EndEvent.Signal();
    }

    // 移行完了
    NN_UTIL_RETURN_IF_FAILED_2(
            nn::act::CompleteTransfer(),
            nn::act::FinalizeAdmin(),
            common::FinalizeNetwork());

    NN_UTIL_RETURN_IF_FAILED_1(
            nn::act::FinalizeAdmin(),
            common::FinalizeNetwork());

    NN_UTIL_RETURN_IF_FAILED(
            common::FinalizeNetwork());

    return nn::ResultSuccess();
}

} /* namespace ConsoleRestore */