#include <assert.h>

#include <unistd.h>
#include <sys/time.h>
#include <sys/stat.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <memory.h>

#include <net/if.h>
#include <sys/ioctl.h>

#include <a8/a8.h>
#include <a8/sysutils.h>

namespace a8
{
    a8::tick_t XGetTickCount()
    {
        #if 1
        struct timeval tv;
        gettimeofday(&tv, NULL);
        long long time = tv.tv_usec;
        time /= 1000;
        time += (tv.tv_sec * 1000);
        return time;
        #else
        struct timespec ts;
        clock_gettime(CLOCK_MONOTONIC, &ts);
        return (ts.tv_sec*1000 + ts.tv_nsec/(1000*1000));
        #endif
    }

    long long XGetNanoSeconds()
    {
        struct timespec ts;
        clock_gettime(CLOCK_MONOTONIC, &ts);
        return (ts.tv_sec*1000000000 + ts.tv_nsec);
    }

    long long GetMilliSecond()
    {
        struct timeval tv;
        gettimeofday(&tv, NULL);
        long long time = tv.tv_usec;
        time /= 1000;
        time += (tv.tv_sec * 1000);
        return time;
    }

    int HashString(const std::string& str)
    {
        return 0;
    }

    a8::XValue Get(std::map<std::string, a8::XValue> &map, const char* key, const char* defval)
    {
        auto itr = map.find(std::string(key));
        return itr != map.end() ? itr->second : a8::XValue(defval);
    }

    int RandEx(int min, int max)
    {
        if (min == max) {
            return min;
        }

        if (min > max) {
            int tmp = min;
            min = max;
            max = tmp;
        }

        return min + std::max(0, rand() % (max - min + 1));
    }

    int GetRangeValue(int src_value, int min, int max)
    {
        if (src_value < min) {
            return min;
        }
        if (src_value > max) {
            return max;
        }
        return rand() % max;
    }

    void SetBitFlag(int& flag_bits, int bit)
    {
        flag_bits |= (int)1 << bit;
    }

    void UnSetBitFlag(int& flag_bits, int bit)
    {
        flag_bits &= ~((int)1 << bit);
    }

    bool HasBitFlag(const int& flag_bits, int bit)
    {
        return (flag_bits & ((int)1 << bit)) != 0;
    }

    void SetBitFlag(long long& flag_bits, int bit)
    {
        flag_bits |= (long long)1 << bit;
    }

    void UnSetBitFlag(long long& flag_bits, int bit)
    {
        flag_bits &= ~((long long)1 << bit);
    }

    bool HasBitFlag(const long long& flag_bits, int bit)
    {
        return (flag_bits & ((long long)1 << bit)) != 0;
    }

    bool SameBitFlag(long long a_flag_bits, long long b_flag_bits, int bit)
    {
        return HasBitFlag(a_flag_bits, bit) == HasBitFlag(b_flag_bits, bit);
    }

    void XPrintf(const char* fmt, std::initializer_list<a8::XValue> args)
    {
        time_t nowtime = time(nullptr);
        struct tm tm_nowtime = {0};
        struct tm *ptr = localtime_r(&nowtime, &tm_nowtime);
        char strtime[80];
        strftime(strtime, 80, "%F %T  ", ptr);

        std::string data;
        data.append((char*)strtime);
        data += a8::Format(fmt, args);

        printf("%s", data.c_str());
        fflush(stdout);
    }

    bool MkDir(const std::string& path)
    {
        if (access(path.c_str(), W_OK)  == 0) {
            return true;
        }
        int status = mkdir(path.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
        return status == 0;
    }

    void ForceCreateDir(const std::string& path)
    {
        if (access(path.c_str(), W_OK)  == 0) {
            return;
        }
        std::vector<std::string> strings;
        a8::Split(path, strings, '/');
        std::string cur_dir = "/";
        for (auto& tmp_str : strings) {
            cur_dir += tmp_str + "/";
            if (access(cur_dir.c_str(), W_OK) != 0) {
                a8::MkDir(cur_dir);
            }
        }
    }

    std::string GetIpAddress(unsigned long ip_saddr)
    {
        in_addr addr;
        memset(&addr, 0, sizeof(addr));
        addr.s_addr = ip_saddr;
        char buf[255];
        buf[0] = '\0';
        inet_ntop(AF_INET, &addr, buf, 255);
        return std::string(buf);
    }

    bool GetLocalIp(std::string& ip_address)
    {
        int sfd, intr;
        struct ifreq buf[16];
        struct ifconf ifc;
        sfd = ::socket(AF_INET, SOCK_DGRAM, 0);
        if (sfd < 0) {
            return false;
        }
        ifc.ifc_len = sizeof(buf);
        ifc.ifc_buf = (caddr_t)buf;
        if (::ioctl(sfd, SIOCGIFCONF, (char *)&ifc)) {
            return false;
        }
        intr = ifc.ifc_len / sizeof(struct ifreq);
        while (intr-- > 0 && ::ioctl(sfd, SIOCGIFADDR, (char *)&buf[intr]));
        ::close(sfd);
        ip_address = inet_ntoa(((struct sockaddr_in*)(&buf[intr].ifr_addr))-> sin_addr);
        return true;
    }

    std::string FormatDateTime(time_t time_val)
    {
        struct tm tm_time = {0};
        localtime_r(&time_val, &tm_time);

        char buff[256];
        buff[0] = '\0';
        strftime(buff, a8::ArraySize(buff), "%F %T", &tm_time);
        return std::string(buff);
    }

    std::string TimestampToDateTime(time_t time_val)
    {
        std::string datetime_str;
        {
            time_t nowtime = time_val;
            struct tm tm_time = {0};
            localtime_r(&nowtime, &tm_time);

            char buff[256];
            strftime(buff, a8::ArraySize(buff), "%F %T", &tm_time);
            datetime_str.append((char*)buff);
        }
        return datetime_str;
    }

    std::string TimestampToDate(time_t time_val)
    {
        std::string datetime_str;
        {
            time_t nowtime = time_val;
            struct tm tm_time = {0};
            localtime_r(&nowtime, &tm_time);

            char buff[256];
            strftime(buff, a8::ArraySize(buff), "%F", &tm_time);
            datetime_str.append((char*)buff);
        }
        return datetime_str;
    }

    time_t GetDaySeconds(time_t time_val, int incdays)
    {
        int g_time_zone = 8;
        return time_t((time_val + g_time_zone * 3600)/3600/24 + incdays) * 3600 * 24 - 3600 * g_time_zone;
    }

    time_t GetMondaySeconds(time_t time_val)
    {
        struct tm tm_time = {0};
        struct tm *ptr = localtime_r(&time_val, &tm_time);
        if (!ptr) {
            abort();
        }

        switch (tm_time.tm_wday) {
        case 1:
        case 2:
        case 3:
        case 4:
        case 5:
        case 6:
            return GetDaySeconds(time_val - (3600 * 24 * (tm_time.tm_wday - 1)));
            break;
        case 0:
            return GetDaySeconds(time_val - (3600 * 24 * 6));
            break;
        default:
            abort();
            return time_val;
        }
    }

    time_t BetweenDays(time_t time_val1, time_t time_val2)
    {
        int g_time_zone = 8;
        return (time_val1 + g_time_zone*3600)/3600/24 - (time_val2 + g_time_zone*3600)/3600/24;
    }

    time_t GetDateTimeSeconds(const char* datetime_str)
    {
        #if 0
        int g_time_zone = 8;
        #endif
        struct tm stm = {0};
        strptime(datetime_str, "%Y-%m-%d %H:%M:%S", &stm);
        long t = mktime(&stm);
        #if 1
        return t;
        #else
        return t + g_time_zone*3600;
        #endif
    }

    time_t GetTimeDaySeconds(const char* time_str)
    {
        struct tm stm = {0};
        char* p = strptime(time_str, "%Y-%m-%d %H:%M:%S", &stm);
        if (!p) {
            return -1;
        }
        long t = mktime(&stm);
        return GetDaySeconds(t);
    }

    long long MakeInt64(int low32, int high32)
    {
        return low32 + ((long long)high32 << 32);
    }

    int Low32(long long int64_val)
    {
        return (int)int64_val;
    }

    int High32(long long int64_val)
    {
        return (int)(int64_val >> 32);
    }

    int MkRgb(int red, int green, int blue)
    {
        return red | (green << 8) | (blue << 16) ;
    }

    float RandAngle()
    {
        float angle = 0.00001f + ((float)rand() / RAND_MAX) * 2.0f;
        return angle;
    }

    void ClearSendQueue(a8::SendQueueNode* node)
    {
        a8::SendQueueNode* tmp_node = node;
        while (tmp_node) {
            a8::SendQueueNode* pdelnode = tmp_node;
            tmp_node = pdelnode->next;
            if (pdelnode->buff) {
                free(pdelnode->buff);
            }
            free(pdelnode);
        }
    }

    void Abort()
    {
        abort();
    }

}