#ifndef A8_SYSUTILS_H
#define A8_SYSUTILS_H

namespace a8
{

    a8::tick_t XGetTickCount();
    long long XGetNanoSeconds();
    long long GetMilliSecond();

    template <class T>
    inline int ArraySize(T& array)
    {
        return (sizeof(array) / sizeof(array[0]));
    }

    int HashString(const std::string& str);

    template <typename T>
    T Get(std::vector<T> &vector_t, unsigned int idx, const T& defval)
    {
        if(idx < vector_t.size()){
            return vector_t[idx];
        }else{
            return defval;
        }
    }

    a8::XValue Get(std::map<std::string, a8::XValue> &map, const char* key, const char* defval=nullptr);

    template <typename T>
    T& FastAppend(std::vector<T>& t)
    {
        t.emplace_back();
        return t.back();
    }

    template <typename T>
    T& FastAppend(std::list<T>& t)
    {
        t.emplace_back();
        return t.back();
    }

    template <typename T>
    const T& Clamp(const T& v, const T& lo, const T& hi)
    {
        return v < hi ? (v > lo ? v : lo) : hi;
    }

    template <typename T>
    float LengthSqr(const T& v)
    {
        return v.x * v.x + v.y * v.y;
    }

    template <typename T>
    void SetToVector(std::set<T>& set_v, std::vector<T>& vector_v)
    {
        vector_v.reserve(set_v.size());
        for (auto& v : set_v) {
            vector_v.push_back(v);
        }
    }

    int RandEx(int min, int max);
    int GetRangeValue(int src_value, int min, int max);
    void SetBitFlag(int& flag_bits, int bit);
    void UnSetBitFlag(int& flag_bits, int bit);
    bool HasBitFlag(const int& flag_bits, int bit);
    void SetBitFlag(long long& flag_bits, int bit);
    void UnSetBitFlag(long long& flag_bits, int bit);
    bool HasBitFlag(const long long& flag_bits, int bit);
    void XPrintf(const char* fmt, std::initializer_list<a8::XValue> args);
    bool MkDir(const std::string& path);
    void ForceCreateDir(const std::string& path);
    std::string GetIpAddress(unsigned long ip_saddr);

    std::string FormatDateTime(time_t time_val);
    std::string TimestampToDateTime(time_t time_val);
    std::string TimestampToDate(time_t time_val);
    time_t GetDaySeconds(time_t time_val, int incdays = 0);
    time_t GetMondaySeconds(time_t time_val);
    time_t BetweenDays(time_t time_val1, time_t time_val2);
    time_t GetDateTimeSeconds(const char* datetime_str);
    time_t GetTimeDaySeconds(const char* time_str);

    long long MakeInt64(int low32, int high32);
    int Low32(long long int64_val);
    int High32(long long int64_val);

    int MkRgb(int red, int green, int blue);

    float RandAngle();

    void ClearSendQueue(a8::SendQueueNode* node);
}

#endif