//
// Created by fly on 2021/11/25.
//

#include "DataTableModel.h"
#include <cmath>
#include <QFile>


DataTableModel::DataTableModel(QObject *parent) : QAbstractTableModel(parent) {
    m_headerData << "Name" << "Pearson" << "Pearson.Abs";
}

QVariant DataTableModel::headerData(int section, Qt::Orientation orientation, int role) const {
    if (role == Qt::DisplayRole && orientation == Qt::Horizontal) {
        return m_headerData.at(section);
    }
    return QAbstractItemModel::headerData(section, orientation, role);
}

int DataTableModel::rowCount(const QModelIndex &parent) const {
    return m_tableData.size();
}

int DataTableModel::columnCount(const QModelIndex &parent) const {
    return m_headerData.size();
}

QVariant DataTableModel::data(const QModelIndex &index, int role) const {
    if (!index.isValid())
        return QVariant();

    if (role == Qt::DisplayRole) {
        auto const &row = m_tableData.at(index.row());
        switch (index.column()) {
            case 0:
                return std::get<0>(row);
            case 1:
                return std::get<1>(row);
            case 2:
                return std::get<2>(row);
            default:
                break;
        }
    }

    return QVariant();
}

void DataTableModel::clear() {
    beginResetModel();
    m_tableData.clear();
    endResetModel();
}

void DataTableModel::InsertRow(QString name, double pearson) {
    beginInsertRows(QModelIndex(), m_tableData.size(), m_tableData.size());
    m_tableData.push_back({name, pearson, std::abs(pearson)});
    endInsertRows();
}

void DataTableModel::sort(int column, Qt::SortOrder order) {
    beginResetModel();
    std::sort(m_tableData.begin(), m_tableData.end(), [&](auto first, auto last) {
        if (order == Qt::AscendingOrder) {
            switch (column) {
                case 0:
                    return std::get<0>(first) > std::get<0>(last);
                    break;
                case 1:
                    return std::get<1>(first) > std::get<1>(last);
                    break;
                case 2:
                    return std::get<2>(first) > std::get<2>(last);
                    break;
                default:
                    break;
            }
        } else {
            switch (column) {
                case 0:
                    return std::get<0>(first) < std::get<0>(last);
                    break;
                case 1:
                    return std::get<1>(first) < std::get<1>(last);
                    break;
                case 2:
                    return std::get<2>(first) < std::get<2>(last);
                    break;
                default:
                    break;
            }
        }
        return false;
    });
    endResetModel();
//    QAbstractItemModel::sort(column, order);
}

bool DataTableModel::SaveFile(const QString &fileName) {
    QFile saveFile(fileName);
    if (saveFile.open(QFile::WriteOnly)) {
        auto header = QString("%1,%2,%3\r\n").arg(m_headerData.at(0)).arg(m_headerData.at(1)).arg(m_headerData.at(2));
        saveFile.write(header.toLocal8Bit());
        for (auto const &data: m_tableData) {
            auto strData = QString("%1,%2,%3\r\n").arg(std::get<0>(data)).arg(std::get<1>(data)).arg(std::get<2>(data));
            saveFile.write(strData.toLocal8Bit());
        }
        saveFile.close();
        return true;
    }

    return false;
}