/*###############################################
 * 常用函数集合
 *
 *
 *
 *
 * ############################################*/

#include "toolkit.h"
#include <QDir>
#include <QFile>
#include <QFileInfo>
#include <QThread>
#include <QDebug>
#include <QDirIterator>
#include <QTextCodec>

bool isDirExist(const QString & fullDirName, bool Crt)
{
    QDir photo;
    bool exist = photo.exists(fullDirName);
    if (exist)
    {
        return true;
        //qDebug() << fullDirName << QString::fromLocal8Bit("::已存在");
    }
    else
    {
        //创建文件夹
        if(Crt)photo.mkdir(fullDirName);
        //qDebug() << fullDirName << QString::fromLocal8Bit("::不存在，创建");
    }
    return false;
}

bool isFileExist(const QString & fullFileName, bool Crt)
{
    QFile file(fullFileName);
    if (file.exists())
    {
        //qDebug() << fullFileName << QString::fromLocal8Bit("::已存在");
        return true;
    }
    if(Crt){
        if(file.open(QIODevice::WriteOnly)){
            //WriteOnly或ReadWrite当文件不存在时创建
            file.flush();
            file.close();
            //qDebug() << fullFileName << QString::fromLocal8Bit("::已创建");
        };
    }


    return false;
}

QString createMultipleFoldes(const QString &fullDirName)
{
    QString path=QDir::fromNativeSeparators(fullDirName);// 将\\转/
    QDir dir(path);
    if(dir.exists()){
       return dir.absolutePath();
    }
    QString parent=createMultipleFoldes(path.mid(0,path.lastIndexOf("/")));
    QString dirName=path.mid(path.lastIndexOf("/")+1);
    QDir parentPath(parent);
    if(!dirName.isEmpty()){
        parentPath.mkpath(dirName);
    }
    return parent+"/"+dirName;
}

QString GetTimeStamp(QString Stamp)
{
    QDateTime time = QDateTime::currentDateTime();
    QString times = time.toString(Stamp);
    return times;
}

bool QSetFileTimes(const QString & filepath, QDateTime& CreationTime)
{
    bool fing=true;
    if(!isFileExist(filepath))return false;
#if (QT_VERSION<QT_VERSION_CHECK(5,10,0))
    HANDLE hFile;
    //可输入中文路径
    hFile=CreateFileW(filepath.toStdWString().data(),GENERIC_READ|GENERIC_WRITE,FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,OPEN_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
    if(hFile!=NULL){
        FILETIME lpCreationTime; // 文件夹的创建时间
        //    FILETIME lpLastAccessTime; // 对文件夹的最近访问时间
        //    FILETIME lpLastWriteTime; // 文件夹的最近修改时间
        //    int i=GetFileTime (hFile, &lpCreationTime, &lpLastAccessTime, &lpLastWriteTime); // 获取文件夹时间属性信息
        //    SYSTEMTIME stc;
        //    FILETIME localTime;
        //    FileTimeToLocalFileTime(&lpCreatxionTime,&localTime);
        //    FileTimeToSystemTime(&localTime,&stc);//UTC转本地时间
        SYSTEMTIME newDay;
        newDay.wDayOfWeek=CreationTime.date().dayOfWeek();
        newDay.wMonth=CreationTime.date().month();
        newDay.wDay=CreationTime.date().day();
        newDay.wYear=CreationTime.date().year();
        newDay.wHour=CreationTime.time().hour();
        newDay.wMinute=CreationTime.time().minute();
        newDay.wSecond=CreationTime.time().second();
        newDay.wMilliseconds=CreationTime.time().msec();
        SystemTimeToFileTime(&newDay,&lpCreationTime);
        fing&=SetFileTime(hFile,&lpCreationTime,&lpCreationTime,&lpCreationTime);//输入UTC格式
        CloseHandle(hFile);//关闭句柄
    }
#else
    QFile file(filepath);
    if(file.open(QIODevice::ReadWrite)){
        fing&=file.setFileTime(CreationTime,QFileDevice::FileBirthTime);
        fing&=file.setFileTime(CreationTime,QFileDevice::FileAccessTime);
        fing&=file.setFileTime(CreationTime,QFileDevice::FileModificationTime);
        file.close();
    }else{
        fing=false;
    };
#endif
    return fing;
}


int QGetRandom(int max, int min, bool timeC)
{
    if(max-min<1)return -1;
    //秒级随机种子
    //qsrand(QTime(0, 0, 0).secsTo(QTime::currentTime()));
    if(timeC)QThread::msleep(1);
    //毫秒级随机种子
    QTime time= QTime::currentTime();
    qsrand(time.msec()+time.second()*1000);
    return min+qrand()%abs(max-min);
}

void deleteDirectory(const QString &fullFileName)
{

    QDir dir(fullFileName);
    if (!dir.exists()) {
        return;
    }

    dir.setFilter(QDir::AllEntries | QDir::NoDotAndDotDot);
    QFileInfoList fileList = dir.entryInfoList();

    foreach (QFileInfo fi, fileList) {
        if (fi.isFile()) {
            fi.dir().remove(fi.fileName());
        } else {
            deleteDirectory(fi.absoluteFilePath());
            dir.rmdir(fi.absoluteFilePath());
        }
    }


}

QStringList addNextDirectory(const QString &fullFileName, bool isDir,QString suffix)
{

    // 判断路径是否存在
    QDir dir(fullFileName);
    if(!dir.exists())
    {
        return QStringList();
    }
    dir.setFilter(QDir::Dirs | QDir::NoSymLinks);
    QFileInfoList list = dir.entryInfoList();

    int file_count = list.count();
    if(file_count <= 0)
    {
        return QStringList();
    }

    QStringList string_list;
    for(int i=0; i<file_count; i++)
    {
        QFileInfo file_info = list.at(i);
        if(file_info.fileName()=="."|file_info.fileName()=="..")continue;
        if(isDir){
            if(file_info.isDir()){
                QString absolute_file_path = file_info.absoluteFilePath();
                string_list.append(absolute_file_path);
            }
        }else{
            if(!suffix.isEmpty()){
                if(QString::compare(file_info.suffix(), QString(suffix), Qt::CaseInsensitive) != 0)
                    continue;
            }
            QString absolute_file_path = file_info.absoluteFilePath();
            string_list.append(absolute_file_path);
        }

    }
    return string_list;
}

QStringList addSubFolderDirectory(const QString &fullFileName, QStringList filters)
{

    // 判断路径是否存在
    QDir dir(fullFileName);
    if(!dir.exists())
    {
        return QStringList();
    }

    // 定义迭代器并设置过滤器
    QDirIterator dir_iterator(fullFileName,
        filters,
        QDir::Files | QDir::NoSymLinks,
        QDirIterator::Subdirectories);
    QStringList string_list;
    while(dir_iterator.hasNext())
    {
        dir_iterator.next();
        QFileInfo file_info = dir_iterator.fileInfo();
        QString absolute_file_path = file_info.absoluteFilePath();
        string_list.append(absolute_file_path);
    }
    return string_list;

}

void getAllFiles(std::string path, std::vector<std::string> &files, std::string format)
{
    intptr_t  hFile = 0;//文件句柄
    struct _finddata_t fileinfo;//文件信息
    std::string p;
    if ((hFile = _findfirst(p.assign(path).append("\\*" + format).c_str(), &fileinfo)) != -1) //文件存在
    {
        do
        {
            if ((fileinfo.attrib & _A_SUBDIR))//判断是否为文件夹
            {
                if (strcmp(fileinfo.name, ".") != 0 && strcmp(fileinfo.name, "..") != 0)//文件夹名中不含"."和".."
                {
                    files.push_back(p.assign(path).append("\\").append(fileinfo.name)); //保存文件夹名
                    getAllFiles(p.assign(path).append("\\").append(fileinfo.name), files, format); //递归遍历文件夹
                }
            }
            else
            {
                files.push_back(p.assign(path).append("\\").append(fileinfo.name));//如果不是文件夹，储存文件名
            }
        } while (_findnext(hFile, &fileinfo) == 0);
        _findclose(hFile);
    }
}


QJsonObject loadJsonCfg(const QString path)
{
    QJsonObject json_object;
    try
    {
        QJsonParseError jsonError;
        QString json_cfg = path;
        if (json_cfg.isEmpty())
        {
            qCritical() << " [error] " << __FUNCTION__ << " line:" << __LINE__ << " JsonPath is null!";
            return json_object;
        }

        QFile JsonFile;
        JsonFile.setFileName(json_cfg);
        JsonFile.open(QIODevice::ReadOnly);

        QByteArray m_Byte = JsonFile.readAll();
        if (m_Byte.isEmpty())
        {
            qDebug() << __FUNCTION__ << " line:" << __LINE__ << json_cfg + " Content is empty";
            JsonFile.close();
            return json_object;
        }

        QJsonDocument jsonDocument(QJsonDocument::fromJson(m_Byte, &jsonError));

        if (!jsonDocument.isNull() && jsonError.error == QJsonParseError::NoError)
        {
            if (jsonDocument.isObject())
            {
                json_object = jsonDocument.object();
                return json_object;
            }
        }
        else
        {
            qCritical() << " [error] " << __FUNCTION__ << " line:" << __LINE__ << json_cfg + " is error!";
        }

        JsonFile.close();

    }
    catch (QString ev)
    {
        qCritical() << " [error] " << __FUNCTION__ << " line:" << __LINE__ << " ev:" << ev;
    }
    return json_object;
}

QStringList ReadTextCfg(const QString path)
{

    QString csvpath = path;
    // 读取每日csv
    QStringList lines; //配置信息列表
    QFile configFile;
    configFile.setFileName(csvpath);
    bool isTxT = false;
    if (path.indexOf(".txt") != -1)isTxT = true;
    if (configFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
        QTextStream stream_text(&configFile);
        stream_text.setCodec(QTextCodec::codecForName("utf-8"));
        // //可读取中文
        stream_text.seek(0);
        while (!stream_text.atEnd())
        {

            lines.push_back(gb2312ToUtf8(stream_text.readLine()));
        }
    }
    else {
        qDebug() << "read csv " << csvpath << " failed!" << endl;
    }
    configFile.close();
    return lines;

}

bool WriteTXTCfg(const QStringList& parm,const QString path) {

    QString fileName = path;

    QFile file(fileName);

    if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
        return false;

    //用文本流读取文件
    QTextStream stream(&file);

    //转换为字符串

    for each (auto var in parm) {
        //写入文本流
        stream << var << endl;
    }
    //关闭文件
    file.close();
    return true;
}

EncodingFormat FileCharacterEncoding(const QString& fileName)
{
    //假定默认编码utf8
    EncodingFormat code = EncodingFormat::UTF8;

    QFile file(fileName);
    if (file.open(QIODevice::ReadOnly))
    {
        //读取3字节用于判断
        QByteArray buffer = file.read(3);
        quint8 sz1st = buffer.at(0);
        quint8 sz2nd = buffer.at(1);
        quint8 sz3rd = buffer.at(2);
        if (sz1st == 0xFF && sz2nd == 0xFE)
        {
            code = EncodingFormat::UTF16LE;
        }
        else if (sz1st == 0xFE && sz2nd == 0xFF)
        {
            code = EncodingFormat::UTF16BE;
        }
        else if (sz1st == 0xEF && sz2nd == 0xBB && sz3rd == 0xBF)
        {
            code = EncodingFormat::UTF8BOM;
        }
        else
        {
            //尝试用utf8转换,如果无效字符数大于0,则表示是ansi编码
            QTextCodec::ConverterState cs;
            QTextCodec* tc = QTextCodec::codecForName("utf-8");
            tc->toUnicode(buffer.constData(), buffer.size(), &cs);
            code = (cs.invalidChars > 0) ? EncodingFormat::ANSI : EncodingFormat::UTF8;
        }

        file.close();
    }

    return code;
}

QString gb2312ToUtf8(const QString strUtf8)
{
    //printf("~~~~ utf8  str is:%s\n", strUtf8);
    QTextCodec* utf8Codec = QTextCodec::codecForName("utf-8");
    QTextCodec* gb2312Codec = QTextCodec::codecForName("gb2312");

    QString strUnicode = gb2312Codec->toUnicode(strUtf8.toLocal8Bit().data());
    QByteArray ByteUtf8 = utf8Codec->fromUnicode(strUnicode);
    return ByteUtf8;
}