//  SPDX-License-Identifier: MIT
//
//  EmulationStation Desktop Edition
//  ThemeData.h
//
//  Finds available themes on the file system and loads these,
//  including the parsing of individual theme components
//  (includes, features, variables, views, elements).
//

#ifndef ES_CORE_THEME_DATA_H
#define ES_CORE_THEME_DATA_H

#include "math/Misc.h"
#include "utils/FileSystemUtil.h"

#include <deque>
#include <map>
#include <memory>
#include <sstream>
#include <vector>

namespace pugi
{
    class xml_node;
}

template <typename T> class TextListComponent;

class GuiComponent;
class ImageComponent;
class NinePatchComponent;
class Sound;
class TextComponent;
class Window;

namespace ThemeFlags
{
    enum PropertyFlags : unsigned int {
        PATH = 1,
        POSITION = 2,
        SIZE = 4,
        ORIGIN = 8,
        COLOR = 16,
        FONT_PATH = 32,
        FONT_SIZE = 64,
        SOUND = 128,
        ALIGNMENT = 256,
        TEXT = 512,
        FORCE_UPPERCASE = 1024,
        LINE_SPACING = 2048,
        DELAY = 4096,
        Z_INDEX = 8192,
        ROTATION = 16384,
        VISIBLE = 32768,
        ALL = 0xFFFFFFFF
    };
}

class ThemeException : public std::exception
{
public:
    std::string msg;

    virtual const char* what() const throw() { return msg.c_str(); }

    template <typename T> friend ThemeException& operator<<(ThemeException& e, T msg);

    void setFiles(const std::deque<std::string>& deque)
    {
        *this << "From theme \"" << deque.front() << "\"";
        for (auto it = deque.cbegin() + 1; it != deque.cend(); it++)
            *this << " -> \"" << (*it) << "\"";
    }
};

template <typename T> ThemeException& operator<<(ThemeException& e, T appendMsg)
{
    std::stringstream ss;
    ss << e.msg << appendMsg;
    e.msg = ss.str();
    return e;
}

struct ThemeSet {
    std::string path;

    std::string getName() const { return Utils::FileSystem::getStem(path); }
    std::string getThemePath(const std::string& system) const
    {
        return path + "/" + system + "/theme.xml";
    }
};

class ThemeData
{
public:
    class ThemeElement
    {
    public:
        bool extra;
        std::string type;

        struct Property {
            void operator=(const glm::vec4& value)
            {
                r = value;
                const glm::vec4 initVector = value;
                v = glm::vec2(initVector.x, initVector.y);
            }
            void operator=(const glm::vec2& value) { v = value; }
            void operator=(const std::string& value) { s = value; }
            void operator=(const unsigned int& value) { i = value; }
            void operator=(const float& value) { f = value; }
            void operator=(const bool& value) { b = value; }

            glm::vec4 r;
            glm::vec2 v;
            std::string s;
            unsigned int i;
            float f;
            bool b;
        };

        std::map<std::string, Property> properties;

        template <typename T> const T get(const std::string& prop) const
        {
            if (std::is_same<T, glm::vec2>::value)
                return *(const T*)&properties.at(prop).v;
            else if (std::is_same<T, std::string>::value)
                return *(const T*)&properties.at(prop).s;
            else if (std::is_same<T, unsigned int>::value)
                return *(const T*)&properties.at(prop).i;
            else if (std::is_same<T, float>::value)
                return *(const T*)&properties.at(prop).f;
            else if (std::is_same<T, bool>::value)
                return *(const T*)&properties.at(prop).b;
            else if (std::is_same<T, glm::vec4>::value)
                return *(const T*)&properties.at(prop).r;
            return T();
        }

        bool has(const std::string& prop) const
        {
            return (properties.find(prop) != properties.cend());
        }
    };

private:
    class ThemeView
    {
    public:
        std::map<std::string, ThemeElement> elements;
        std::vector<std::string> orderedKeys;
    };

public:
    ThemeData();

    // Throws ThemeException.
    void loadFile(std::map<std::string, std::string> sysDataMap, const std::string& path);

    enum ElementPropertyType {
        NORMALIZED_RECT,
        NORMALIZED_PAIR,
        PATH,
        STRING,
        COLOR,
        FLOAT,
        BOOLEAN
    };

    bool hasView(const std::string& view);

    // If expectedType is an empty string, will do no type checking.
    const ThemeElement* getElement(const std::string& view,
                                   const std::string& element,
                                   const std::string& expectedType) const;

    static std::vector<GuiComponent*> makeExtras(const std::shared_ptr<ThemeData>& theme,
                                                 const std::string& view,
                                                 Window* window);

    static const std::shared_ptr<ThemeData>& getDefault();

    static std::map<std::string, ThemeSet> getThemeSets();
    static std::string getThemeFromCurrentSet(const std::string& system);

private:
    static std::map<std::string, std::map<std::string, ElementPropertyType>> sElementMap;
    static std::vector<std::string> sSupportedFeatures;
    static std::vector<std::string> sSupportedViews;

    std::deque<std::string> mPaths;
    float mVersion;

    void parseFeatures(const pugi::xml_node& themeRoot);
    void parseIncludes(const pugi::xml_node& themeRoot);
    void parseVariables(const pugi::xml_node& root);
    void parseViews(const pugi::xml_node& themeRoot);
    void parseView(const pugi::xml_node& viewNode, ThemeView& view);
    void parseElement(const pugi::xml_node& elementNode,
                      const std::map<std::string, ElementPropertyType>& typeMap,
                      ThemeElement& element);

    std::map<std::string, ThemeView> mViews;
};

#endif // ES_CORE_THEME_DATA_H