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

  Copyright (C)2009 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: 23838 $
 *---------------------------------------------------------------------------*/

#include <nn/srv.h>
#include <nn/util.h>
#include <nn/ndm/CTR/ndm_Types.h>
#include <nn/ndm/ndm_Result.h>
#include <nn/ndm/ndm_UserControl.h>
#include <nn/ndm/CTR/ndm_Interface.h>
#include <nn/os/os_CriticalSection.h>
#include <nn/dbg/dbg_PrintResult.h>

#include "ndm_LibraryPrivate.h"

NN_DBG_DECLARE_GET_RESULT_DESCRIPTION_STRING_IMPL_KEEPER(ndm)

namespace {

    s32                     s_InitializedCount = 0;
    nn::os::CriticalSection s_cs = nn::WithInitialize();
}

namespace nn {
namespace ndm {
    using namespace CTR;
    using namespace CTR::detail;

Result Initialize(void)
{
    nn::os::CriticalSection::ScopedLock locker(s_cs);
    Result result;

    NN_DBG_USE_GET_RESULT_DESCRIPTION_STRING_IMPL_KEEPER(ndm);

    if (s_InitializedCount == 0)
    {
        nn::srv::Initialize();

#ifndef NN_NDM_STUB
        result = nn::srv::GetServiceHandle(&Interface::s_Session, PORT_NAME_USER);
        NN_UTIL_RETURN_IF_FAILED(result);
#else
        NN_LOG_WARN("stub mode.");
#endif
    }
    ++s_InitializedCount;
    return ResultSuccess();
}

Result Finalize()
{
    nn::os::CriticalSection::ScopedLock locker(s_cs);
    Result result;

    if (s_InitializedCount == 0)
    {
        NN_LOG_WARN("ndm library is not initialized.");
        return ResultNotInitialized();
    }
    else if (s_InitializedCount == 1)
    {
#ifndef NN_NDM_STUB
        result = nn::svc::CloseHandle(Interface::s_Session);
        NN_UTIL_RETURN_IF_FAILED(result);
#endif

        CTR::detail::Interface::s_Session = Handle();
    }
    --s_InitializedCount;
    return ResultSuccess();
}

bool IsInitialized(void)
{
    return s_InitializedCount > 0;
}

Result EnterExclusiveState(ExclusiveMode mode)
{
#ifndef NN_NDM_STUB
    return Interface::EnterExclusiveState(static_cast<s32>(mode));
#else
NN_UNUSED_VAR(mode);
    return ResultSuccess();
#endif
}

Result QueryExclusiveMode(ExclusiveMode& mode)
{
#ifndef NN_NDM_STUB
    s32 modeNumber;
    Result result = Interface::QueryExclusiveMode(&modeNumber);
    NN_UTIL_RETURN_IF_FAILED(result);
    mode = static_cast<ExclusiveMode>(modeNumber);
#else
    mode = ndm::EM_NONE;
#endif
    return ResultSuccess();
}

Result LeaveExclusiveState(void)
{
#ifndef NN_NDM_STUB
    return Interface::LeaveExclusiveState();
#else
    return ResultSuccess();
#endif
}

Result LockState(void)
{
#ifndef NN_NDM_STUB
    return Interface::LockState();
#else
    return ResultSuccess();
#endif
}

Result UnlockState(void)
{
#ifndef NN_NDM_STUB
    return Interface::UnlockState();
#else
    return ResultSuccess();
#endif
}

Result SuspendDaemons(bit32 mask)
{
#ifndef NN_NDM_STUB
    return Interface::SuspendDaemons(mask);
#else
    NN_UNUSED_VAR(mask);
    return ResultSuccess();
#endif
}

Result ResumeDaemons(bit32 mask)
{
#ifndef NN_NDM_STUB
    return Interface::ResumeDaemons(mask);
#else
    NN_UNUSED_VAR(mask);
    return ResultSuccess();
#endif
}

Result Suspend(DaemonName name)
{
    if (name < 0 || name >= NUM_OF_DAEMONS)
    {
        return ResultInvalidEnumValue();
    }
    return SuspendDaemons(1 << name);
}

Result Resume(DaemonName name)
{
    if (name < 0 || name >= NUM_OF_DAEMONS)
    {
        return ResultInvalidEnumValue();
    }
    return ResumeDaemons(1 << name);
}

Result SuspendScheduler(bool bAsync)
{
#ifndef NN_NDM_STUB
    return Interface::SuspendScheduler(bAsync);
#else
    NN_UNUSED_VAR(bAsync);
    return ResultSuccess();
#endif
}

Result ResumeScheduler(void)
{
#ifndef NN_NDM_STUB
    return Interface::ResumeScheduler();
#else
    return ResultSuccess();
#endif
}

} // end of namespace ndm
} // end of namespace nn