/*---------------------------------------------------------------------------*
  Project:  Horizon
  File:     os_Tick.h

  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: 23609 $
 *---------------------------------------------------------------------------*/

/*! @file
    @brief      Tick に関する API の宣言

    :include nn/os.h
*/

#ifndef NN_OS_OS_TICK_H_
#define NN_OS_OS_TICK_H_

#include <nn/svc.h>
#include <nn/os/os_HardwareParamsSelect.h>
#include <nn/fnd/fnd_TimeSpan.h>
#include <nn/math/math_Misccellaneous.h>

#ifdef __cplusplus

namespace nn { namespace os {

/*!
    @brief システムチックを扱う為のクラスです。

           システムチックは、CPU の 1 クロックの時間を表します。
           変換コンストラクタ・変換演算子を使うことで、実際の時間を表す @ref nn::fnd::TimeSpan との相互変換ができます。
           システムが立ち上がってからのチック数を取得するには @ref GetSystemCurrent を使います。

*/
class Tick
{
public:

    /*!
        @brief チック数を取ってオブジェクトを初期化するコンストラクタです。

        @param[in] tick チック数
    */
    explicit Tick(s64 tick = 0) : m_Tick(tick) {}

    /*!
        @brief TimeSpan を取ってオブジェクトを初期化するコンストラクタです。

        @param[in] span 初期化する時間の値
    */
    Tick(nn::fnd::TimeSpan span);

    /*!
        @brief 64bit のチック値に変換します。
    */
    operator s64() const { return m_Tick; }

    /*!
        @brief @ref nn::fnd::TimeSpan の値に変換します。
    */
    operator nn::fnd::TimeSpan() const;

    /*!
        @brief @ref nn::fnd::TimeSpan の値に変換します。

        @return チックと同じ時間を表す @ref nn::fnd::TimeSpan オブジェクトを返します。
    */
    nn::fnd::TimeSpan ToTimeSpan() const;

    /*!
        @brief      システムが起動してからのチック数を返します。

        @return     システムの Tick 値。
    */
    static Tick GetSystemCurrent();

    /*!
        @brief 1秒間のチック数を表す定数です。
    */
    static const s64 TICKS_PER_SECOND  = NN_HW_TICKS_PER_SECOND;

    Tick& operator-=(Tick rhs) { this->m_Tick -= rhs.m_Tick; return *this; }
    Tick operator-(Tick rhs) const { Tick ret(*this); return ret -= rhs; }

    Tick& operator+=(Tick rhs) { this->m_Tick += rhs.m_Tick; return *this; }
    Tick operator+(Tick rhs) const { Tick ret(*this); return ret += rhs; }

    inline Tick& operator+=(fnd::TimeSpan rhs);
    Tick operator+(fnd::TimeSpan rhs) const { Tick ret(*this); return ret += rhs; }

private:
    s64 m_Tick;
};


inline Tick Tick::GetSystemCurrent()
{
    return Tick(nn::svc::GetSystemTick());
}

inline Tick::Tick(nn::fnd::TimeSpan span) : m_Tick(nnmathMultiplyAndDivide(span.GetNanoSeconds(), TICKS_PER_SECOND, 1000 * 1000 * 1000))
{
}

inline Tick::operator nn::fnd::TimeSpan() const
{
    return nn::fnd::TimeSpan::FromNanoSeconds(nnmathMultiplyAndDivide(m_Tick, 1000 * 1000 * 1000, TICKS_PER_SECOND));
}

inline nn::fnd::TimeSpan Tick::ToTimeSpan() const
{
    return *this;
}

inline Tick& Tick::operator+=(fnd::TimeSpan rhs)
{
    const s64 tick = nnmathMultiplyAndDivide(rhs.GetNanoSeconds(), TICKS_PER_SECOND, 1000 * 1000 * 1000);
    this->m_Tick += tick;
    return *this;
}

}}

#endif // __cplusplus

// 以下、C 用宣言

#include <nn/util/detail/util_CLibImpl.h>

/*!
  @addtogroup   nn_os
  @{

  @defgroup     nn_os_Tick_c     Tick (C)

  @brief        @ref nn::os::Tick の C インタフェースモジュールです。

  @{
*/

/*!
    @brief      ナノ秒から Tick 値へ変換します。

    @param[in]  ns        変換元の値（ナノ秒）

    @return     変換の結果を Tick 値で返します。
*/
NN_EXTERN_C inline s64 nnosTickConvertFromNanoSeconds(s64 ns)
{
    return nnmathMultiplyAndDivide(ns, NN_HW_TICKS_PER_SECOND, 1000 * 1000 * 1000);
}

/*!
    @brief      マイクロ秒から Tick 値へ変換します。

    @param[in]  us        変換元の値（マイクロ秒）

    @return     変換の結果を Tick 値で返します。
*/
NN_EXTERN_C inline s64 nnosTickConvertFromMicroSeconds(s64 us)
{
    return nnmathMultiplyAndDivide(us, NN_HW_TICKS_PER_SECOND, 1000 * 1000);
}

/*!
    @brief      ミリ秒から Tick 値へ変換します。

    @param[in]  ms        変換元の値（ミリ秒）

    @return     変換の結果を Tick 値で返します。
*/
NN_EXTERN_C inline s64 nnosTickConvertFromMilliSeconds(s64  ms)
{
    return nnmathMultiplyAndDivide(ms, NN_HW_TICKS_PER_SECOND, 1000);
}

/*!
    @brief      秒から Tick 値へ変換します。

    @param[in]  s         変換元の値（秒）

    @return     変換の結果を Tick 値で返します。
*/
NN_EXTERN_C inline s64 nnosTickConvertFromSeconds(s64 s)
{
    return nnmathMultiplyAndDivide(s, NN_HW_TICKS_PER_SECOND, 1);
}

/*!
    @brief      Tick 値をナノ秒へ変換します。

    @param[in]  tick      変換元のTick 値

    @return     変換の結果を ナノ秒で返します。
*/
NN_EXTERN_C inline s64 nnosTickConvertToNanoSeconds(s64 tick)
{
    return nnmathMultiplyAndDivide(tick, 1000 * 1000 * 1000, NN_HW_TICKS_PER_SECOND);
}

/*!
    @brief      Tick 値をマイクロ秒へ変換します。

    @param[in]  tick      変換元のTick 値

    @return     変換の結果を マイクロ秒で返します。
*/
NN_EXTERN_C inline s64 nnosTickConvertToMicroSeconds(s64 tick)
{
    return nnmathMultiplyAndDivide(tick, 1000 * 1000, NN_HW_TICKS_PER_SECOND);
}

/*!
    @brief      Tick 値をミリ秒へ変換します。

    @param[in]  tick      変換元のTick 値

    @return     変換の結果をミリ秒で返します。
*/
NN_EXTERN_C inline s64 nnosTickConvertToMilliSeconds(s64 tick)
{
    return nnmathMultiplyAndDivide(tick, 1000, NN_HW_TICKS_PER_SECOND);
}

/*!
    @brief      Tick 値を秒へ変換します。

    @param[in]  tick      変換元のTick 値

    @return     変換の結果を秒で返します。
*/
NN_EXTERN_C inline s64 nnosTickConvertToSeconds(s64 tick)
{
    return nnmathMultiplyAndDivide(tick, 1, NN_HW_TICKS_PER_SECOND);
}

/*!
  @brief 対応する C++ 関数 @ref nn::os::Tick::GetSystemCurrent を参照してください。
*/
NN_EXTERN_C s64 nnosTickGetSystemCurrent(void);

/*!
  @}

  @}
*/

#endif /* NN_OS_OS_TICK_H_ */