#include "kzqsettings.h"
#include "../src/kzsettings.h"
#include <qdebug.h>

class QFileSystemWatcher;


QVariant toQVariant(const KzSettingValue &value, QVariant defvalue = QVariant())
{
    if(std::holds_alternative<std::string>(value))
    {
        return QString::fromStdString(std::get<std::string>(value));
    }
    if(std::holds_alternative<int>(value))
    {
        return  std::get<int>(value);
    }
    if(std::holds_alternative<bool>(value))
    {
        return  std::get<bool>(value);
    }
    if(std::holds_alternative<double>(value))
    {
        return  std::get<double>(value);
    }
    return QVariant(defvalue);
}

KzSettingValue fromQVariant(const QVariant &value)
{
    if(value.isNull())
        return KzSettingValue();

    switch (value.userType())
    {
    case QMetaType::Int:
        return value.value<int>();

    case QMetaType::QString:
        return value.toString().toStdString();

    case QMetaType::Bool:
        return value.value<bool>();

    case QMetaType::Double:
        return value.value<double>();

    default:
        return false;
    }
}

QString toKeyCombined(const std::string& category, const std::string& key)
{
    QString keysig;
    if(category.size())
    {
        keysig.append("[");
        keysig.append(QString::fromStdString(category));
        keysig.append("]");
    }
    keysig.append(QString::fromStdString(key));
    return keysig;
}

KaZoe::KzQSettings::KzQSettings(QObject *parent)
    : QObject(parent)
    , m_settings(new KaZoe::KzSettings())
{
    m_settings->setNotifier([this](const std::string& category, const std::string& key, KzSettingValue value) {
        emit valueChanged(toKeyCombined(category, key), toQVariant(value));
    });
}

KaZoe::KzQSettings::~KzQSettings()
{
}

QVariant KaZoe::KzQSettings::getValue(const QString &id, QVariant defvalue)
{
    KaZoe::KzSettings settings;

    QString category;
    QString key = id;
    if(id.contains("/"))
    {
        qWarning() << "OLD Syntax used for " << id;
        QStringList tab = id.split("/");
        category = tab[0];
        tab.removeFirst();
        key = tab.join("/");
    }

    KzSettingValue value = settings.get(key.toStdString(), category.toStdString(), fromQVariant(defvalue));
    return toQVariant(value);
}

bool KaZoe::KzQSettings::setValue(const QString &id, const QVariant &value)
{
    KaZoe::KzSettings settings;
    bool ret;
    QString key = id;
    QString category;

    if(id.contains("/"))
    {
        qWarning() << "OLD Syntax used for " << id;
        QStringList tab = id.split("/");
        category = tab[0];
        tab.removeFirst();
        key = tab.join("/");
    }

    switch (value.userType())
    {
    case QMetaType::Int:
        ret = settings.set(key.toStdString(), value.value<int>(), category.toStdString());
        break;

    case QMetaType::QString:
        ret = settings.set(key.toStdString(), value.toString().toStdString(), category.toStdString());
        break;

    case QMetaType::Bool:
        ret = settings.set(key.toStdString(), value.value<bool>(), category.toStdString());
        break;

    case QMetaType::Double:
        ret = settings.set(key.toStdString(), value.value<double>(), category.toStdString());
        break;
    default:
        ret = false;
        break;
    }

    if(!ret)
    {
        qWarning() << "Settings ERROR: Write access not permitted for" << id << " with " << QString::fromStdString(settings.id());
        return false;
    }
    return true;
}


int KaZoe::KzQSettings::count() const
{
    if(m_settings) return m_settings->size();
    qWarning() << "Invalid object state for count";
    return -1;
}

QVariant KaZoe::KzQSettings::get(const QString &id, const QVariant defvalue) const
{
    if(!m_settings)
    {
        qWarning() << "Invalid object state for get";
        return QVariant();
    }

    QString category;
    QString key = id;
    if(id.contains("/"))
    {
        qWarning() << "OLD Syntax used for " << id;
        QStringList tab = id.split("/");
        category = tab[0];
        tab.removeFirst();
        key = tab.join("/");
    }

    KzSettingValue value = m_settings->get(key.toStdString(), category.toStdString(), fromQVariant(defvalue));
    return toQVariant(value);
}

bool KaZoe::KzQSettings::set(const QString &id, const QVariant &value)
{
    if(!m_settings)
    {
        qWarning() << "Invalid object state for set";
        return false;
    }
    bool ret;
    QString key = id;
    QString category;

    if(id.contains("/"))
    {
        qWarning() << "OLD Syntax used for " << id;
        QStringList tab = id.split("/");
        category = tab[0];
        tab.removeFirst();
        key = tab.join("/");
    }

    switch (value.userType())
    {
    case QMetaType::Int:
        ret = m_settings->set(key.toStdString(), value.value<int>(), category.toStdString());
        break;

    case QMetaType::QString:
        ret = m_settings->set(key.toStdString(), value.toString().toStdString(), category.toStdString());
        break;

    case QMetaType::Bool:
        ret = m_settings->set(key.toStdString(), value.value<bool>(), category.toStdString());
        break;

    case QMetaType::Double:
        ret = m_settings->set(key.toStdString(), value.value<double>(), category.toStdString());
        break;
    default:
        ret = false;
        break;
    }

    if(!ret)
    {
        qWarning() << "Settings ERROR: Write access not permitted for" << id << " with " << QString::fromStdString(m_settings->id());
        return false;
    }

    emit valueChanged(toKeyCombined(category.toStdString(), key.toStdString()), value);
    return true;
}

QStringList KaZoe::KzQSettings::keys() const
{
    if(!m_settings)
    {
        qWarning() << "Invalid object state for keys";
        return QStringList();
    }

    QStringList keys;
    m_settings->forEach([&keys](const KzSettingKey& key, const KzSettingValue& value) {
        std::string combined;
        if(!key.first.empty())
        {
            combined = "[" + key.first + "]";
        }
        combined.append(key.second);
        keys.append(QString::fromStdString(combined));
    });
    return keys;
}