// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

#undef QT_NO_FOREACH // this file contains unported legacy Q_FOREACH uses

#include <QtCharts/QBarCategoryAxis>
#include <QtCharts/QCandlestickSeries>
#include <QtCharts/QCandlestickSet>
#include <QtCharts/QDateTimeAxis>
#include <QtCharts/QHCandlestickModelMapper>
#include <QtCharts/QValueAxis>
#include <QtCore/QDateTime>
#include <QtCore/QDebug>
#include <QtCore/QRandomGenerator>
#include <QtWidgets/QCheckBox>
#include <QtWidgets/QComboBox>
#include <QtWidgets/QDoubleSpinBox>
#include <QtWidgets/QGridLayout>
#include <QtWidgets/QHeaderView>
#include <QtWidgets/QLabel>
#include <QtWidgets/QPushButton>
#include <QtWidgets/QTableView>
#include "customtablemodel.h"
#include "mainwidget.h"

QT_USE_NAMESPACE

MainWidget::MainWidget(QWidget *parent)
    : QWidget(parent),
      m_chart(new QChart()),
      m_chartView(new QChartView(m_chart, this)),
      m_axisX(nullptr),
      m_axisY(nullptr),
      m_maximumColumnWidth(-1.0),
      m_minimumColumnWidth(5.0),
      m_bodyOutlineVisible(true),
      m_capsVisible(false),
      m_bodyWidth(0.5),
      m_capsWidth(0.5),
      m_customIncreasingColor(false),
      m_customDecreasingColor(false),
      m_hModelMapper(new QHCandlestickModelMapper(this))
{
    m_chartView->setRenderHint(QPainter::Antialiasing, false);

    m_hModelMapper->setModel(new CustomTableModel(this));
    m_hModelMapper->setTimestampColumn(0);
    m_hModelMapper->setOpenColumn(1);
    m_hModelMapper->setHighColumn(2);
    m_hModelMapper->setLowColumn(3);
    m_hModelMapper->setCloseColumn(4);

    QGridLayout *mainLayout = new QGridLayout();
    mainLayout->addLayout(createSeriesControlsLayout(), 0, 0);
    mainLayout->addLayout(createSetsControlsLayout(), 1, 0);
    mainLayout->addLayout(createCandlestickControlsLayout(), 2, 0);
    mainLayout->addLayout(createMiscellaneousControlsLayout(), 3, 0);
    mainLayout->addWidget(m_chartView, 0, 1, mainLayout->rowCount() + 1, 1);
    mainLayout->addLayout(createModelMapperControlsLayout(), 0, 2, mainLayout->rowCount(), 1);
    setLayout(mainLayout);

    addSeries();
}

MainWidget::~MainWidget()
{
}

QGridLayout *MainWidget::createSeriesControlsLayout()
{
    QGridLayout *layout = new QGridLayout();
    int row = 0;

    layout->addWidget(new QLabel(QStringLiteral("Series controls:")), row, 0, Qt::AlignLeft);

    QPushButton *addSeriesButton = new QPushButton(QStringLiteral("Add a series"));
    connect(addSeriesButton, SIGNAL(clicked(bool)), this, SLOT(addSeries()));
    layout->addWidget(addSeriesButton, row++, 1, Qt::AlignLeft);

    QPushButton *removeSeriesButton = new QPushButton(QStringLiteral("Remove a series"));
    connect(removeSeriesButton, SIGNAL(clicked(bool)), this, SLOT(removeSeries()));
    layout->addWidget(removeSeriesButton, row++, 1, Qt::AlignLeft);

    QPushButton *removeAllSeriesButton = new QPushButton(QStringLiteral("Remove all series"));
    connect(removeAllSeriesButton, SIGNAL(clicked(bool)), this, SLOT(removeAllSeries()));
    layout->addWidget(removeAllSeriesButton, row++, 1, Qt::AlignLeft);

    return layout;
}

QGridLayout *MainWidget::createSetsControlsLayout()
{
    QGridLayout *layout = new QGridLayout();
    int row = 0;

    layout->addWidget(new QLabel(QStringLiteral("Sets controls:")), row, 0, Qt::AlignLeft);

    QPushButton *addSetButton = new QPushButton(QStringLiteral("Add a set"));
    connect(addSetButton, SIGNAL(clicked(bool)), this, SLOT(addSet()));
    layout->addWidget(addSetButton, row++, 1, Qt::AlignLeft);

    QPushButton *insertSetButton = new QPushButton(QStringLiteral("Insert a set"));
    connect(insertSetButton, SIGNAL(clicked(bool)), this, SLOT(insertSet()));
    layout->addWidget(insertSetButton, row++, 1, Qt::AlignLeft);

    QPushButton *removeSetButton = new QPushButton(QStringLiteral("Remove a set"));
    connect(removeSetButton, SIGNAL(clicked(bool)), this, SLOT(removeSet()));
    layout->addWidget(removeSetButton, row++, 1, Qt::AlignLeft);

    QPushButton *removeAllSetsButton = new QPushButton(QStringLiteral("Remove all sets"));
    connect(removeAllSetsButton, SIGNAL(clicked(bool)), this, SLOT(removeAllSets()));
    layout->addWidget(removeAllSetsButton, row++, 1, Qt::AlignLeft);

    return layout;
}

QGridLayout *MainWidget::createCandlestickControlsLayout()
{
    QGridLayout *layout = new QGridLayout();
    int row = 0;

    layout->addWidget(new QLabel(QStringLiteral("Maximum column width:")), row, 0, Qt::AlignLeft);
    QDoubleSpinBox *maximumColumnWidthSpinBox = new QDoubleSpinBox();
    maximumColumnWidthSpinBox->setRange(-1.0, 1024.0);
    maximumColumnWidthSpinBox->setDecimals(0);
    maximumColumnWidthSpinBox->setValue(m_maximumColumnWidth);
    maximumColumnWidthSpinBox->setSingleStep(1.0);
    connect(maximumColumnWidthSpinBox, SIGNAL(valueChanged(double)),
            this, SLOT(changeMaximumColumnWidth(double)));
    layout->addWidget(maximumColumnWidthSpinBox, row++, 1, Qt::AlignLeft);

    layout->addWidget(new QLabel(QStringLiteral("Minimum column width:")), row, 0, Qt::AlignLeft);
    QDoubleSpinBox *minimumColumnWidthSpinBox = new QDoubleSpinBox();
    minimumColumnWidthSpinBox->setRange(-1.0, 1024.0);
    minimumColumnWidthSpinBox->setDecimals(0);
    minimumColumnWidthSpinBox->setValue(m_minimumColumnWidth);
    minimumColumnWidthSpinBox->setSingleStep(1.0);
    connect(minimumColumnWidthSpinBox, SIGNAL(valueChanged(double)),
            this, SLOT(changeMinimumColumnWidth(double)));
    layout->addWidget(minimumColumnWidthSpinBox, row++, 1, Qt::AlignLeft);

    QCheckBox *bodyOutlineVisible = new QCheckBox(QStringLiteral("Body outline visible"));
    connect(bodyOutlineVisible, SIGNAL(toggled(bool)), this, SLOT(bodyOutlineVisibleToggled(bool)));
    bodyOutlineVisible->setChecked(m_bodyOutlineVisible);
    layout->addWidget(bodyOutlineVisible, row++, 0, Qt::AlignLeft);

    QCheckBox *capsVisible = new QCheckBox(QStringLiteral("Caps visible"));
    connect(capsVisible, SIGNAL(toggled(bool)), this, SLOT(capsVisibleToggled(bool)));
    capsVisible->setChecked(m_capsVisible);
    layout->addWidget(capsVisible, row++, 0, Qt::AlignLeft);

    layout->addWidget(new QLabel(QStringLiteral("Candlestick body width:")), row, 0, Qt::AlignLeft);
    QDoubleSpinBox *bodyWidthSpinBox = new QDoubleSpinBox();
    bodyWidthSpinBox->setRange(-1.0, 2.0);
    bodyWidthSpinBox->setValue(m_bodyWidth);
    bodyWidthSpinBox->setSingleStep(0.1);
    connect(bodyWidthSpinBox, SIGNAL(valueChanged(double)), this, SLOT(changeBodyWidth(double)));
    layout->addWidget(bodyWidthSpinBox, row++, 1, Qt::AlignLeft);

    layout->addWidget(new QLabel(QStringLiteral("Candlestick caps width:")), row, 0, Qt::AlignLeft);
    QDoubleSpinBox *capsWidthSpinBox = new QDoubleSpinBox();
    capsWidthSpinBox->setRange(-1.0, 2.0);
    capsWidthSpinBox->setValue(m_capsWidth);
    capsWidthSpinBox->setSingleStep(0.1);
    connect(capsWidthSpinBox, SIGNAL(valueChanged(double)), this, SLOT(changeCapsWidth(double)));
    layout->addWidget(capsWidthSpinBox, row++, 1, Qt::AlignLeft);

    QCheckBox *increasingColor = new QCheckBox(QStringLiteral("Custom increasing color (only S1)"));
    connect(increasingColor, SIGNAL(toggled(bool)), this, SLOT(customIncreasingColorToggled(bool)));
    increasingColor->setChecked(m_customIncreasingColor);
    layout->addWidget(increasingColor, row++, 0, 1, 2, Qt::AlignLeft);

    QCheckBox *decreasingColor = new QCheckBox(QStringLiteral("Custom decreasing color (only S1)"));
    connect(decreasingColor, SIGNAL(toggled(bool)), this, SLOT(customDecreasingColorToggled(bool)));
    decreasingColor->setChecked(m_customDecreasingColor);
    layout->addWidget(decreasingColor, row++, 0, 1, 2, Qt::AlignLeft);

    return layout;
}

QGridLayout *MainWidget::createMiscellaneousControlsLayout()
{
    QGridLayout *layout = new QGridLayout();
    int row = 0;

    layout->addWidget(new QLabel(QStringLiteral("Miscellaneous:")), row, 0, Qt::AlignLeft);

    QCheckBox *antialiasingCheckBox = new QCheckBox(QStringLiteral("Antialiasing"));
    connect(antialiasingCheckBox, SIGNAL(toggled(bool)), this, SLOT(antialiasingToggled(bool)));
    antialiasingCheckBox->setChecked(false);
    layout->addWidget(antialiasingCheckBox, row++, 1, Qt::AlignLeft);

    QCheckBox *animationCheckBox = new QCheckBox(QStringLiteral("Animation"));
    connect(animationCheckBox, SIGNAL(toggled(bool)), this, SLOT(animationToggled(bool)));
    animationCheckBox->setChecked(false);
    layout->addWidget(animationCheckBox, row++, 1, Qt::AlignLeft);

    QCheckBox *legendCheckBox = new QCheckBox(QStringLiteral("Legend"));
    connect(legendCheckBox, SIGNAL(toggled(bool)), this, SLOT(legendToggled(bool)));
    legendCheckBox->setChecked(true);
    layout->addWidget(legendCheckBox, row++, 1, Qt::AlignLeft);

    QCheckBox *titleCheckBox = new QCheckBox(QStringLiteral("Title"));
    connect(titleCheckBox, SIGNAL(toggled(bool)), this, SLOT(titleToggled(bool)));
    titleCheckBox->setChecked(true);
    layout->addWidget(titleCheckBox, row++, 1, Qt::AlignLeft);

    layout->addWidget(new QLabel(QStringLiteral("Chart theme:")), row, 0, Qt::AlignLeft);
    QComboBox *chartThemeComboBox = new QComboBox();
    chartThemeComboBox->addItem(QStringLiteral("Light"));
    chartThemeComboBox->addItem(QStringLiteral("Blue Cerulean"));
    chartThemeComboBox->addItem(QStringLiteral("Dark"));
    chartThemeComboBox->addItem(QStringLiteral("Brown Sand"));
    chartThemeComboBox->addItem(QStringLiteral("Blue Ncs"));
    chartThemeComboBox->addItem(QStringLiteral("High Contrast"));
    chartThemeComboBox->addItem(QStringLiteral("Blue Icy"));
    chartThemeComboBox->addItem(QStringLiteral("Qt"));
    connect(chartThemeComboBox,SIGNAL(currentIndexChanged(int)),this,SLOT(changeChartTheme(int)));
    layout->addWidget(chartThemeComboBox, row++, 1, Qt::AlignLeft);

    layout->addWidget(new QLabel(QStringLiteral("Axis X:")), row, 0, Qt::AlignLeft);
    QComboBox *axisXComboBox = new QComboBox();
    axisXComboBox->addItem(QStringLiteral("BarCategory"));
    axisXComboBox->addItem(QStringLiteral("DateTime"));
    axisXComboBox->addItem(QStringLiteral("Value"));
    connect(axisXComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(changeAxisX(int)));
    layout->addWidget(axisXComboBox, row++, 1, Qt::AlignLeft);

    return layout;
}

QGridLayout *MainWidget::createModelMapperControlsLayout()
{
    QGridLayout *layout = new QGridLayout();
    int row = 0;

    layout->addWidget(new QLabel(QStringLiteral("First series:")), row, 0, Qt::AlignLeft);

    QPushButton *attachModelMapperButton = new QPushButton(QStringLiteral("Attach model mapper"));
    connect(attachModelMapperButton, SIGNAL(clicked(bool)), this, SLOT(attachModelMapper()));
    layout->addWidget(attachModelMapperButton, row++, 1, Qt::AlignLeft);

    QPushButton *detachModelMappeButton = new QPushButton(QStringLiteral("Detach model mapper"));
    connect(detachModelMappeButton, SIGNAL(clicked(bool)), this, SLOT(detachModelMapper()));
    layout->addWidget(detachModelMappeButton, row++, 1, Qt::AlignLeft);

    QTableView *tableView = new QTableView();
    tableView->setMinimumSize(320, 480);
    tableView->setMaximumSize(320, 480);
    tableView->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
    tableView->verticalHeader()->setSectionResizeMode(QHeaderView::Stretch);
    Q_ASSERT_X(m_hModelMapper->model(), Q_FUNC_INFO, "Model is not initialized");
    tableView->setModel(m_hModelMapper->model());
    layout->addWidget(tableView, row++, 0, 1, 2, Qt::AlignLeft);

    layout->addItem(new QSpacerItem(1, 1, QSizePolicy::Fixed, QSizePolicy::Expanding), row++, 0);

    return layout;
}

qreal MainWidget::randomValue(int min, int max) const
{
    if (min > max)
        qSwap(min, max);
    return QRandomGenerator::global()->bounded(min, max);
}

QCandlestickSet *MainWidget::randomSet(qreal timestamp)
{
    QCandlestickSet *set = new QCandlestickSet(timestamp);
    set->setOpen(randomValue(4, 11));
    set->setHigh(randomValue(12, 15));
    set->setLow(randomValue(0, 3));
    set->setClose(randomValue(4, 11));

    return set;
}

void MainWidget::updateAxes()
{
    if (m_chart->axes().isEmpty())
        m_chart->createDefaultAxes();

    QCandlestickSeries *series;
    if (!m_chart->series().isEmpty())
        series = qobject_cast<QCandlestickSeries *>(m_chart->series().at(0));
    else
        series = nullptr;

    m_axisX = m_chart->axes(Qt::Horizontal).first();
    if (series && !series->sets().isEmpty()) {
        if (m_axisX->type() == QAbstractAxis::AxisTypeBarCategory) {
            QBarCategoryAxis *axisX = qobject_cast<QBarCategoryAxis *>(m_axisX);
            QStringList categories;
            for (int i = 0; i < series->sets().count(); ++i)
                categories.append(QString::number(i));
            axisX->setCategories(categories);
        } else { // QAbstractAxis::AxisTypeDateTime || QAbstractAxis::AxisTypeValue
            qreal msInMonth = 31.0 * 24.0 * 60.0 * 60.0 * 1000.0;
            qreal min = series->sets().first()->timestamp() - msInMonth;
            qreal max = series->sets().last()->timestamp() + msInMonth;
            QDateTime minDateTime = QDateTime::fromMSecsSinceEpoch(min);
            QDateTime maxDateTime = QDateTime::fromMSecsSinceEpoch(max);

            if (m_axisX->type() == QAbstractAxis::AxisTypeDateTime)
                m_axisX->setRange(minDateTime, maxDateTime);
            else
                m_axisX->setRange(min, max);
        }
    }

    m_axisY = m_chart->axes(Qt::Vertical).first();
    m_axisY->setMax(15);
    m_axisY->setMin(0);
}

void MainWidget::addSeries()
{
    if (m_chart->series().count() > 9) {
        qDebug() << "Maximum series count is 10";
        return;
    }

    QCandlestickSeries *series = new QCandlestickSeries();
    series->setName(QStringLiteral("S%1").arg(m_chart->series().count() + 1));
    series->setMaximumColumnWidth(m_maximumColumnWidth);
    series->setMinimumColumnWidth(m_minimumColumnWidth);
    series->setBodyOutlineVisible(m_bodyOutlineVisible);
    series->setBodyWidth(m_bodyWidth);
    series->setCapsVisible(m_capsVisible);
    series->setCapsWidth(m_capsWidth);

    if (m_chart->series().isEmpty()) {
        if (m_customIncreasingColor)
            series->setIncreasingColor(QColor(Qt::green));
        if (m_customDecreasingColor)
            series->setDecreasingColor(QColor(Qt::red));

        for (int month = 1; month <= 12; ++month) {
            QDateTime dateTime;
            dateTime.setDate(QDate(QDateTime::currentDateTime().date().year(), month, 1));
            dateTime.setTime(QTime(12, 34, 56, 789));

            QCandlestickSet *set = randomSet(dateTime.toMSecsSinceEpoch());
            series->append(set);
        }
    } else {
        QCandlestickSeries *s = qobject_cast<QCandlestickSeries *>(m_chart->series().at(0));
        for (int i = 0; i < s->sets().count(); ++i) {
            QCandlestickSet *set = randomSet(s->sets().at(i)->timestamp());
            series->append(set);
        }
    }

    m_chart->addSeries(series);

    updateAxes();
    if (!series->attachedAxes().contains(m_axisX))
        series->attachAxis(m_axisX);
    if (!series->attachedAxes().contains(m_axisY))
        series->attachAxis(m_axisY);
}

void MainWidget::removeSeries()
{
    if (m_chart->series().isEmpty()) {
        qDebug() << "Create a series first";
        return;
    }

    if (m_chart->series().count() == 1)
        detachModelMapper();

    QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(m_chart->series().last());
    m_chart->removeSeries(series);
    delete series;
    series = nullptr;
}

void MainWidget::removeAllSeries()
{
    if (m_chart->series().isEmpty()) {
        qDebug() << "Create a series first";
        return;
    }

    detachModelMapper();

    m_chart->removeAllSeries();
}

void MainWidget::addSet()
{
    if (m_chart->series().isEmpty()) {
        qDebug() << "Create a series first";
        return;
    }

    for (auto s : m_chart->series()) {
        QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(s);

        QDateTime dateTime;
        if (series->count()) {
            dateTime.setMSecsSinceEpoch(series->sets().last()->timestamp());
            dateTime = dateTime.addMonths(1);
        } else {
            dateTime.setDate(QDate(QDateTime::currentDateTime().date().year(), 1, 1));
            dateTime.setTime(QTime(12, 34, 56, 789));
        }

        QCandlestickSet *set = randomSet(dateTime.toMSecsSinceEpoch());
        series->append(set);
    }

    updateAxes();
}

void MainWidget::insertSet()
{
    if (m_chart->series().isEmpty()) {
        qDebug() << "Create a series first";
        return;
    }

    for (auto s : m_chart->series()) {
        QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(s);

        QDateTime dateTime;
        if (series->count()) {
            dateTime.setMSecsSinceEpoch(series->sets().first()->timestamp());
            dateTime = dateTime.addMonths(-1);
        } else {
            dateTime.setDate(QDate(QDateTime::currentDateTime().date().year(), 1, 1));
            dateTime.setTime(QTime(12, 34, 56, 789));
        }

        QCandlestickSet *set = randomSet(dateTime.toMSecsSinceEpoch());
        series->insert(0, set);
    }

    updateAxes();
}

void MainWidget::removeSet()
{
    if (m_chart->series().isEmpty()) {
        qDebug() << "Create a series first";
        return;
    }

    for (auto s : m_chart->series()) {
        QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(s);
        if (series->sets().isEmpty())
            qDebug() << "Create a set first";
        else
            series->remove(series->sets().last());
    }

    updateAxes();
}

void MainWidget::removeAllSets()
{
    if (m_chart->series().isEmpty()) {
        qDebug() << "Create a series first";
        return;
    }

    for (auto s : m_chart->series()) {
        QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(s);
        if (series->sets().isEmpty())
            qDebug() << "Create a set first";
        else
            series->clear();
    }

    updateAxes();
}

void MainWidget::changeMaximumColumnWidth(double width)
{
    m_maximumColumnWidth = width;
    for (auto s : m_chart->series()) {
        QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(s);
        series->setMaximumColumnWidth(m_maximumColumnWidth);
    }
}

void MainWidget::changeMinimumColumnWidth(double width)
{
    m_minimumColumnWidth = width;
    for (auto s : m_chart->series()) {
        QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(s);
        series->setMinimumColumnWidth(m_minimumColumnWidth);
    }
}

void MainWidget::bodyOutlineVisibleToggled(bool visible)
{
    m_bodyOutlineVisible = visible;
    for (auto s : m_chart->series()) {
        QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(s);
        series->setBodyOutlineVisible(m_bodyOutlineVisible);
    }
}

void MainWidget::capsVisibleToggled(bool visible)
{
    m_capsVisible = visible;
    for (auto s : m_chart->series()) {
        QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(s);
        series->setCapsVisible(m_capsVisible);
    }
}

void MainWidget::changeBodyWidth(double width)
{
    m_bodyWidth = width;
    for (auto s : m_chart->series()) {
        QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(s);
        series->setBodyWidth(m_bodyWidth);
    }
}

void MainWidget::changeCapsWidth(double width)
{
    m_capsWidth = width;
    for (auto s : m_chart->series()) {
        QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(s);
        series->setCapsWidth(m_capsWidth);
    }
}

void MainWidget::customIncreasingColorToggled(bool custom)
{
    m_customIncreasingColor = custom;

    if (m_chart->series().isEmpty())
        return;

    QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(m_chart->series().at(0));
    if (series) {
        QColor color = m_customIncreasingColor ? QColor(Qt::green) : QColor();
        series->setIncreasingColor(color);
    }
}

void MainWidget::customDecreasingColorToggled(bool custom)
{
    m_customDecreasingColor = custom;

    if (m_chart->series().isEmpty())
        return;

    QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(m_chart->series().at(0));
    if (series) {
        QColor color = m_customDecreasingColor ? QColor(Qt::red) : QColor();
        series->setDecreasingColor(color);
    }
}

void MainWidget::antialiasingToggled(bool enabled)
{
    m_chartView->setRenderHint(QPainter::Antialiasing, enabled);
}

void MainWidget::animationToggled(bool enabled)
{
    if (enabled)
        m_chart->setAnimationOptions(QChart::SeriesAnimations);
    else
        m_chart->setAnimationOptions(QChart::NoAnimation);
}

void MainWidget::legendToggled(bool visible)
{
    m_chart->legend()->setVisible(visible);
    if (visible)
        m_chart->legend()->setAlignment(Qt::AlignBottom);
}

void MainWidget::titleToggled(bool visible)
{
    if (visible)
        m_chart->setTitle(QStringLiteral("Candlestick Chart"));
    else
        m_chart->setTitle(QString());
}

void MainWidget::changeChartTheme(int themeIndex)
{
    if (themeIndex < QChart::ChartThemeLight || themeIndex > QChart::ChartThemeQt) {
        qDebug() << "Invalid chart theme index:" << themeIndex;
        return;
    }

    m_chart->setTheme((QChart::ChartTheme)(themeIndex));
}

void MainWidget::changeAxisX(int axisXIndex)
{
    if (m_axisX) {
        m_chart->removeAxis(m_axisX);
        delete m_axisX;
    }

    switch (axisXIndex) {
    case 0:
        m_axisX = new QBarCategoryAxis();
        break;
    case 1:
        m_axisX = new QDateTimeAxis();
        break;
    case 2:
        m_axisX = new QValueAxis();
        break;
    default:
        qDebug() << "Invalid axis x index:" << axisXIndex;
        return;
    }

    m_chart->addAxis(m_axisX, Qt::AlignBottom);

    updateAxes();

    for (auto series : m_chart->series())
        series->attachAxis(m_axisX);
}

void MainWidget::attachModelMapper()
{
    if (m_hModelMapper->series()) {
        qDebug() << "Model mapper is already attached";
        return;
    }

    if (m_chart->series().isEmpty())
        addSeries();

    QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(m_chart->series().at(0));
    Q_ASSERT(series);
    series->setName(QStringLiteral("SWMM")); // Series With Model Mapper

    CustomTableModel *model = qobject_cast<CustomTableModel *>(m_hModelMapper->model());
    for (auto set : series->sets())
        model->addRow(set);

    m_hModelMapper->setFirstSetRow(0);
    m_hModelMapper->setLastSetRow(model->rowCount() - 1);
    m_hModelMapper->setSeries(series);
}

void MainWidget::detachModelMapper()
{
    if (!m_hModelMapper->series())
        return;

    QCandlestickSeries *series = qobject_cast<QCandlestickSeries *>(m_hModelMapper->series());
    Q_ASSERT(series);
    series->setName(QStringLiteral("S1"));

    m_hModelMapper->setSeries(nullptr);
    m_hModelMapper->setFirstSetRow(-1);
    m_hModelMapper->setLastSetRow(-1);

    CustomTableModel *model = qobject_cast<CustomTableModel *>(m_hModelMapper->model());
    model->clearRows();
}
