#include "EnergyScaleDataModel.h"
#include <QJsonDocument>
#include <QFile>
#include <QVariant>

EnergyScaleDataModel::EnergyScaleDataModel(const QString& filename) : _data_filename(filename)
{
    _data_filename = filename;
}

EnergyScaleDataModel::~EnergyScaleDataModel()
{
}

void EnergyScaleDataModel::SetDataFilename(const QString& filename)
{
    _data_filename = filename;
}

const QString &EnergyScaleDataModel::GetDataFilename() const
{
    return _data_filename;
}

bool EnergyScaleDataModel::LoadData()
{
    QFile json_file(_data_filename);
    if (!json_file.open(QIODevice::ReadOnly | QIODevice::Text)) {
        return false;
    }
    QJsonDocument json_doc = QJsonDocument::fromJson(json_file.readAll());
    json_file.close();
    _energy_scale_data_map = json_doc.toVariant().toMap();
    return true;
}

bool EnergyScaleDataModel::SaveData()
{
    QJsonDocument energy_scale_fit_result_doc = QJsonDocument::fromVariant(_energy_scale_data_map);;
    QFile json_file(_data_filename);
    if (!json_file.open(QIODevice::WriteOnly | QIODevice::Text)) {
        return false;
    }
    json_file.write(energy_scale_fit_result_doc.toJson());
    json_file.close();
    return true;
}

bool EnergyScaleDataModel::IsValid()
{
    bool b_is_valid = true;
    if (this->_data_filename.isEmpty()) {
        b_is_valid &= false;
    }
    for (const QString& channel_name : _energy_scale_data_map.keys()) {
        const QVariantMap& energy_scale_ch_data_map = _energy_scale_data_map[channel_name].toMap();
        b_is_valid &= energy_scale_ch_data_map.contains("EnergyFitDegree");
        b_is_valid &= energy_scale_ch_data_map.contains("EnergyFitResultCoeffs");
        b_is_valid &= energy_scale_ch_data_map.contains("FwhmFitResultCoeffs");
        b_is_valid &= energy_scale_ch_data_map.contains("FitData");
    }
    return b_is_valid;
}

void EnergyScaleDataModel::SetName(const QString &name)
{
    _energy_scale_data_map["Name"] = name;
}

QString EnergyScaleDataModel::GetName()
{
    return _energy_scale_data_map.value("Name", QString()).toString();
}

void EnergyScaleDataModel::SetDescription(const QString &description)
{
    _energy_scale_data_map["Description"] = description;
}

QString EnergyScaleDataModel::GetDescription()
{
    return _energy_scale_data_map.value("Description", QString()).toString();
}

void EnergyScaleDataModel::SetChannelEnergyScaleDataMap(const QString& channel_name, const QVariantMap& ch_energy_scale_data_map)
{
    if (!ch_energy_scale_data_map.isEmpty()) {
        this->_energy_scale_data_map[channel_name] = ch_energy_scale_data_map;
    }
}

QVariantMap EnergyScaleDataModel::GetChannelEnergyScaleDataMap(const QString& channel_name)
{
    return _energy_scale_data_map.value(channel_name, QVariantMap()).toMap();
}

void EnergyScaleDataModel::SetEnergyFitDegree(const QString& channel_name, int fit_degree)
{
    if (!_energy_scale_data_map.contains(channel_name)) {
        _energy_scale_data_map[channel_name] = QVariantMap();
    }
    QVariantMap energy_scale_ch_data_map = _energy_scale_data_map[channel_name].toMap();
    if ( fit_degree == 0) {
        energy_scale_ch_data_map.remove("EnergyFitDegree");
    } else {
        energy_scale_ch_data_map["EnergyFitDegree"] = fit_degree;
    }
    _energy_scale_data_map[channel_name] = energy_scale_ch_data_map;
    cleanEmptyItem();
}

int EnergyScaleDataModel::GetEnergyFitDegree(const QString& channel_name)
{
    int fit_degree = 0;
    if (_energy_scale_data_map.contains(channel_name)) {
        const QVariantMap& energy_scale_ch_data_map = _energy_scale_data_map[channel_name].toMap();
        fit_degree = energy_scale_ch_data_map.value("EnergyFitDegree", 0).toInt();
    }
    return fit_degree;
}

void EnergyScaleDataModel::SetEnergyFitResultCoeffs(const QString& channel_name, std::vector<double> coeffs)
{
    if (!_energy_scale_data_map.contains(channel_name)) {
        _energy_scale_data_map[channel_name] = QVariantMap();
    }
    QVariantList coeffs_list;
    for (double coeff : coeffs) {
        coeffs_list.append(coeff);
    }
    QVariantMap energy_scale_ch_data_map = _energy_scale_data_map[channel_name].toMap();
    if ( coeffs_list.isEmpty() ) {
        energy_scale_ch_data_map.remove("EnergyFitResultCoeffs");
    } else {
        energy_scale_ch_data_map["EnergyFitResultCoeffs"] = coeffs_list;
    }
    _energy_scale_data_map[channel_name] = energy_scale_ch_data_map;
    cleanEmptyItem();
}

std::vector<double> EnergyScaleDataModel::GetEnergyFitResultCoeffs(const QString& channel_name)
{
    std::vector<double> coeffs;
    if (_energy_scale_data_map.contains(channel_name)) {
        const QVariantMap& energy_scale_ch_data_map = _energy_scale_data_map[channel_name].toMap();
        QVariantList coeffs_list = energy_scale_ch_data_map.value("EnergyFitResultCoeffs", QVariantList()).toList();
        for (QVariant coeff : coeffs_list) {
            coeffs.push_back(coeff.toDouble());
        }
    }
    return coeffs;
}

void EnergyScaleDataModel::SetFwhmFitResultCoeffs(const QString& channel_name, std::vector<double> coeffs)
{
    if (!_energy_scale_data_map.contains(channel_name)) {
        _energy_scale_data_map[channel_name] = QVariantMap();
    }
    QVariantList coeffs_list;
    for (double coeff : coeffs) {
        coeffs_list.append(coeff);
    }
    QVariantMap energy_scale_ch_data_map = _energy_scale_data_map[channel_name].toMap();
    if ( coeffs_list.isEmpty() ) {
        energy_scale_ch_data_map.remove("FwhmFitResultCoeffs");
    } else {
        energy_scale_ch_data_map["FwhmFitResultCoeffs"] = coeffs_list;
    }
    _energy_scale_data_map[channel_name] = energy_scale_ch_data_map;
    cleanEmptyItem();
}

std::vector<double> EnergyScaleDataModel::GetFwhmFitResultCoeffs(const QString& channel_name)
{
    std::vector<double> coeffs;
    if (_energy_scale_data_map.contains(channel_name)) {
        const QVariantMap& energy_scale_ch_data_map = _energy_scale_data_map[channel_name].toMap();
        QVariantList coeffs_list = energy_scale_ch_data_map.value("FwhmFitResultCoeffs", QVariantList()).toList();
        for (QVariant coeff : coeffs_list) {
            coeffs.push_back(coeff.toDouble());
        }
    }
    return coeffs;
}

void EnergyScaleDataModel::SetFitData(const QString& channel_name, const std::vector<std::vector<double> >& fit_data)
{
    if (!_energy_scale_data_map.contains(channel_name)) {
        _energy_scale_data_map[channel_name] = QVariantMap();
    }
    QVariantList fit_data_list;
    for (std::vector<double> fit : fit_data) {
        QVariantList fit_list;
        for (double value : fit) {
            fit_list.append(value);
        }
        fit_data_list.append(QVariant(fit_list));
    }
    QVariantMap energy_scale_ch_data_map = _energy_scale_data_map[channel_name].toMap();
    if ( fit_data_list.isEmpty() ) {
        energy_scale_ch_data_map.remove("FitData");
    } else {
        energy_scale_ch_data_map["FitData"] = fit_data_list;
    }
    _energy_scale_data_map[channel_name] = energy_scale_ch_data_map;
    cleanEmptyItem();
}

std::vector<std::vector<double> > EnergyScaleDataModel::GetFitData(const QString& channel_name)
{
    std::vector<std::vector<double> > fit_data;
    if (_energy_scale_data_map.contains(channel_name)) {
        const QVariantMap& energy_scale_ch_data_map = _energy_scale_data_map[channel_name].toMap();
        QVariantList fit_data_list = energy_scale_ch_data_map.value("FitData", QVariantList()).toList();
        for (QVariant fit_list : fit_data_list) {
            std::vector<double> fit;
            for (QVariant value : fit_list.toList()) {
                fit.push_back(value.toDouble());
            }
            fit_data.push_back(fit);
        }
    }
    return fit_data;
}

void EnergyScaleDataModel::cleanEmptyItem()
{
    for (auto it = _energy_scale_data_map.begin(); it != _energy_scale_data_map.end(); it++) {
        if (it.value().toMap().isEmpty()) {
            _energy_scale_data_map.remove(it.key());
        }
    }
}