#include "SQLHelper.h"
#include <QSqlQuery>
#include <QSqlDatabase>
#include <QSqlQuery>
#include <QSqlError>
#include <QSqlRecord>
#include <qdebug.h>
QSqlDatabase* SQLHelper::defaultDatabase= nullptr;
static QHash<QString,QSqlQueryModel*> cache;
bool SQLHelper::Open() {
    if (defaultDatabase) return true;
    // defaultDatabase=  new QSqlDatabase(QSqlDatabase::addDatabase("QSQLITE", "USCTDB"));
    // defaultDatabase->setDatabaseName("USCTDB.data");
    defaultDatabase = new QSqlDatabase(QSqlDatabase::addDatabase("QMYSQL"));
    defaultDatabase->setHostName("localhost");  // 数据库服务器地址
    defaultDatabase->setPort(3306);  // 数据库名称
    defaultDatabase->setDatabaseName("USCT");  // 数据库名称
    defaultDatabase->setUserName("rc");  // 数据库用户名
    defaultDatabase->setPassword("123$%^");  // 数据库密码
    bool ret = defaultDatabase->open();
    if (!ret){
        delete defaultDatabase;
        defaultDatabase = nullptr;
    }
    return ret;
}

bool SQLHelper::Open(QSqlDatabase *base) {
    if(base && base != defaultDatabase){
        defaultDatabase = base;
    }
    return defaultDatabase->open();
}

void SQLHelper::Close() {
    for(auto item : cache.values())
    {
        delete item;
    }
    cache.clear();
    if(defaultDatabase->isValid() && defaultDatabase->isOpen())
    {
        defaultDatabase->close();
        delete defaultDatabase;
        defaultDatabase = nullptr;
    }
}

void prepareSQL(QSqlQuery& query,const QMap<QString,QVariant>& params)
{
    if (params.empty()) return;
    for (const auto & key : params.keys())
    {
        query.bindValue(key,params.value(key));
    }
}


QSqlTableModel* SQLHelper::getTable(const QString &tableName) {
    if (cache.contains(tableName)) return (QSqlTableModel*)cache[tableName];
    CenterAlignSqlTableModel *model = new CenterAlignSqlTableModel(nullptr,*defaultDatabase);
    model->setTable(tableName);
    cache[tableName] = model;
    return (QSqlTableModel*)(cache)[tableName];
}

int SQLHelper::QueryCount(const QString& sql, const QMap<QString,QVariant>& params) {
    QSqlQuery query(*defaultDatabase);
    prepareSQL(query, params);
    if (query.exec(sql))
    {
        query.last();
        return query.at()+1;
    }
    return 0;
}

int SQLHelper::ExecuteNoQuery(const QString& sql, const QMap<QString,QVariant>& params) {
    QSqlQuery query(*defaultDatabase);
    query.prepare(sql);
    prepareSQL(query, params);
    if (query.exec())
    {
        return query.numRowsAffected();
    }
    return 0;
}

void SQLHelper::QueryFirst(const QString &sql, QMap<QString,QVariant>& result, const QMap<QString,QVariant>& params) {
    QSqlQuery query(*defaultDatabase);
    query.prepare(sql);
    prepareSQL(query, params);
    if (query.exec())
    {
        if(query.next())
        {
            for(int i=0; i<query.record().count(); i++)
            {
                result[query.record().fieldName(i)]=query.record().value(i);
            }
        }
    }
}

QSqlQueryModel *SQLHelper::QueryModel(const QString& queryName, const QString& sql, const QMap<QString, QVariant> &params) {
    if (cache.contains(queryName)) return cache[queryName];
    QSqlQueryModel* model = new QSqlQueryModel;

    QSqlQuery query(*defaultDatabase);
    query.prepare(sql);
    prepareSQL(query, params);
    model->setQuery(query);
    if (model->lastError().isValid()){
        qDebug() << model->lastError();
        delete model;
        return nullptr;
    }
    cache[queryName] = model;
    return model;
}

QSqlQueryModel *SQLHelper::QueryModel(const QString& queryName) {
    if (cache.contains(queryName)) return cache[queryName];
    return nullptr;
}

void SQLHelper::QueryMap(const QString& sql, QMap<QString, QVariant> &result, const QMap<QString, QVariant> &params) {
    QSqlQuery query(*defaultDatabase);
    query.prepare(sql);
    prepareSQL(query, params);
    if (query.exec())
    {
        while(query.next())
        {
            result[query.record().value(0).toString()]=query.record().value(1);
        }
    }
}

bool SQLHelper::exec(const QString& aSql)
{
    QSqlQuery query(*defaultDatabase);
    bool result = query.exec(aSql);
    if(!result)
    {
        qDebug() << query.lastError().text();
    }
    return result;
}

QVariant SQLHelper::queryValue(const QString& aSql)
{
    QSqlQuery query(*defaultDatabase);
    if (!query.exec(aSql))
    {
        qDebug()<<query.lastError().text();
        return QVariant();
    }
    if(query.next())
    {
        return query.value(0);
    }

    return QVariant();
}

QList<QVariant> SQLHelper::queryValues(const QString& aSql)
{
    QList<QVariant> result;
    QSqlQuery query(*defaultDatabase);
    if (!query.exec(aSql))
    {
        qDebug()<<query.lastError().text();
        return QList<QVariant>();
    }

    while(query.next())
    {
        QList<QVariant> record;
        for(int i=0 ; i<query.record().count(); ++i)
        {
            record.append(query.value(i));
        }
        result.append(QVariant::fromValue(record));
    }

    return result;
}