#pragma once

#include "DI/interfaces/wrapper.hpp"

#include "DI/concepts.hpp"
#include "DI/object_type.hpp"

#include <concepts>
#include <memory>
#include <unordered_map>

class Container;

template <typename Interface>
class BindingBuilder
{
public:
	explicit BindingBuilder(Container *container) noexcept;

	template <typename Impl>
	requires std::derived_from<Impl, Interface>
	void to() noexcept;

	void to_factory(Interface func) noexcept;

private:
	Container *_container;
};

class Container
{
public:
	Container() noexcept = default;

	template <typename Type>
	using Ptr = std::shared_ptr<Type>;

	template <class Interface>
	auto bind() noexcept -> BindingBuilder<Interface>;

	template <class Interface>
	requires Abstract<Interface>
	auto get() const noexcept -> Ptr<Interface>;

	template <typename Interface>
	requires Function<Interface>
	auto get() const noexcept -> Interface;

	void add(BaseObjectType type, const Ptr<IGenericWrapper> &wrapper) noexcept;

private:
	std::unordered_map<BaseObjectType, Ptr<IGenericWrapper>, ObjectTypeHasher> _bindings;
};

#include "container.tpp"