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

  Copyright (C)2010-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 <cctype>

#include <nn.h>
#include <nn/ptm/CTR/ptm_ApiSysmenu.h>
#include <nn/fs/CTR/fs_ArchiveTypesForSystem.h>
#include <nn/fs/CTR/MPCore/fs_FileSystemBasePrivate.h>
#include <nn/fs/CTR/MPCore/fs_ApiIntegrityVerificationSeed.h>
#include <nn/fs/fs_ApiSysSaveData.h>
#include <nn/cfg/CTR/cfg_Api.h>
#include <nn/cfg/CTR/cfg_ApiInit.h>
#include <nn/cfg/CTR/cfg_ApiSys.h>
#include <nn/friends.h>
#include <nn/friends/CTR/friends_ApiPrivate.h>
#include <nn/ps.h>
#include <nn/drivers/mcu/CTR/driverMcuRegisterMap.h>

#include <nn/ac.h>
#include <nn/ac/private/ac.h>
#include <nn/ac/CTR/private/ac_InternalApi.h>
#include <nn/ac/CTR/private/ac_NetworkSetting.h>
#include <nn/nwm/CTR/nwm_ExtAPI.h>
#include <nn/nwm/CTR/nwm_ExtHwAPI.h>

#include "Util.h"
#include "FileName.h"
#include "CommonLogger.h"
#include "HeapManager.h"


namespace common
{

Util::Util() :
        m_BatteryRemain(100)
{

}

Util::~Util()
{

}

void Util::InitializeForBackup()
{
    Initialize();
}

void Util::InitializeForRestore()
{
    Initialize();
}

void Util::Initialize()
{
    nn::Result result;

    // mcuの初期化
    nn::mcu::CTR::InitializeHwCheck(&m_McuSession);
    mp_Mcu = new nn::mcu::CTR::HwCheck(m_McuSession);

    // リージョンの取得
    m_Region = nn::cfg::CTR::GetRegion();

    // バージョンの取得
    common::GetSystemVersion(&m_VerData, m_Region);

    // nwmの初期化
    nn::nwm::InitializeExtControl();
}

void Util::FinalizeForBackup()
{
    Finalize();
}

void Util::FinalizeForRestore()
{
    nn::friends::detail::Finalize();
}

void Util::Finalize()
{
    nn::nwm::FinalizeExtControl();
    nn::mcu::CTR::FinalizeHwCheck(&m_McuSession);
}

void Util::SetWifiOn()
{
    COMMON_LOGGER_RESULT_IF_FAILED(
            nn::nwm::Ext::SetWifiOn());
}

void Util::SetWifiOff()
{
    COMMON_LOGGER_RESULT_IF_FAILED(
            nn::nwm::Ext::SetWifiOff());
}

// 無線状態を取得する
bool Util::IsWifiOn()
{
    return nn::nwm::IsWifiOn();
}

bool Util::IsAdapterConnected()
{
    static nn::os::Tick last(0);
    static bool lastResult = false;
    const u8 UPDATE_INTERVAL = 100;

    nn::os::Tick now = nn::os::Tick::GetSystemCurrent();
    if(last == 0 || (now - last).ToTimeSpan().GetMilliSeconds() > UPDATE_INTERVAL)
    {
        u8 buf;
        nn::Result result = mp_Mcu->ReadByReceive(nn::drivers::mcu::CTR::MCU_PERIPHERAL_STATUS_ADDR, &buf, sizeof(buf));
        if(result.IsSuccess())
        {
            last = now;
            lastResult = buf & nn::drivers::mcu::CTR::MCU_STATUS_ADAPTER_MASK;
        }
    }
    return lastResult;

}

bool Util::IsBatteryLower()
{
    m_BatteryRemain = GetBatteryRemain();
    return m_BatteryRemain <= 10;
}

u8 Util::GetCupMajorVersion()
{
    return m_VerData.cup.majorVersion;
}

u8 Util::GetCupMinorVersion()
{
    return m_VerData.cup.minorVersion;
}

u8 Util::GetCupMicroVersion()
{
    return m_VerData.cup.microVersion;
}

u8 Util::GetNupVersion()
{
    return m_VerData.nup.majorVersion;
}

nn::Handle Util::GetMcuHandle()
{
    return m_McuSession;
}

u32 Util::GetBatteryRemain()
{
    u8 remain;
    mp_Mcu->GetBatteryRemain(&remain);
    return remain;
}

nn::cfg::CTR::CfgRegionCode Util::GetRegion()
{
    return m_Region;
}

const char* Util::GetRegionCodeA3()
{
    return nn::cfg::GetRegionCodeA3(m_Region);
}

void Util::GetVersionData(common::VerDef* version)
{
    *version = m_VerData;
}

u32 Util::GetRenderTarget(u32 target, bool flip)
{
    if(flip)
    {
        if(target == NN_GX_DISPLAY0)
        {
            return NN_GX_DISPLAY1;
        }
        else
        {
            return NN_GX_DISPLAY0;
        }
    }
    else
    {
        return target;
    }
}

nn::Result PrintNetworkSetting()
{
    nn::Result result;
    nn::ac::NetworkSetting networkSetting;
    result = nn::ac::LoadNetworkSetting(0, networkSetting);
    COMMON_LOGGER("SSID: %s\n", networkSetting.wireless.essidSecurity.ssid);
    COMMON_LOGGER("DNS : %d.%d.%d.%d\n",
            networkSetting.ip.dns[0][0], networkSetting.ip.dns[0][1],
            networkSetting.ip.dns[0][2], networkSetting.ip.dns[0][3]);
    return result;
}

nn::Result InitializeNetwork(void)
{
    nn::Result result;
    nn::ac::Config config;

    // 未初期化の時だけ初期化する
    if(!nn::ac::IsInitializedInternal())
    {
        result = nn::ac::InitializeInternal();
        COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
    }

    // 接続要求用のパラメータを作成
    result = nn::ac::CreateDefaultConfig(&config);
    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);

    // デバッグ用に接続テストを無効化
    nn::ac::DebugSetNetworkArea(&config, nn::ac::NETWORK_AREA_LAN);

    // 接続要求を発行
    result = nn::ac::ConnectWithoutEula(config);
    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);

    return nn::ResultSuccess();
}

nn::Result FinalizeNetwork(void)
{
    nn::Result result;

    // 接続要求用のパラメータを作成
    result = nn::ac::Close();
    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);

    result = nn::ac::FinalizeInternal();
    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);

    return nn::ResultSuccess();
}

}