#ifndef INCLUDED_BOBCAT_CLOCKTYPES_
#define INCLUDED_BOBCAT_CLOCKTYPES_

#include <chrono>

// assignning a later value to an earlier value is OK
// (minutes min = 1h -> min = 60
//
// nanoseconds      duration<int64_t, nano>         1ns
// microseconds     duration<int64_t, micro>        1us
// milliseconds     duration<int64_t, milli>        1ms
// seconds          duration<int64_t>               1s
// minutes          duration<int64_t, ratio<60>>    1min
// hours            duration<int64_t, ratio<3600>>  1h
//
//  members:    count()
//  static members: zero(), min(), max()
// 
// Duration types: =, -, +(=) -(=)

namespace FBB
{

using nanoseconds   = std::chrono::nanoseconds;
using microseconds  = std::chrono::microseconds;
using milliseconds  = std::chrono::milliseconds;
using seconds       = std::chrono::seconds;
using minutes       = std::chrono::minutes;
using hours         = std::chrono::hours;

template <typename Dest, typename Src>  // less precise to more precise
Dest toDuration(Src const &src);

template <typename Dest, typename Src>
auto toClock(Src const &src);

template <typename Dest, typename Src>
double toDouble(Src const &src);

struct ClockTypes
{
    using Duration = std::chrono::duration<int64_t, std::nano>;
    using Period = Duration::period;
    using DenType = decltype(Period::den);
    using NumType = decltype(Period::num);

    static Period period();                                 // .f
    static DenType den();                                   // .f
    static NumType num();                                   // .f
    static Duration zero();                                 // .f

    template <typename TimePoint>
    static Duration elapsed(TimePoint const &tp);

    template <typename TimePoint>
    static size_t count(TimePoint const &tp);
};

template <typename Dest, typename Src>
inline auto toClock(Src const &src)
{
    return std::chrono::clock_cast<typename Dest::ChronoClock>(
                                                            src.timePoint());
}

template <typename Dest, typename Src>
inline Dest toDuration(Src const &src)
{
    return std::chrono::duration_cast<Dest>(src);
}

template <typename Dest, typename Src>
inline double toDouble(Src const &src)
{
    return static_cast<double>(src.count()) * 
                            Dest::period::den * Src::period::num /
                            (Dest::period::num * Src::period::den);
}

// static
inline ClockTypes::Period ClockTypes::period()
{
    return Duration::period{};
}

// static
inline ClockTypes::NumType ClockTypes::den()
{
    return Period::den;
}

// static
inline ClockTypes::NumType ClockTypes::num()
{
    return Period::num;
}

// static
inline ClockTypes::Duration ClockTypes::zero()
{
    return Duration::zero();
}

// static 
template <typename TimePoint>
inline ClockTypes::Duration ClockTypes::elapsed(TimePoint const &tp)
{
    return tp.time_since_epoch();
}

// static 
template <typename TimePoint>
inline size_t ClockTypes::count(TimePoint const &tp)
{
    return elapsed(tp).count();
}


} // FBB        
#endif

