#include "MainController.h"

#include <QJsonDocument>
#include <QJsonArray>
#include <stdexcept>
#include "MainView.h"
#include "FileManager.h"
#include "ClangAnalyzer.h"
#include "GlobalConfig.h"
#include "PumlDiagramer.h"
#include "ClassGenerator.h"

using namespace std;

QVector<QPair<QVariant, QVariant>> jsonArrayToVector(const QString& str)
{
    QVector<QPair<QVariant, QVariant>> res;
    QJsonDocument doc = QJsonDocument::fromJson(str.toUtf8());
    if (doc.isArray())
    {
        QJsonArray jsonArray = doc.array();
        for (const QJsonValue &value : jsonArray) {
            QJsonObject obj = value.toObject();
            res.push_back({obj["name"].toVariant(), obj["value"].toVariant()});
        }
    }

    return res;
}

CMainController::CMainController(QObject* parent)
    : m_pMainView(make_shared<CMainView>())
    , m_pFileMgr(make_shared<CFileManager>())
    , m_pAnalyzer(make_shared<CClangAnalyzer>())
    , m_pDiagramer(make_shared<Diagram::CPumlDiagramer>())
    , m_pUmlGenerator(make_shared<CClassGenerator>())
{
    Q_UNUSED(parent);
    m_pUmlGenerator->setDiagramer(m_pDiagramer);
    QObject::connect(m_pMainView.get(), SIGNAL(sigAdd(QList<QUrl>)),
                     this, SLOT(sltAdd(QList<QUrl>)));
    QObject::connect(m_pMainView.get(), SIGNAL(sigClear()),
                     this, SLOT(sltClear()));
    QObject::connect(m_pMainView.get(), SIGNAL(sigAnalyze()),
                     this, SLOT(sltAnalyze()), Qt::DirectConnection);
    QObject::connect(m_pMainView.get(), SIGNAL(sigTerminate()),
                     this, SLOT(sltTerminate()));
    QObject::connect(m_pMainView.get(), SIGNAL(sigUpdateFilterPath(QVariantList)),
                     this, SLOT(sltUpdateFilterPath(QVariantList)));
    QObject::connect(m_pMainView.get(), SIGNAL(sigUpdateIncludePath(QVariantList)),
                     this, SLOT(sltUpdateIncludePath(QVariantList)));
    QObject::connect(m_pMainView.get(), SIGNAL(sigGetClassDesc(QString)),
                     this, SLOT(sltGetClassDesc(QString)));
    QObject::connect(m_pMainView.get(), SIGNAL(sigSetConfig(QVariant, QVariant)),
                     this, SLOT(sltSetConfig(QVariant, QVariant)));

    __updateConfig();
}

void CMainController::start()
{
    m_pMainView->show();
}

void CMainController::sltAdd(QList<QUrl> fileList)
{
    m_pFileMgr->add(fileList);
    auto fileNameList = m_pFileMgr->getFileNameList();
    QVariantList tempList;
    for (const auto& filename : fileNameList)
    {
        tempList.append(filename);
    }

    emit m_pMainView->sigUpdateQml("updateFileList", tempList);
}

void CMainController::sltClear()
{
    m_pFileMgr->clear();
}

void CMainController::sltAnalyze()
{
    m_pAnalyzer->parse(m_pFileMgr->getFileInfoList());
    __updateView();
}

void CMainController::sltTerminate()
{
    m_pAnalyzer->terminateParse(1000);
}

void CMainController::sltUpdateFilterPath(QVariantList val)
{
    QVector<QString> vecPath;
    foreach (const QVariant& item, val)
    {
        vecPath.push_back(item.toString());
    }

    m_pAnalyzer->setExcludePath(vecPath);
    CGlobalConfig::getInstance()->setFilterPath(vecPath);
}

void CMainController::sltUpdateIncludePath(QVariantList val)
{
    QVector<QString> vecPath;
    foreach (const QVariant& item, val)
    {
        vecPath.push_back(item.toString());
    }

    m_pAnalyzer->setIncludePath(vecPath);
    CGlobalConfig::getInstance()->setIncludePath(vecPath);
}

QString CMainController::sltGetClassDesc(QString strType)
{
    return m_pAnalyzer->getClassElem(strType)->getClassPrettyDesc();
}

void CMainController::sltSetConfig(QVariant name, QVariant val)
{
    scope_exit autoSave([&name, &val](){
        CGlobalConfig::getInstance()->setConfig(name.toString(), val);
    });

    if (name == "hideSingle")
    {
        m_pDiagramer->setHideSingleClass(val.toBool());
        return;
    }

    if (name == "hideOneToOne")
    {
        m_pDiagramer->setHideOneToOne(val.toBool());
        return;
    }

    if (name == "graphConfig")
    {
        m_pDiagramer->setGraphConfig(jsonArrayToVector(val.toString()));
        return;
    }

    if (name == "layoutType")
    {
        m_pDiagramer->setLayout(static_cast<Diagram::LAYOUT_TYPE>(val.toInt()));
        return;
    }

    autoSave.release();
}

void CMainController::__updateConfig()
{
    //更新配置
    auto vecFilePath = CGlobalConfig::getInstance()->getFilterPath();
    if (vecFilePath.size() > 0)
    {
        QVariantList pathList;
        foreach (const auto& item, vecFilePath)
        {
            pathList.append(item);
        }
        emit m_pMainView->sigUpdateQml("updateFilterPath", pathList);
        m_pAnalyzer->setExcludePath(vecFilePath);
    }

    vecFilePath = CGlobalConfig::getInstance()->getIncludePath();
    if (vecFilePath.size() > 0)
    {
        QVariantList pathList;
        foreach (const auto& item, vecFilePath)
        {
            pathList.append(item);
        }
        emit m_pMainView->sigUpdateQml("updateIncludePath", pathList);
        m_pAnalyzer->setIncludePath(vecFilePath);
    }

    auto hideSingle = CGlobalConfig::getInstance()->getConfig("hideSingle");
    emit m_pMainView->sigUpdateQml("updateHideSingle", hideSingle);
    m_pDiagramer->setHideSingleClass(hideSingle.toBool());

    auto hideOneToOne = CGlobalConfig::getInstance()->getConfig("hideOneToOne");
    emit m_pMainView->sigUpdateQml("updateHideOneToOne", hideOneToOne);
    m_pDiagramer->setHideOneToOne(hideOneToOne.toBool());

    auto layoutType = CGlobalConfig::getInstance()->getConfig("layoutType");
    emit m_pMainView->sigUpdateQml("updateLayoutType", layoutType);
    m_pDiagramer->setLayout(static_cast<Diagram::LAYOUT_TYPE>(layoutType.toInt()));

    auto graphConfig = CGlobalConfig::getInstance()->getConfig("graphConfig");
    emit m_pMainView->sigUpdateQml("updateGraphConfig", graphConfig);
    m_pDiagramer->setGraphConfig(jsonArrayToVector(graphConfig.toString()));
}

void CMainController::__updateView()
{
    QList<CClassElem::ptr> classInfos = m_pAnalyzer->getAllClassElemList();
    QVariantList infosList;
    foreach (const auto& item, classInfos)
    {
        QVariantList infos;
        infos.push_back(item->type());
        infos.push_back(item->filePath());
        infosList.push_back(infos);
    }

    QImage imgClass;
    try
    {
        imgClass = m_pUmlGenerator->generateImg(classInfos);
    }
    catch (const std::invalid_argument& e)
    {
        qDebug() << e.what();
    }
    catch (const std::runtime_error& e)
    {
        qDebug() << e.what();
    }
    catch(const std::exception&)
    {
        qDebug() << tr("generateImg unexpected error");
    }

    m_pMainView->updateUmlImage(imgClass);
    emit m_pMainView->sigUpdateQml("updateClassDscript", infosList);
    emit m_pMainView->sigUpdateQml("updateOutPrint", m_pAnalyzer->getDiagnostics());
}