#ifndef MATADOR_RESOLVER_FACTORY_HPP
#define MATADOR_RESOLVER_FACTORY_HPP

#include <unordered_map>

#include "matador/object/abstract_collection_resolver.hpp"
#include "matador/object/object_resolver_factory.hpp"
#include "matador/sql/internal/object_resolver_producer.hpp"

namespace matador::sql {
class executor;

class producer_resolver_factory : public object::object_resolver_factory {
public:
  std::shared_ptr<object::abstract_type_resolver> acquire_object_resolver(const std::type_index &type) override;
  void register_object_resolver(std::shared_ptr<object::abstract_type_resolver> &&resolver) override;

private:
  std::unordered_map<std::type_index, std::shared_ptr<object::abstract_type_resolver>> resolvers_;
};

struct composite_key {
  std::type_index root_type;
  std::type_index type;
  std::string name;

  bool operator==(const composite_key& other) const {
    return root_type == other.root_type &&
           type == other.type &&
           name == other.name;
  }
};

struct composite_key_hash {
  std::size_t operator()(const composite_key& k) const noexcept {
    const std::size_t h1 = std::hash<std::type_index>{}(k.root_type);
    const std::size_t h2 = std::hash<std::type_index>{}(k.type);
    const std::size_t h3 = std::hash<std::string>{}(k.name);

    // Klassische Hash-Kombination (Boost-Style)
    std::size_t seed = h1;
    seed ^= h2 + 0x9e3779b9 + (seed << 6) + (seed >> 2);
    seed ^= h3 + 0x9e3779b9 + (seed << 6) + (seed >> 2);

    return seed;
  }
};

class producer_collection_resolver_factory : public object::collection_resolver_factory {
public:
  std::shared_ptr<object::abstract_collection_resolver> acquire_collection_resolver(const std::type_index& root_type,
                                                                                    const std::type_index& element_type,
                                                                                    const std::string& collection_name) override;
  void register_collection_resolver(std::shared_ptr<object::abstract_collection_resolver>&& resolver) override;

private:
  std::unordered_map<composite_key, std::shared_ptr<object::abstract_collection_resolver>, composite_key_hash> resolvers_;
};
}
#endif //MATADOR_RESOLVER_FACTORY_HPP