theme_book.hpp

// Copyright Take Vos 2020-2021.
// 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 "theme_mode.hpp"
#include "style_sheet.hpp"
#include "style_sheet_parser.hpp"
#include "../log.hpp"
#include "../trace.hpp"
#include "../file/glob.hpp"
#include <limits>
#include <vector>
#include <memory>
#include <filesystem>
 
namespace hi { inline namespace v1 {
namespace detail {
 
class theme_book {
public:
    [[nodiscard]] inline static theme_book& global() noexcept;
 
    ~theme_book() = default;
    theme_book(theme_book const&) = delete;
    theme_book(theme_book&&) = delete;
    theme_book& operator=(theme_book const&) = delete;
    theme_book& operator=(theme_book&&) = delete;
    theme_book() = default;
 
    void register_theme_directory(std::filesystem::path const& path) noexcept
    {
        theme_dirs.push_back(path);
        refresh();
    }
 
    void refresh()
    {
        theme_files.clear();
 
        for (hilet& theme_dir : theme_dirs) {
            hilet theme_dir_glob = theme_dir / "**" / "*.css";
            for (hilet& path : glob(theme_dir_glob)) {
                try {
                    auto style_sheet = hi::parse_style_sheet(path);
                    hi_log_info("Found theme {}:{} at '{}'.", style_sheet.name, style_sheet.mode, path.generic_string());
 
                    theme_files.emplace_back(style_sheet.name, style_sheet.mode, path);
 
                } catch (std::exception const& e) {
                    hi_log_error("Unable to load theme from file '{}': {}", path.generic_string(), e.what());
                }
            }
        }
    }
 
    [[nodiscard]] std::vector<std::string> names() const noexcept
    {
        auto names = std::vector<std::string>{};
 
        for (hilet& theme_file : theme_files) {
            names.push_back(theme_file.name);
        }
 
        std::sort(names.begin(), names.end());
        hilet new_end = std::unique(names.begin(), names.end());
        names.erase(new_end, names.cend());
        return names;
    }
 
    [[nodiscard]] std::optional<std::filesystem::path> find(std::string name, theme_mode mode) const noexcept
    {
        // First find the exact match.
        auto it = find_if(theme_files.begin(), theme_files.end(), [&](hilet& entry) {
            return entry.name == name and entry.mode == mode;
        });
 
        if (it != theme_files.end()) {
            return it->path;
        }
 
        // Next find the theme for different modes..
        it = find_if(theme_files.begin(), theme_files.end(), [&](hilet& entry) {
            return entry.name == name;
        });
 
        if (it != theme_files.end()) {
            return it->path;
        }
 
        return std::nullopt;
    }
 
private:
    struct theme_file_entry {
        std::string name;
        hi::theme_mode mode;
        std::filesystem::path path;
    };
 
    std::vector<std::filesystem::path> theme_dirs;
    std::vector<theme_file_entry> theme_files;
};
 
[[nodiscard]] inline theme_book& theme_book::global() noexcept
{
    static auto r = theme_book{};
    return r;
}
 
} // namespace detail
 
inline void register_theme_directory(std::filesystem::path const& path) noexcept
{
    return detail::theme_book::global().register_theme_directory(path);
}
 
[[nodiscard]] inline std::vector<std::string> theme_names() noexcept
{
    return detail::theme_book::global().names();
}
 
inline void load_theme(std::string name, theme_mode mode) noexcept
{
    static std::optional<std::pair<std::string, theme_mode>> loaded_theme = std::nullopt;
 
    if (hilet path = detail::theme_book::global().find(name, mode)) {
        try {
            auto style_sheet = parse_style_sheet(*path);
            style_sheet.activate();
            loaded_theme = {name, mode};
            hi_log_info(
                "Theme {}:{} at '{}' activated successfully.", style_sheet.name, style_sheet.mode, path->generic_string());
 
        } catch (std::exception const& e) {
            if (loaded_theme) {
                hi_log_error("Unable to load theme {} from file '{}': {}", name, path->generic_string(), e.what());
            } else {
                hi_log_fatal(
                    "Unable to load theme {} from file '{}': {}. No theme loaded.", name, path->generic_string(), e.what());
            }
        }
 
    } else {
        if (loaded_theme) {
            hi_log_error("Unable to find a theme matching {}:{}.", name, mode);
        } else {
            hi_log_fatal("Unable to find a theme matching {}:{}. No theme loaded.", name, mode);
        }
    }
}
 
}} // namespace hi::v1