#include "syschartdeveloper.h"
#include <QToolBar>
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QDebug>
#include <topcore/topcore.h>
#include <topcore/topclasssqlthread.h>
#include <toputil/t.h>
#include <tbaseutil/tdataresponse.h>
#include <tbaseutil/tdataparse.h>
#include <tbaseutil/tresource.h>
#include <tbaseutil/tconcurrent.h>
#include <tdatabaseutil/tsqlselectorv2.h>
#include <tdatabaseutil/tsqlconnectionpoolv2.h>
#include <tdatabaseutil/tsqlqueryv2.h>
#include <twidget/ttableview.h>
#include <twidget/tuiloader.h>
#include <twidget/ttabwidget.h>
#include <twidget/tsplitter.h>
#include <twidget/tcodeedit.h>
#include <twidget/tlabel.h>
#include <twidget/tsearchentry.h>

SysChartDeveloper::SysChartDeveloper(const QString &iModuleName, const QVariantMap &iUrlPars, QWidget *iParent)
    : TopClassAbs(iParent)
{
    setLicenseKey("sys_common");
    initModule(iModuleName,iUrlPars);
    initUi();
}

SysChartDeveloper::~SysChartDeveloper()
{
}

void SysChartDeveloper::refresh()
{
    t::loading(this);
    TSqlSelectorV2 selector = getSqlSelector();
    QVariant data = doThreadWork(new TopClassSqlThread(this), TOPSQLTHREAD_SELECT_MAP, QVariant::fromValue(selector));
    unloading();
    TDataResponse dataRes(data.toMap());
    if (dataRes.hasError()) {
        alertError(dataRes.errText(), "Error");
        return;
    }
    mDetailDataMap = dataRes.data().toMap();
    mEdtGraph->setText(mDetailDataMap.value("graph_layout").toString());
    mEdtParam->setText(mDetailDataMap.value("parameter_list").toString());
    this->setWindowModified(false);
    this->setDataModified(false);
    this->refreshActionState();
}

void SysChartDeveloper::refreshDatasource()
{
    TSqlSelectorV2 selector;
    selector.setTable("pub_chart_datasource");
    selector.setField(mTableConf.queryFields);
    if (!mSpecifiedClass.isEmpty()) {
        selector.setWhere("class", mSpecifiedClass);
    }
    if (mSearchEntryData != nullptr) {
        selector.whereRef().append(mSearchEntryData->sqlWhere());
    }
    selector.setOrder("id", Qt::AscendingOrder);
    QVariant data = doThreadWork(new TopClassSqlThread(this), TOPSQLTHREAD_SELECT_ARRAYMAP, QVariant::fromValue(selector));
    TDataResponse dataRes(data.toMap());
    if (dataRes.hasError()) {
        alertError(dataRes.errText(), "Error");
        return;
    }
    QVariantList dataList = dataRes.data().toList();
    TopClassHelper::formatTableData(this,&mTableConf,dataList);
    mDatasourceTable->loadData(dataList);
    mUiLoaderData->clearValues();
    mUiLoaderData->setEnabled(false);
    this->setDatasourceModified(false);
}

void SysChartDeveloper::refreshGraph()
{
    TSqlSelectorV2 selector;
    selector.setTable("pub_chart_graph");
    selector.setField(mTableConf.queryFields);
    if (!mSpecifiedClass.isEmpty()) {
        selector.setWhere("class", mSpecifiedClass);
    }
    if (mSearchEntryGraph != nullptr) {
        selector.whereRef().append(mSearchEntryGraph->sqlWhere());
    }
    selector.setOrder("id", Qt::AscendingOrder);
    QVariant data = doThreadWork(new TopClassSqlThread(this), TOPSQLTHREAD_SELECT_ARRAYMAP, QVariant::fromValue(selector));
    TDataResponse dataRes(data.toMap());
    if (dataRes.hasError()) {
        alertError(dataRes.errText(), "Error");
        return;
    }
    QVariantList dataList = dataRes.data().toList();
    TopClassHelper::formatTableData(this,&mTableConf,dataList);
    mGraphTable->loadData(dataList);
    mUiLoaderGraph->clearValues();
    mUiLoaderGraph->setEnabled(false);
    this->setGraphModified(false);
}

void SysChartDeveloper::refreshDatasourceInfo()
{
    QVariantList selectedItems = this->selectedDatasrcItems();
    if (selectedItems.size() == 0) return;
    QString sid = selectedItems.first().toString();
    t::loading(this);
    TSqlSelectorV2 selector;
    selector.setTable("pub_chart_datasource");
    selector.setField("*");
    selector.setWhere("id", sid);
    QVariant data = doThreadWork(new TopClassSqlThread(this), TOPSQLTHREAD_SELECT_MAP, QVariant::fromValue(selector));
    unloading();
    TDataResponse dataRes(data.toMap());
    if (dataRes.hasError()) {
        alertError(dataRes.errText(), "Error");
        return;
    }
    QVariantMap dataMap = dataRes.data().toMap();
    mUiLoaderData->loadValues(dataMap);
    this->setDatasourceModified(false);
    this->refreshActionState();
}

void SysChartDeveloper::refreshGraphInfo()
{
    QVariantList selectedItems = this->selectedGraphItems();
    if (selectedItems.size() == 0) return;
    QString sid = selectedItems.first().toString();
    t::loading(this);
    TSqlSelectorV2 selector;
    selector.setTable("pub_chart_graph A LEFT JOIN pub_chart_datasource B ON A.chart_datasource_id = B.id");
    selector.setField("A.*, B.name as datasource_name");
    selector.setWhere("A.id", sid);
    QVariant data = doThreadWork(new TopClassSqlThread(this), TOPSQLTHREAD_SELECT_MAP, QVariant::fromValue(selector));
    unloading();
    TDataResponse dataRes(data.toMap());
    if (dataRes.hasError()) {
        alertError(dataRes.errText(), "Error");
        return;
    }
    QVariantMap dataMap = dataRes.data().toMap();
    mUiLoaderGraph->loadValues(dataMap);
    this->setGraphModified(false);
    this->refreshActionState();
}

void SysChartDeveloper::saveData()
{
    QVariantMap dataMap;
    dataMap.insert("graph_layout", mEdtGraph->toPlainText());
    dataMap.insert("parameter_list", mEdtParam->toPlainText());
    TError *oErr = new TError;
    TConcurrent::runSync([this, oErr, dataMap]() {
        TSqlQueryV2 query(T_SQLCNT_POOL->getSqlDatabase());
        query.begin();
        try {
            TSqlUpdaterV2 updater;
            updater.setTable("pub_chart_navigation");
            updater.setData(dataMap);
            updater.setWhere("id", this->uid());
            query.updateRow(updater);
            if (query.lastError().isValid()) {
                throw query.lastError();
            }
            query.commit();
            return QVariant();
        } catch (TError &iErr) {
            if (oErr != nullptr) {
                oErr->setText(iErr.text());
            }
            query.rollback();
            return QVariant();
        }
    });
    if (oErr->isValid()) {
        alertError(ttr("Save data failed!"), oErr->text());
    } else {
        alertOk(ttr("Data saved"));
    }
    this->setDataModified(false);
}

void SysChartDeveloper::clearData()
{
    mEdtGraph->clear();
    mEdtParam->clear();
    this->setDataModified(false);
    this->refreshActionState();
}

void SysChartDeveloper::saveDatasource()
{
    QVariantMap dataMap;
    dataMap = mUiLoaderData->getAllValues().toVariant().toMap();
    if (dataMap.isEmpty()) return;
    QVariantList selectedItems = this->selectedDatasrcItems();
    if (selectedItems.size() == 0) return;
    QString sid = selectedItems.first().toString();
    TError *oErr = new TError;
    TConcurrent::runSync([this, oErr, dataMap, sid]() {
        TSqlQueryV2 query(T_SQLCNT_POOL->getSqlDatabase());
        query.begin();
        try {
            TSqlUpdaterV2 updater;
            updater.setTable("pub_chart_datasource");
            updater.setData(dataMap);
            updater.setWhere("id", sid);
            query.updateRow(updater);
            if (query.lastError().isValid()) {
                throw query.lastError();
            }
            query.commit();
            return QVariant();
        } catch (TError &iErr) {
            if (oErr != nullptr) {
                oErr->setText(iErr.text());
            }
            query.rollback();
            return QVariant();
        }
    });
    if (oErr->isValid()) {
        alertError(ttr("Save data failed!"), oErr->text());
    } else {
        alertOk(ttr("Data saved"));
    }
    this->setDatasourceModified(false);
}

void SysChartDeveloper::saveGraph()
{
    QVariantMap dataMap;
    dataMap = mUiLoaderGraph->getAllValues(true).toVariant().toMap();
    if (dataMap.isEmpty()) return;
    dataMap.remove("datasource_name");
    QVariantList selectedItems = this->selectedGraphItems();
    if (selectedItems.size() == 0) return;
    QString sid = selectedItems.first().toString();
    TError *oErr = new TError;
    TConcurrent::runSync([this, oErr, dataMap, sid]() {
        TSqlQueryV2 query(T_SQLCNT_POOL->getSqlDatabase());
        query.begin();
        try {
            TSqlUpdaterV2 updater;
            updater.setTable("pub_chart_graph");
            updater.setData(dataMap);
            updater.setWhere("id", sid);
            query.updateRow(updater);
            if (query.lastError().isValid()) {
                throw query.lastError();
            }
            query.commit();
            return QVariant();
        } catch (TError &iErr) {
            if (oErr != nullptr) {
                oErr->setText(iErr.text());
            }
            query.rollback();
            return QVariant();
        }
    });
    if (oErr->isValid()) {
        alertError(ttr("Save data failed!"), oErr->text());
    } else {
        alertOk(ttr("Data saved"));
    }
    this->setGraphModified(false);
}

void SysChartDeveloper::setSpecifiedClass(const QString &iClassName)
{
    mSpecifiedClass = iClassName;
}

QString SysChartDeveloper::specifiedClass()
{
    return mSpecifiedClass;
}

QVariantList SysChartDeveloper::selectedDatasrcDataMaps() const
{
    return mDatasourceTable->selectedRowDataMaps(true);
}

QVariantList SysChartDeveloper::selectedGraphDataMaps() const
{
    return mGraphTable->selectedRowDataMaps(true);
}

QVariantList SysChartDeveloper::selectedDatasrcItems() const
{
    return mDatasourceTable->selectedPrimaryKeys();
}

QVariantList SysChartDeveloper::selectedGraphItems() const
{
    return mGraphTable->selectedPrimaryKeys();
}

QVariantMap SysChartDeveloper::detailDataMap() const
{
    return mDetailDataMap;
}

void SysChartDeveloper::setDatasourceModified(const bool &iFlag)
{
    mDatasourceModified = iFlag;
    this->refreshActionState();
    mUiLoaderData->refreshState();
}

void SysChartDeveloper::setGraphModified(const bool &iFlag)
{
    mGraphModified = iFlag;
    this->refreshActionState();
    mUiLoaderGraph->refreshState();
}

bool SysChartDeveloper::isDatasourceModified() const
{
    return mDatasourceModified;
}

bool SysChartDeveloper::isGraphModified() const
{
    return mGraphModified;
}

void SysChartDeveloper::dataModified(bool iFlag)
{
    this->setDataModified(iFlag);
    this->refreshActionState();
}

void SysChartDeveloper::datasourceModified(bool iFlag)
{
    this->setDatasourceModified(iFlag);
    this->refreshActionState();
}

void SysChartDeveloper::graphModified(bool iFlag)
{
    this->setGraphModified(iFlag);
    this->refreshActionState();
}

void SysChartDeveloper::onDataSelectionChanged()
{
    if (this->selectedDatasrcItems().size()) {
        mUiLoaderData->setEnabled(true);
        refreshDatasourceInfo();
    } else {
        mUiLoaderData->clearValues();
        mUiLoaderData->setEnabled(false);
    }
}

void SysChartDeveloper::onGraphSelectionChanged()
{
    if (this->selectedGraphItems().size()) {
        mUiLoaderGraph->setEnabled(true);
        refreshGraphInfo();
    } else {
        mUiLoaderGraph->clearValues();
        mUiLoaderGraph->setEnabled(false);
    }
}

void SysChartDeveloper::uidChangeEvent(const QString &iUidStr)
{
    if (iUidStr.isEmpty()) {
        mEdtGraph->clear();
        mEdtParam->clear();
        mEdtGraph->clearFocus();
        mEdtParam->clearFocus();
        mDetailDataMap = QVariantMap();
        mTabNavigation->setEnabled(false);
        this->setDataModified(false);
        this->refreshActionState();
        return;
    }
    mTabNavigation->setEnabled(true);
    refresh();
}

void SysChartDeveloper::initUi()
{
    initTopWidget();
    initBottomWidget();
    mTabNavigation->setEnabled(false);
}

void SysChartDeveloper::initTopWidget()
{
    QWidget *centerWgt = new QWidget(this);
    setCentralWidget(centerWgt);
    mMainLayout = new QVBoxLayout(centerWgt);
    mMainLayout->setMargin(0);
    mMainLayout->setSpacing(6);
    if (QToolBar *toolbar = qobject_cast<QToolBar *>(uim()->getWidget("MAIN_TOOLBAR"))) {
        mMainLayout->addWidget(toolbar, 0);
    }
    mTabNavigation = new TTabWidget(this);
    mMainSplitter = new TSplitter(this);
    mMainSplitter->setOrientation(Qt::Vertical);
    mMainLayout->addWidget(mMainSplitter);
    mMainSplitter->addWidget(mTabNavigation);
    QWidget *graphWgt = new QWidget(this);
    TLabel *lblGraph = new TLabel(this);
    lblGraph->setText(ttr("Graph Layout"));
    mEdtGraph = new TCodeEdit(this);
    QHBoxLayout *graphLayout = new QHBoxLayout(graphWgt);
    graphLayout->setMargin(6);
    graphLayout->setSpacing(6);
    graphLayout->addWidget(lblGraph);
    graphLayout->addWidget(mEdtGraph);
    graphLayout->setAlignment(lblGraph, Qt::AlignTop);
    QWidget *paramWgt = new QWidget;
    TLabel *lblParam = new TLabel;
    lblParam->setText(ttr("Param List"));
    mEdtParam = new TCodeEdit(this);
    QHBoxLayout *paramLayout = new QHBoxLayout(paramWgt);
    paramLayout->setMargin(6);
    paramLayout->setSpacing(6);
    paramLayout->addWidget(lblParam);
    paramLayout->addWidget(mEdtParam);
    paramLayout->setAlignment(lblParam, Qt::AlignTop);
    mTabNavigation->addTab(graphWgt, TRES->icon("bar-chart"), ttr("Graph Layout"));
    mTabNavigation->addTab(paramWgt, TRES->icon("bars"), ttr("Param List"));
    connect(mEdtGraph, SIGNAL(textChanged()), this, SLOT(dataModified()));
    connect(mEdtParam, SIGNAL(textChanged()), this, SLOT(dataModified()));
}

void SysChartDeveloper::initBottomWidget()
{
    TopClassHelper::parseTableConf0(this,"view",&mTableConf);
    initDatasourceTab();
    initGraphTab();
    mTabDataGraph = new TTabWidget(this);
    mTabDataGraph->addTab(mDatasourceWgt, TRES->icon("database"), ttr("Datasource"));
    mTabDataGraph->addTab(mGraphWgt, TRES->icon("bar-chart"), ttr("Graph"));
    mMainSplitter->addWidget(mTabDataGraph);
    mMainSplitter->setStretchFactor(0, 5);
    mMainSplitter->setStretchFactor(1, 4);
    connect(mDatasourceTable->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
            this, SLOT(onDataSelectionChanged()));
    connect(mGraphTable->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
            this, SLOT(onGraphSelectionChanged()));
}

void SysChartDeveloper::initDatasourceTab()
{
    mDatasourceWgt = new QWidget(this);
    QVBoxLayout *vLayout = new QVBoxLayout(mDatasourceWgt);
    vLayout->setMargin(0);
    vLayout->setSpacing(6);
    if (QToolBar *toolbar = qobject_cast<QToolBar*>(uim()->getWidget("DATASOURCE_TOOLBAR"))) {
        vLayout->insertWidget(0, toolbar);
        mSearchEntryData = qobject_cast<TSearchEntry *>(uim()->getWidget("DATASOURCE_TOOLBAR/SEARCH_ENTRY"));
        if (mSearchEntryData != nullptr) {
            connect(mSearchEntryData, SIGNAL(search(QString,QVariant)), this, SLOT(refreshDatasource()));
        }
    }
    mDatasourceTable = new TTableView(this);
    mDatasourceTable->setDataKeyList(mTableConf.dataKeys);
    mDatasourceTable->setPrimaryKey(mTableConf.primaryKey);
    QVariantList headerItems = mTableConf.horizontalHeaders;
    headerItems.prepend(QVariant());
    mDatasourceTable->setHeaderItem(headerItems);
    mDatasourceTable->horizontalHeader()->setFixedHeight(40);
    QMenu *popMenu = qobject_cast<QMenu*>(uim()->getWidget("DATA_TABLEVIEW_POPUP"));
    if(popMenu) {
        mDatasourceTable->setContextMenu(popMenu);
    }
    if (mSearchEntryData != nullptr) {
        mSearchEntryData->setOptionList(TDataParse::headerItem2searchList(mDatasourceTable->headerItem()));
        mSearchEntryData->setPlaceholderText(ttr("Search %1"));
    }
    mUiLoaderData = new TUiLoader(this);
    connect(mUiLoaderData, SIGNAL(dataChanged()), this, SLOT(datasourceModified()));
    mUiLoaderData->setProperty("SS_BG", "PANEL");
    mUiLoaderData->setScriptEngine(APP->scriptEngine());
    mUiLoaderData->setSelf(this);
    mUiLoaderData->setUiStr(ui("detail_data").toString());
    TSplitter *splitter = new TSplitter(this);
    splitter->setOrientation(Qt::Horizontal);
    splitter->addWidget(mDatasourceTable);
    splitter->addWidget(mUiLoaderData);
    vLayout->addWidget(splitter);
}

void SysChartDeveloper::initGraphTab()
{
    mGraphWgt = new QWidget(this);
    QVBoxLayout *vLayout = new QVBoxLayout(mGraphWgt);
    vLayout->setMargin(0);
    vLayout->setSpacing(6);
    if (QToolBar *toolbar = qobject_cast<QToolBar*>(uim()->getWidget("GRAPH_TOOLBAR"))) {
        vLayout->insertWidget(0, toolbar);
        mSearchEntryGraph = qobject_cast<TSearchEntry *>(uim()->getWidget("GRAPH_TOOLBAR/SEARCH_ENTRY"));
        if (mSearchEntryGraph != nullptr) {
            connect(mSearchEntryGraph, SIGNAL(search(QString,QVariant)), this, SLOT(refreshGraph()));
        }
    }
    mGraphTable = new TTableView(this);
    mGraphTable->setDataKeyList(mTableConf.dataKeys);
    mGraphTable->setPrimaryKey(mTableConf.primaryKey);
    QVariantList headerItems = mTableConf.horizontalHeaders;
    headerItems.prepend(QVariant());
    mGraphTable->setHeaderItem(headerItems);
    mGraphTable->horizontalHeader()->setFixedHeight(40);
    QMenu *popMenu = qobject_cast<QMenu*>(uim()->getWidget("GRAPH_TABLEVIEW_POPUP"));
    if(popMenu) {
        mGraphTable->setContextMenu(popMenu);
    }
    if (mSearchEntryGraph != nullptr) {
        mSearchEntryGraph->setOptionList(TDataParse::headerItem2searchList(mGraphTable->headerItem()));
        mSearchEntryGraph->setPlaceholderText(ttr("Search %1"));
    }
    mUiLoaderGraph = new TUiLoader(this);
    connect(mUiLoaderGraph, SIGNAL(dataChanged()), this, SLOT(graphModified()));
    mUiLoaderGraph->setProperty("SS_BG", "PANEL");
    mUiLoaderGraph->setScriptEngine(APP->scriptEngine());
    mUiLoaderGraph->setSelf(this);
    mUiLoaderGraph->setUiStr(ui("detail_graph").toString());
    TSplitter *splitter = new TSplitter(this);
    splitter->setOrientation(Qt::Horizontal);
    splitter->addWidget(mGraphTable);
    splitter->addWidget(mUiLoaderGraph);
    vLayout->addWidget(splitter);
}

TSqlSelectorV2 SysChartDeveloper::getSqlSelector()
{
    TSqlSelectorV2 selector;
    selector.setTable("pub_chart_navigation");
    selector.setField(QStringList()<<"graph_layout"<<"parameter_list");
    selector.setWhere("id", uid());
    return selector;
}