ui-builder.h

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2025-2026 Manuel Osorio
#pragma once
#include "flint/core/log.h"
#include "flint/ui/ui-context.h"
#include "flint/ui/ui-node.h"
#include "flint/ui/ui-parser.h"
 
#include <functional>
#include <memory>
#include <unordered_map>
#include <unordered_set>
 
namespace Flint {
  class UIBuilder {
    public:
      UIBuilder(IAssetLoader &assetLoader, SDL_GPUDevice *device);
      void build(UIContext &context, const Context &parsedData);
 
    private:
      IAssetLoader &m_assetLoader;
      UIContext    *m_rootContext = nullptr;
      using FactoryFunc = std::function<std::unique_ptr<UINode>(const Node *)>;
      std::unordered_map<std::string, FactoryFunc> m_registry;
 
      std::unordered_map<std::string, std::shared_ptr<GPUTexture>> m_textureCache;
      std::unordered_set<std::string>                              m_usedTextures;
 
      std::shared_ptr<GPUTexture> loadTexture(const std::string &src, SDL_GPUDevice *device);
 
      void registerComponent(const std::string                                   &type,
                             std::function<std::unique_ptr<UINode>(const Node &)> func) {
        m_registry[type] = [func = std::move(func)](const Node *n) -> std::unique_ptr<UINode> {
          return n ? func(*n) : nullptr;
        };
      }
 
      template <typename F, typename = std::enable_if_t<std::is_invocable_v<F>>>
      void registerComponent(const std::string &type, F &&func) {
        m_registry[type] = [func = std::forward<F>(func)](const Node *) -> std::unique_ptr<UINode> {
          return func();
        };
      }
 
      std::unique_ptr<UINode> buildNode(const Node &dataNode);
 
      void applyAttributes(UINode *node, const Node &dataNode);
 
      SDL_GPUDevice *m_device = nullptr;
  };
}