#include "Utils.h"
#include <string>      // std::string
#include <sstream>     // std::stringstream
#include <fstream>     // std::ifstream/ofstream
#include <algorithm>
#include <iostream>
#include <QTime>
#include <QCoreApplication>
#include <fstream>
#include <algorithm>
#include <iostream>
#include <QDebug>


std::string Utils::m_hexTable = "0123456789ABCDEF";


// 字符转16进制字符串，不适用于汉字字符
//std::string Utils::charToHexStr(unsigned char ch)
//{
//    const std::string hex = "0123456789ABCDEF";

//    std::stringstream ss;
//    ss << hex[ch >> 4] << hex[ch & 0xf];

//    return ss.str();
//}



// 字符串转十六进制字符串，可用于汉字字符串
// str : 待转换的字符串
// separator : 十六进制分隔符
//std::string Utils::strToHexStr(std::string str, std::string separator)
//{
//    const std::string hex = "0123456789ABCDEF";
//    std::stringstream ss;

////    int nSize = str.size();
////    int nLength = str.size();

//    for (std::string::size_type i = 0; i < str.size(); ++i)
//    {
//        ss << hex[(unsigned char)str[i] >> 4] << hex[(unsigned char)str[i] & 0xf] << separator;
//    }

//    return ss.str();
//}

// 字符转字符流
// char为1字节，按字节将数据存储到字符串中
std::string Utils::charToByteStr(unsigned char val)
{
    std::string s;
    s.append((char*)&val, 1);
    return s;
}

// 短整型转字符流
// short为2字节，按字节将数据存储到字符串中
std::string Utils::shortToByteStr(unsigned short val)
{
    std::string s;
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    s.append((char *)&val + 1, 1);
    s.append((char *)&val + 0, 1);
#else
    s.append((char *)&val + 0, 1);
    s.append((char *)&val + 1, 1);
#endif
    return s;
}

// 整型转字符流
// int为4字节，按字节将数据存储到字符串中
std::string Utils::intToByteStr(unsigned int val)
{
    std::string s;
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    s.append((char *)&val + 3, 1);
    s.append((char *)&val + 2, 1);
    s.append((char *)&val + 1, 1);
    s.append((char *)&val + 0, 1);
#else
    s.append((char *)&val + 0, 1);
    s.append((char *)&val + 1, 1);
    s.append((char *)&val + 2, 1);
    s.append((char *)&val + 3, 1);
#endif
    return s;
}

// byte字符串转字符
unsigned char Utils::byteStrToChar(std::string val)
{
    return (unsigned char)val.c_str()[0];
}

// byte字符串转短整型
unsigned short Utils::byteStrToShort(std::string val)
{
    unsigned short us = 0;
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    us = ((unsigned short)val.c_str()[0] << 8 & 0xFF00) + ((unsigned short)val.c_str()[1] << 0 & 0x00FF);
#else
    us = ((unsigned short)val.c_str()[0] << 0 & 0x00FF) + ((unsigned short)val.c_str()[1] << 8 & 0xFF00);
#endif
    return us;
}

// c1,c2为按顺序的两个字节
unsigned short Utils::charToShort(unsigned char c1, unsigned char c2)
{
    unsigned short us = 0;
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    us = ((unsigned short)c1 << 8 & 0xFF00) + ((unsigned short)c2 << 0 & 0x00FF);
#else
    us = ((unsigned short)c1 << 0 & 0x00FF) + ((unsigned short)c2 << 8 & 0xFF00);
#endif
    return us;
}


// byte字符串转整形
unsigned int Utils::byteStrToInt(std::string val)
{
    unsigned int ui = 0;
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
//    unsigned int a = (unsigned int)val.c_str()[0] << 24;
//    unsigned int b = (unsigned int)val.c_str()[1] << 16;
//    unsigned int c = (unsigned int)val.c_str()[2] << 8;
//    unsigned int d = (unsigned int)val.c_str()[3] << 0;
    ui = ((unsigned int)val.c_str()[0] << 24 & 0xFF000000)  +
         ((unsigned int)val.c_str()[1] << 16 & 0x00FF0000)  +
         ((unsigned int)val.c_str()[2] <<  8 & 0x0000FF00)  +
         ((unsigned int)val.c_str()[3] <<  0 & 0x000000FF) ;
#else
    ui = ((unsigned int)val.c_str()[0] <<  0 & 0x000000FF) +
         ((unsigned int)val.c_str()[1] <<  8 & 0x0000FF00) +
         ((unsigned int)val.c_str()[2] << 16 & 0x00FF0000) +
         ((unsigned int)val.c_str()[3] << 24 & 0xFF000000);
#endif
    return ui;
}



//std::string Utils::charToHexStr(const unsigned char& c)
//{
//    std::string hexStr;
//    hexStr.reserve(2);
//    hexStr.push_back(m_hexTable.at((c >> 4) & 0x0F));
//    hexStr.push_back(m_hexTable.at((c >> 0) & 0x0F));
//    return hexStr;
//}
//std::string Utils::ucharToHexStr(const unsigned char& c)
//{
//    static const char* lut = "0123456789ABCDEF";
//    std::string hexStr;
//    hexStr.reserve(2);
//    hexStr.push_back(lut[(c >> 4) & 0x0F]);
//    hexStr.push_back(lut[(c >> 0) & 0x0F]);
//    return hexStr;
//}

std::string Utils::strToHexStr(const std::string& str)
{
    static const char* lut = "0123456789ABCDEF";
    std::string hexStr;
    size_t len = str.length();
    hexStr.reserve(2 * len);
    for(size_t i=0; i<len; i++)
    {
        const unsigned c = str[i];
        hexStr.push_back(lut[(c >> 4) & 0x0F]);
        hexStr.push_back(lut[(c >> 0) & 0x0F]);
    }
    return hexStr;
}



std::string Utils::hexStrToStr(const std::string& hexStr)
{
    static const char* const lut = "0123456789ABCDEF";
    size_t len = hexStr.length();
    if (len & 1)
    {
        throw std::invalid_argument("odd length");
    }

    std::string str;
    str.reserve(len / 2);
    for (size_t i = 0; i < len; i += 2)
    {
        char a = hexStr[i];
        const char* p = std::lower_bound(lut, lut + 16, a);
        if (*p != a)
        {
            throw std::invalid_argument("not a hex digit");
        }

        char b = hexStr[i + 1];
        const char* q = std::lower_bound(lut, lut + 16, b);
        if (*q != b)
        {
            throw std::invalid_argument("not a hex digit");
        }

        str.push_back(((char)(p - lut) << 4) | (char)(q - lut));
    }
    return str;
}

std::string Utils::ucharToStr(const unsigned char& val)
{
    std::string s;
    s.append((char *)&val, 1);
    return s;
}

std::string Utils::ushortToStr(const unsigned short& val)
{
    std::string s;
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    s.append((char *)&val + 1, 1);
    s.append((char *)&val + 0, 1);
#else
    s.append((char *)&val + 0, 1);
    s.append((char *)&val + 1, 1);
#endif
    return s;
}

std::string Utils::uintToStr(const unsigned int& val)
{
    std::string s;
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    s.append((char *)&val + 3, 1);
    s.append((char *)&val + 2, 1);
    s.append((char *)&val + 1, 1);
    s.append((char *)&val + 0, 1);
#else
    s.append((char *)&val + 0, 1);
    s.append((char *)&val + 1, 1);
    s.append((char *)&val + 2, 1);
    s.append((char *)&val + 3, 1);
#endif
    return s;
}

std::string Utils::ulongToStr(const unsigned long& val)
{
    std::string s;
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    s.append((char *)&val + 3, 1);
    s.append((char *)&val + 2, 1);
    s.append((char *)&val + 1, 1);
    s.append((char *)&val + 0, 1);
#else
    s.append((char *)&val + 0, 1);
    s.append((char *)&val + 1, 1);
    s.append((char *)&val + 2, 1);
    s.append((char *)&val + 3, 1);
#endif
    return s;
}

std::string Utils::charToStr(const char& val)
{
    std::string s;
    s.append(&val, 1);
    return s;
}

std::string Utils::shortToStr(const short& val)
{
    std::string s;
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    s.append((char *)&val + 1, 1);
    s.append((char *)&val + 0, 1);
#else
    s.append((char *)&val + 0, 1);
    s.append((char *)&val + 1, 1);
#endif
    return s;
}

std::string Utils::intToStr(const int& val)
{
    std::string s;
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    s.append((char *)&val + 3, 1);
    s.append((char *)&val + 2, 1);
    s.append((char *)&val + 1, 1);
    s.append((char *)&val + 0, 1);
#else
    s.append((char *)&val + 0, 1);
    s.append((char *)&val + 1, 1);
    s.append((char *)&val + 2, 1);
    s.append((char *)&val + 3, 1);
#endif
    return s;
}

std::string Utils::longToStr(const long& val)
{
    std::string s;
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    s.append((char *)&val + 3, 1);
    s.append((char *)&val + 2, 1);
    s.append((char *)&val + 1, 1);
    s.append((char *)&val + 0, 1);
#else
    s.append((char *)&val + 0, 1);
    s.append((char *)&val + 1, 1);
    s.append((char *)&val + 2, 1);
    s.append((char *)&val + 3, 1);
#endif
    return s;
}

unsigned char Utils::strToUchar(const std::string& str)
{
    unsigned char val;
    val = str.at(0);
    return val;
}

unsigned short Utils::strToUshort(const std::string& str)
{
    unsigned short val;
    if(str.length() < sizeof(unsigned short))
    {
        throw std::invalid_argument("length not enough");
    }
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    ((char *)&val)[0] = str.at(1);
    ((char *)&val)[1] = str.at(0);
#else
    ((char *)&val)[0] = str.at(0);
    ((char *)&val)[1] = str.at(1);
#endif
    return val;
}

unsigned int Utils::strToUint(const std::string& str)
{
    unsigned int val;
    if(str.length() < sizeof(unsigned int))
    {
        throw std::invalid_argument("length not enough");
    }
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    ((char *)&val)[0] = str.at(3);
    ((char *)&val)[1] = str.at(2);
    ((char *)&val)[2] = str.at(1);
    ((char *)&val)[3] = str.at(0);
#else
    ((char *)&val)[0] = str.at(0);
    ((char *)&val)[1] = str.at(1);
    ((char *)&val)[2] = str.at(2);
    ((char *)&val)[3] = str.at(3);
#endif
    return val;
}

unsigned long Utils::strToUlong(const std::string& str)
{
    unsigned long val;
    if(str.length() < sizeof(unsigned long))
    {
        throw std::invalid_argument("length not enough");
    }
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    ((char *)&val)[0] = str.at(3);
    ((char *)&val)[1] = str.at(2);
    ((char *)&val)[2] = str.at(1);
    ((char *)&val)[3] = str.at(0);
#else
    ((char *)&val)[0] = str.at(0);
    ((char *)&val)[1] = str.at(1);
    ((char *)&val)[2] = str.at(2);
    ((char *)&val)[3] = str.at(3);
#endif
    return val;
}

char Utils::strToChar(const std::string& str)
{
    char val;
    val = str.at(0);
    return val;
}

short Utils::strToShort(const std::string& str)
{
    short val;
    if(str.length() < sizeof(short))
    {
        throw std::invalid_argument("length not enough");
    }
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    ((char *)&val)[0] = str.at(1);
    ((char *)&val)[1] = str.at(0);
#else
    ((char *)&val)[0] = str.at(0);
    ((char *)&val)[1] = str.at(1);
#endif
    return val;
}

int Utils::strToInt(const std::string& str)
{
    int val;
    if(str.length() < sizeof(int))
    {
        throw std::invalid_argument("length not enough");
    }
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    ((char *)&val)[0] = str.at(3);
    ((char *)&val)[1] = str.at(2);
    ((char *)&val)[2] = str.at(1);
    ((char *)&val)[3] = str.at(0);
#else
    ((char *)&val)[0] = str.at(0);
    ((char *)&val)[1] = str.at(1);
    ((char *)&val)[2] = str.at(2);
    ((char *)&val)[3] = str.at(3);
#endif
    return val;
}

long Utils::strToLong(const std::string& str)
{
    long val;
    if(str.length() < sizeof(long))
    {
        throw std::invalid_argument("length not enough");
    }
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    ((char *)&val)[0] = str.at(3);
    ((char *)&val)[1] = str.at(2);
    ((char *)&val)[2] = str.at(1);
    ((char *)&val)[3] = str.at(0);
#else
    ((char *)&val)[0] = str.at(0);
    ((char *)&val)[1] = str.at(1);
    ((char *)&val)[2] = str.at(2);
    ((char *)&val)[3] = str.at(3);
#endif
    return val;
}

void Utils::testTransOfTypeAndStr()
{
    unsigned char ucA = 0x12;
    std::string sucB = Utils::ucharToStr(ucA);
    unsigned char ucC = Utils::strToUchar(sucB);
    qDebug() << "testTransOfTypeAndStr : uchar -> " << (ucA == ucC);

    unsigned short usA = 0x1234;
    std::string susB = Utils::ushortToStr(usA);
    unsigned short usC = Utils::strToUshort(susB);
    qDebug() << "testTransOfTypeAndStr : ushort -> " << (usA == usC);

    unsigned int uiA = 0x12345678;
    std::string suiB = Utils::uintToStr(uiA);
    unsigned int uiC = Utils::strToUint(suiB);
    qDebug() << "testTransOfTypeAndStr : uint -> " << (uiA == uiC);

    unsigned long ulA = 0x87654321;
    std::string sulB = Utils::uintToStr(ulA);
    unsigned long ulC = Utils::strToUint(sulB);
    qDebug() << "testTransOfTypeAndStr : ulong -> " << (ulA == ulC);
}




// 判断字节序是大端序还是小端序,默认小端序
// 对于int a = 1，如果a的内存分布为：
// 00  00  00  01  则为大端序
// 01  00  00  00  则为小端序
// 低地址---->高地址
int Utils::byteOrder()
{
    union
    {
        short value;
        char union_bytes[sizeof(short)];
    } test;
    test.value=0x0102;
    if((test.union_bytes[0] == 1) && (test.union_bytes[1] == 2))
    {
        return BIG_ENDIA;
    }
    else if((test.union_bytes[0] == 2) && (test.union_bytes[1] == 1))
    {
        return LITTLE_ENDIA;
    }

    return LITTLE_ENDIA;
}


//
// 不阻塞的延时
//
void Utils::Sleep(int msec)
{
    QTime dieTime = QTime::currentTime().addMSecs(msec);
    while( QTime::currentTime() < dieTime )
        QCoreApplication::processEvents(QEventLoop::AllEvents, 100);
}

std::string Utils::readFile(const std::string& fileName)
{
    std::ifstream ifile;
    std::string str;

    ifile.open(fileName);
    ifile >> str;
    ifile.close();

    return str;
}

void Utils::writeFile(const std::string& fileName, const std::string& content)
{
    std::ofstream ofile;
    ofile.open(fileName);
    ofile << content;
    ofile.close();
}