#include "ruoyidatamanager.h"
#include <QNetworkAccessManager>
#include <QNetworkRequest>
#include <QUrlQuery>
#include <QNetworkReply>
#include <QJsonDocument>
#include <QJsonParseError>
#include <QJsonObject>
#include <QJsonArray>
#include <QEventLoop>
#include <QTimer>

RuoyiDataManager::RuoyiDataManager()
{
    m_pNetworkManager = new QNetworkAccessManager;
    //服务器地址
    m_sUrl = "http://top.365rise.top";
}

RuoyiDataManager::~RuoyiDataManager()
{
    if(m_pNetworkManager)
    {
        m_pNetworkManager->deleteLater();
        m_pNetworkManager = nullptr;
    }
}

QPixmap RuoyiDataManager::GetVerificationCode()
{
    QNetworkRequest request;
    QString urlStr(m_sUrl + "/prod-api/captchaImage");
    QUrl url = QUrl(urlStr);
    request.setUrl(url);
    QNetworkReply *reply = m_pNetworkManager->get(request);
    reply->setProperty("msgType",QVariant(int(GETVERIFICATIONCODE)));
    connect(reply,&QNetworkReply::finished,this,&RuoyiDataManager::RequestFinished);

    QEventLoop loop;
    connect(this, SIGNAL(ParseReplyFinished()), &loop, SLOT(quit()));
    loop.exec();

    return m_userInfo.codePix;
}

UserInfo RuoyiDataManager::Login(const QString &userName, const QString &password, const QString &code)
{
    m_userInfo.userName = userName;

    QNetworkRequest request;
    QString urlStr(m_sUrl + "/prod-api/login");

    QJsonDocument doc;
    QJsonObject rootObject;
    rootObject.insert("username",userName);
    rootObject.insert("password",password);
    rootObject.insert("code",code);
    rootObject.insert("uuid",m_userInfo.uuid);
    doc.setObject(rootObject);
    qDebug() << __FUNCTION__ << " login json: " << doc.toJson();

    QUrl url = QUrl(urlStr);
    request.setUrl(url);
    request.setHeader(QNetworkRequest::ContentTypeHeader,"application/json;charset=UTF-8");
    QNetworkReply *reply = m_pNetworkManager->post(request,doc.toJson());
    reply->setProperty("msgType",QVariant(int(LOGIN)));
    connect(reply,&QNetworkReply::finished,this,&RuoyiDataManager::RequestFinished);

    QEventLoop loop;
    connect(this, SIGNAL(ParseReplyFinished()), &loop, SLOT(quit()));
    loop.exec();

    return m_userInfo;
}

QList<QList<QString> > RuoyiDataManager::GetTrends(const TrendsRequestParam& requestParam)
{
    QNetworkRequest request;
    QString urlStr(m_sUrl + "/prod-api/stocksystem/trends/listSection");

    QUrl url = QUrl(urlStr);

    QUrlQuery query;
    query.addQueryItem("Token", requestParam.token.toUtf8());
    query.addQueryItem("pageNum", requestParam.pageNum);
    query.addQueryItem("pageSize", requestParam.pageSize);
    query.addQueryItem("tradeDay", requestParam.tradeDay);
    query.addQueryItem("type", requestParam.period);
    url.setQuery(query);

    request.setUrl(url);
    request.setHeader(QNetworkRequest::ContentTypeHeader,"application/json;charset=UTF-8");
    request.setRawHeader("Authorization",QString("Bearer %1").arg(requestParam.token).toLocal8Bit());
    qDebug() << __FUNCTION__ << " rawHeader: " << QString("Bearer %1").arg(requestParam.token).toLocal8Bit();

    QNetworkReply *reply = m_pNetworkManager->get(request);
    reply->setProperty("msgType",QVariant(int(GETTRENDS)));
    connect(reply,&QNetworkReply::finished,this,&RuoyiDataManager::RequestFinished);

    QEventLoop loop;
    connect(this, SIGNAL(ParseReplyFinished()), &loop, SLOT(quit()));
    loop.exec();

    return m_TrendsList;
}

QList<StockBasicInfo> RuoyiDataManager::GetStocksBasicInfo(const StockRequestParam &requestParam)
{
    if(!m_StockBasicList.isEmpty())
        return m_StockBasicList;
    QNetworkRequest request;
    QString urlStr(m_sUrl + "/prod-api/stocksystem/stockbasic/list");

    QUrl url = QUrl(urlStr);

    QUrlQuery query;
    query.addQueryItem("Token", requestParam.token.toUtf8());
    query.addQueryItem("pageNum", requestParam.pageNum);
    query.addQueryItem("pageSize", requestParam.pageSize);
    query.addQueryItem("tradeDay", requestParam.tradeDay);
    query.addQueryItem("type", requestParam.period);
    url.setQuery(query);

    request.setUrl(url);
    request.setHeader(QNetworkRequest::ContentTypeHeader,"application/json;charset=UTF-8");
    request.setRawHeader("Authorization",QString("Bearer %1").arg(requestParam.token).toLocal8Bit());
    qDebug() << __FUNCTION__ << " rawHeader: " << QString("Bearer %1").arg(requestParam.token).toLocal8Bit();

    QNetworkReply *reply = m_pNetworkManager->get(request);
    reply->setProperty("msgType",QVariant(int(GETSTOCKBASIC)));
    connect(reply,&QNetworkReply::finished,this,&RuoyiDataManager::RequestFinished);

    QEventLoop loop;
    connect(this, SIGNAL(ParseReplyFinished()), &loop, SLOT(quit()));
    loop.exec();

    return m_StockBasicList;
}

void RuoyiDataManager::AddTradeRecord(const TradingRequestParam &requestParam)
{
    // 创建一个 JSON 对象
    QJsonObject jsonObj;
    jsonObj["code"] = requestParam.code;
    jsonObj["name"] = requestParam.name;
    jsonObj["tradeDay"] = requestParam.tradeDay;
    jsonObj["weekDay"] = requestParam.weekDay;
    jsonObj["operate"] = requestParam.operate;
    jsonObj["dealPrice"] = requestParam.dealPrice;
    jsonObj["volumn"] = requestParam.volumn;
    jsonObj["amount"] = requestParam.amount;
    jsonObj["tax"] = requestParam.tax;
    jsonObj["fee"] = requestParam.fee;
    jsonObj["other"] = requestParam.fee;
    jsonObj["operateDiff"] = requestParam.operateDiff;
    jsonObj["preId"] = requestParam.preId;
    jsonObj["userId"] = requestParam.userId;
    jsonObj["dealLogic"] = requestParam.dealLogic;
    jsonObj["bz"] = requestParam.bz;

    // 创建一个 JSON 文档
    QJsonDocument jsonDoc(jsonObj);

    // 将 JSON 文档转换为字符串
    QString jsonString = jsonDoc.toJson(QJsonDocument::Compact);
    qDebug() << "JSON String:" << jsonString;


    QNetworkRequest request;
    QString urlStr(m_sUrl + "/prod-api/booksystem/operations");

    QUrl url = QUrl(urlStr);

    QUrlQuery query;
    query.addQueryItem("Token", requestParam.token.toUtf8());
    url.setQuery(query);

    request.setUrl(url);
    request.setHeader(QNetworkRequest::ContentTypeHeader,"application/json;charset=UTF-8");
    request.setRawHeader("Authorization",QString("Bearer %1").arg(requestParam.token).toLocal8Bit());
    qDebug() << __FUNCTION__ << " rawHeader: " << QString("Bearer %1").arg(requestParam.token).toLocal8Bit();

    QNetworkReply *reply = m_pNetworkManager->post(request,jsonString.toUtf8());
    reply->setProperty("msgType",QVariant(int(ADDTRADEDATA)));
    connect(reply,&QNetworkReply::finished,this,&RuoyiDataManager::RequestFinished);

    QEventLoop loop;
    connect(this, SIGNAL(ParseReplyFinished()), &loop, SLOT(quit()));
    loop.exec();
}

void RuoyiDataManager::RequestFinished()
{
    QNetworkReply *reply = dynamic_cast< QNetworkReply* >(sender());
    MsgType type =(MsgType) reply->property("msgType").toInt();
    if(type == GETVERIFICATIONCODE)
    {
        ParseVerificationCode(reply);
    }
    else if(type == LOGIN)
    {
        ParseLogin(reply);
    }
    else if(type == GETTRENDS)
    {
        ParseTrends(reply);
    }
    else if(type == GETSTOCKBASIC)
    {
        ParseStockBasic(reply);
    }
    else if(type == ADDTRADEDATA)
    {
        ParseAddTradeReply(reply);
    }
    emit ParseReplyFinished();
}

void RuoyiDataManager::ParseVerificationCode(QNetworkReply *reply)
{
    QByteArray readAllArray;
    QVariant statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
    if(statusCode.isValid())
    {
        qDebug() << "status code=" << statusCode.toInt();
    }

    QNetworkReply::NetworkError err = reply->error();
    if(err != QNetworkReply::NoError)
    {
        qDebug() << "Failed: " << reply->errorString();
    }
    else
    {
        readAllArray = reply->readAll();
        QJsonParseError jsonError;
        QJsonDocument document = QJsonDocument::fromJson(readAllArray,&jsonError);
        if(jsonError.error == QJsonParseError::NoError && !document.isNull())
        {
            QJsonObject root = document.object();
            if(root.contains("img"))
            {
                QPixmap pix;
                bool ret = pix.loadFromData(QByteArray::fromBase64(root["img"].toString().toUtf8()));
                m_userInfo.codePix = pix;
            }
            m_userInfo.uuid = root["uuid"].toString();
        }
        else
        {
            qDebug() << __FUNCTION__ << __LINE__ << jsonError.errorString();
        }
    }
}

void RuoyiDataManager::ParseLogin(QNetworkReply *reply)
{
    QByteArray readAllArray;
    QVariant statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
    if(statusCode.isValid())
    {
        qDebug() << "status code=" << statusCode.toInt();
    }

    QNetworkReply::NetworkError err = reply->error();
    if(err != QNetworkReply::NoError)
    {
        qDebug() << "Failed: " << reply->errorString();
        m_userInfo.token = "";
    }
    else
    {
        readAllArray = reply->readAll();
        QJsonParseError jsonError;
        QJsonDocument document = QJsonDocument::fromJson(readAllArray,&jsonError);
        if(jsonError.error == QJsonParseError::NoError && !document.isNull())
        {
            QJsonObject root = document.object();
            if(root.contains("token") && root["code"].toInt() == 200)
            {
                m_userInfo.token = root["token"].toString();
            }
        }
        else
        {
            qDebug() << __FUNCTION__ << __LINE__ << jsonError.errorString();
            m_userInfo.token = "";
        }
    }
}

void RuoyiDataManager::ParseTrends(QNetworkReply *reply)
{
    QByteArray readAllArray;
    QVariant statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
    if(statusCode.isValid())
    {
        qDebug() << "status code=" << statusCode.toInt();
    }

    QNetworkReply::NetworkError err = reply->error();
    if(err != QNetworkReply::NoError)
    {
        qDebug() << "Failed: " << reply->errorString();
    }
    else
    {
        readAllArray = reply->readAll();
//        qDebug() << __FUNCTION__ << readAllArray;
/**
 * total:
 * rows:[{title:2级行业,sortDataList:["煤炭","营销服务"]},{title:2023-12-07,sortDataList:["1","2"]}]
 * msg:""
 *
 * 第0行是第一列行业；title是列名即日期
 * 第1行是行业名称，所有的行数
*/
        QJsonParseError jsonError;
        QJsonDocument document = QJsonDocument::fromJson(readAllArray,&jsonError);
        if(jsonError.error == QJsonParseError::NoError && !document.isNull())
        {
//            QList< QList<QString> > rowsList;
            QList<QString> dates;
            int rowCounts = 0;
            QJsonObject root = document.object();
            if(root.contains("total"))
            {
                qDebug() << __FUNCTION__ << root["total"];
                rowCounts = root["total"].toInt();
            }
            if(root.contains("rows"))
            {
                m_TrendsList.clear();
                QJsonArray rows = root["rows"].toArray();
                for(int i = 0 ; i < rowCounts; i++)
                {
                    QJsonObject obj = rows[i].toObject();
                    if(obj.contains("title"))
                    {
                        dates.append(obj["title"].toString());
                    }
                    if(obj.contains("sortDataList"))
                    {
                        QList<QString> datasList;
                        QJsonArray datas = obj["sortDataList"].toArray();
                        for(int c = 0 ; c < datas.count(); c++)
                        {
                            datasList.append(datas[c].toString());
                        }
                        m_TrendsList.append(datasList);
                    }
                }
                m_TrendsList.prepend(dates);
            }
//            qDebug() << __FUNCTION__ << m_TrendsList;
        }
        else
        {
            qDebug() << __FUNCTION__ << __LINE__ << jsonError.errorString();
        }
    }
}

void RuoyiDataManager::ParseStockBasic(QNetworkReply *reply)
{
    QByteArray readAllArray;
    QVariant statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
    if(statusCode.isValid())
    {
        qDebug() << "status code=" << statusCode.toInt();
    }

    QNetworkReply::NetworkError err = reply->error();
    if(err != QNetworkReply::NoError)
    {
        qDebug() << "Failed: " << reply->errorString();
    }
    else
    {
        readAllArray = reply->readAll();
        QJsonParseError jsonError;
        QJsonDocument document = QJsonDocument::fromJson(readAllArray,&jsonError);
        if(jsonError.error == QJsonParseError::NoError && !document.isNull())
        {
            int rowCounts = 0;
            QJsonObject root = document.object();
            if(root.contains("rows"))
            {
                m_StockBasicList.clear();
                QJsonArray rows = root["rows"].toArray();
                rowCounts = rows.count();
                for(int i = 0 ; i < rowCounts; i++)
                {
                    StockBasicInfo info;
                    QJsonObject obj = rows[i].toObject();
                    if(obj.contains("name"))
                    {
                        info.name = obj["name"].toString();
                    }
                    if(obj.contains("code"))
                    {
                       info.code = obj["code"].toString();
                    }
                    if(obj.contains("blemind2"))
                    {
                       info.blemind2 = obj["blemind2"].toString();
                    }
                    if(obj.contains("blemind3"))
                    {
                       info.blemind3 = obj["blemind3"].toString();
                    }
                    if(obj.contains("listdate"))
                    {
                       info.listdate = obj["listdate"].toString();
                    }
                    m_StockBasicList.append(info);
                }
            }
        }
        else
        {
            qDebug() << __FUNCTION__ << __LINE__ << jsonError.errorString();
        }
    }
}

void RuoyiDataManager::ParseAddTradeReply(QNetworkReply *reply)
{
    QByteArray readAllArray;
    QVariant statusCode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
    if(statusCode.isValid())
    {
        qDebug() << "status code=" << statusCode.toInt();
    }

    QNetworkReply::NetworkError err = reply->error();
    if(err != QNetworkReply::NoError)
    {
        qDebug() << "Failed: " << reply->errorString();
    }
    else
    {
        readAllArray = reply->readAll();
        qDebug() << __FUNCTION__ << readAllArray;
    }
}