/*
 * This file is part of smolbote. It's copyrighted by the contributors recorded
 * in the version control history of the file, available from its original
 * location: https://neueland.iserlohn-fortress.net/smolbote.hg
 *
 * SPDX-License-Identifier: GPL-3.0
 */

#include "configuration.h"
#include <QtCore/QStandardPaths>
#include <QFile>
#include <sstream>

using namespace libconfig;

Configuration::Configuration(const std::string &path, const std::string &home)
{
    m_userCfg = new Config();
    // prettier output
    m_userCfg->setOption(Config::OptionSemicolonSeparators, true);
    m_userCfg->setOption(Config::OptionColonAssignmentForGroups, false);
    m_userCfg->setOption(Config::OptionColonAssignmentForNonGroups, false);
    m_userCfg->setOption(Config::OptionOpenBraceOnSeparateLine, false);
    m_userCfg->setOption(Config::OptionFsync, true);

    m_userCfgPath = path;
    m_homePath = home;
}

Configuration::~Configuration()
{
    delete m_userCfg;
}

bool Configuration::read(const QString &path)
{
    QFile conf(path);

    if(!conf.open(QIODevice::ReadOnly)) {
        return false;
    }

    try {
        m_userCfg->readString(conf.readAll().toStdString());
        conf.close();
    } catch(const ParseException &e) {
        return false;
    }

    return true;
}

bool Configuration::writeIfNeeded(const std::string &path)
{
    if(!path.empty())
        m_userCfgPath = path;

    if(!changed)
        return true;

    try {
        m_userCfg->writeFile(m_userCfgPath.c_str());
    } catch(const FileIOException &e) {
        return false;
    }

    changed = false;
    return true;
}

std::vector<std::string> Configuration::childrenSettings(const char *name)
{
    std::vector<std::string> groupNames;
    const Setting &root = m_userCfg->lookup(name);

    for(const Setting &setting : root) {
        if(setting.getType() != Setting::TypeGroup) {
            groupNames.emplace_back(setting.getName());
            //groupNames.push_back(setting.getName());
        }
    }

    return groupNames;
}

std::vector<std::string> Configuration::childrenGroups(const char *name)
{
    std::vector<std::string> groupNames;
    const Setting &root = m_userCfg->lookup(name);

    for(const Setting &setting : root) {
        if(setting.getType() == Setting::TypeGroup) {
            groupNames.emplace_back(setting.getName());
            //groupNames.push_back(setting.getName());
        }
    }
    return groupNames;
}

std::string castToString(const libconfig::Setting &v)
{
    // cast depending on type
    // type checks are done during compile time
    switch(v.getType()) {
    case Setting::TypeNone:
        return std::string();

    case Setting::TypeInt:
        // int, unsigned int, long, unsigned long
        return std::to_string(static_cast<int32_t>(v));

    case Setting::TypeInt64:
        // int, unsigned int; long long, unsigned long long
        return std::to_string(static_cast<int64_t>(v));

    case Setting::TypeFloat:
        // float, double
        return std::to_string(static_cast<double>(v));

    case Setting::TypeString:
        // const char*, std::string
        return std::string(static_cast<const char *>(v));

    case Setting::TypeBoolean:
        // bool
        return std::string(static_cast<bool>(v) ? "true" : "false");

    case Setting::TypeGroup:
    case Setting::TypeArray:
    case Setting::TypeList:
        return std::string();
    }
}

void setFromString(libconfig::Setting &setting, const std::string &value)
{
    switch(setting.getType()) {
        case libconfig::Setting::TypeNone:
            break;

        case libconfig::Setting::TypeInt:
        case libconfig::Setting::TypeInt64:
            setting = std::stoi(value);
            break;

        case libconfig::Setting::TypeFloat:
            setting = std::stod(value);
            break;

        case libconfig::Setting::TypeString:
            setting = value.c_str();
            break;

        case libconfig::Setting::TypeBoolean:
            if(value == "true") {
                setting = true;
            } else if(value == "false") {
                setting = false;
            }
            break;

        case libconfig::Setting::TypeGroup:
            break;
        case libconfig::Setting::TypeArray:
            break;
        case libconfig::Setting::TypeList:
            break;
    }
}