preferences.hpp

// Copyright Take Vos 2020-2022.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "../telemetry/telemetry.hpp"
#include "../observer/observer.hpp"
#include "../codec/codec.hpp"
#include "../dispatch/dispatch.hpp"
#include "../file/file.hpp"
#include "../macros.hpp"
#include <typeinfo>
#include <filesystem>
 
hi_export_module(hikogui.settings.preferences);
 
hi_export namespace hi::inline v1 {
class preferences;
 
namespace detail {
 
class preference_item_base {
public:
    preference_item_base(preferences& parent, std::string_view path) noexcept : _parent(parent), _path(path) {}
 
    preference_item_base(preference_item_base const&) = delete;
    preference_item_base(preference_item_base&&) = delete;
    preference_item_base& operator=(preference_item_base const&) = delete;
    preference_item_base& operator=(preference_item_base&&) = delete;
    virtual ~preference_item_base() = default;
 
    virtual void reset() noexcept = 0;
 
    void load() noexcept;
 
protected:
    preferences& _parent;
    jsonpath _path;
 
    [[nodiscard]] virtual datum encode() const noexcept = 0;
 
    virtual void decode(datum const& data) = 0;
};
 
template<typename T>
class preference_item : public preference_item_base {
public:
    preference_item(preferences& parent, std::string_view path, observer<T> const& value, T init) noexcept :
        preference_item_base(parent, path), _value(value), _init(std::move(init))
    {
        _value_cbt = _value.subscribe(
            [this](auto...) {
                if (auto tmp = this->encode(); not holds_alternative<std::monostate>(tmp)) {
                    this->_parent.write(_path, this->encode());
                } else {
                    this->_parent.remove(_path);
                }
            },
            callback_flags::local);
    }
 
    void reset() noexcept override
    {
        _value = _init;
    }
 
protected:
    [[nodiscard]] datum encode() const noexcept override
    {
        if (*_value != _init) {
            return hi::pickle<T>{}.encode(*_value);
        } else {
            return datum{std::monostate{}};
        }
    }
 
    void decode(datum const& data) override
    {
        _value = hi::pickle<T>{}.decode(data);
    }
 
private:
    T _init;
    observer<T> _value;
    callback<void(T)> _value_cbt;
};
 
} // namespace detail
 
class preferences {
public:
    mutable std::mutex mutex;
 
    preferences() noexcept : _location(), _data(datum::make_map()), _modified(false)
    {
        using namespace std::chrono_literals;
 
        _check_modified_cbt = loop::timer().repeat_function(5s, [this](auto...) {
            this->check_modified();
        });
    }
 
    preferences(std::filesystem::path location) noexcept : preferences()
    {
        load(location);
    }
 
    preferences(std::string_view location) : preferences(std::filesystem::path{location}) {}
    preferences(std::string const& location) : preferences(std::filesystem::path{location}) {}
    preferences(char const *location) : preferences(std::filesystem::path{location}) {}
 
    ~preferences()
    {
        save();
    }
 
    preferences(preferences const&) = delete;
    preferences(preferences&&) = delete;
    preferences& operator=(preferences const&) = delete;
    preferences& operator=(preferences&&) = delete;
 
    void save() const noexcept
    {
        auto const lock = std::scoped_lock(mutex);
        _save();
    }
 
    void save(std::filesystem::path location) noexcept
    {
        auto const lock = std::scoped_lock(mutex);
        _location = std::move(location);
        _save();
    }
 
    void load() noexcept
    {
        auto const lock = std::scoped_lock(mutex);
        _load();
    }
 
    void load(std::filesystem::path location) noexcept
    {
        auto const lock = std::scoped_lock(mutex);
        _location = std::move(location);
        _load();
    }
 
    void reset() noexcept
    {
        _data = datum::make_map();
        for (auto& item : _items) {
            item->reset();
        }
    }
    template<typename T>
    void add(std::string_view path, observer<T> const& item, T init = T{}) noexcept
    {
        auto item_ = std::make_unique<detail::preference_item<T>>(*this, path, item, std::move(init));
        item_->load();
        _items.push_back(std::move(item_));
    }
 
private:
    std::filesystem::path _location;
 
    datum _data;
 
    mutable bool _modified = false;
 
    std::vector<std::unique_ptr<detail::preference_item_base>> _items;
 
    callback<void()> _check_modified_cbt;
 
    void _load() noexcept
    {
        try {
            auto file = hi::file(_location, access_mode::open_for_read);
            auto text = file.read_string();
            _data = parse_JSON(text);
 
            for (auto& item : _items) {
                item->load();
            }
 
        } catch (io_error const& e) {
            hi_log_warning("Could not read preferences file. \"{}\"", e.what());
            reset();
 
        } catch (parse_error const& e) {
            hi_log_error("Could not parse preferences file. \"{}\"", e.what());
            reset();
        }
    }
 
    void _save() const noexcept
    {
        try {
            auto text = format_JSON(_data);
 
            auto tmp_location = _location;
            tmp_location += ".tmp";
 
            auto file = hi::file(tmp_location, access_mode::truncate_or_create_for_write | access_mode::rename);
            file.write(text);
            file.flush();
            file.rename(_location, true);
 
        } catch (io_error const& e) {
            hi_log_error("Could not save preferences to file. \"{}\"", e.what());
        }
 
        _modified = false;
    }
 
    void check_modified() noexcept
    {
        auto const lock = std::scoped_lock(mutex);
 
        if (_modified) {
            _save();
        }
    }
 
    void write(jsonpath const& path, datum const value) noexcept
    {
        auto const lock = std::scoped_lock(mutex);
        auto *v = _data.find_one_or_create(path);
        if (v == nullptr) {
            hi_log_fatal("Could not write '{}' to preference file '{}'", path, _location.string());
        }
 
        if (*v != value) {
            *v = value;
            _modified = true;
        }
    }
 
    datum read(jsonpath const& path) noexcept
    {
        auto const lock = std::scoped_lock(mutex);
        if (auto const *const r = _data.find_one(path)) {
            return *r;
        } else {
            return datum{std::monostate{}};
        }
    }
 
    void remove(jsonpath const& path) noexcept
    {
        auto const lock = std::scoped_lock(mutex);
        if (_data.remove(path)) {
            _modified = true;
        }
    }
 
    friend class detail::preference_item_base;
    template<typename T>
    friend class detail::preference_item;
};
 
inline void detail::preference_item_base::load() noexcept
{
    auto const value = this->_parent.read(_path);
    if (value.is_undefined()) {
        this->reset();
    } else {
        try {
            this->decode(value);
        } catch (std::exception const&) {
            hi_log_error("Could not decode preference {}, value {}", _path, value);
            this->reset();
        }
    }
}
 
} // namespace hi::inline v1