#pragma once

#include "container.hpp"

#include "function_wrapper.hpp"
#include "object_wrapper.hpp"

#include <iostream>

template <typename Interface>
BindingBuilder<Interface>::BindingBuilder(Container *container) noexcept
	: _container(container)
{
}

template <typename Interface>
template <typename Impl>
requires Abstract<Interface> && std::derived_from<Impl, Interface>
void BindingBuilder<Interface>::to() noexcept
{
	using Wrapper = ObjectWrapper<Interface, Impl>;

	auto wrapper = Container::WrapperPtr<Wrapper>(new Wrapper(*_container));

	_container->add(
		ObjectType<Interface>(),
		std::dynamic_pointer_cast<IGenericWrapper>(wrapper)
	);
}

template <typename Interface>
template <typename FactoryFunc>
requires IsFactory<Interface> && std::constructible_from<Interface, FactoryFunc>
void BindingBuilder<Interface>::to_factory(FactoryFunc factory) noexcept
{
	using Wrapper = FunctionWrapper<Interface>;

	auto wrapper = Container::WrapperPtr<Wrapper>(new Wrapper(factory));

	_container->add(
		ObjectType<Interface>(),
		std::dynamic_pointer_cast<IGenericWrapper>(wrapper)
	);
}

template <typename Interface>
auto Container::bind() noexcept -> BindingBuilder<Interface>
{
	return BindingBuilder<Interface>(this);
}

template <typename Interface>
requires Abstract<Interface>
auto Container::get() const noexcept -> std::unique_ptr<Interface>
{
	ObjectType<Interface> interface_type;

	if (_bindings.count(interface_type) == 0)
	{
		std::cerr
			<< "Error: Tried to get a item from the container using unbound interface '"
			<< interface_type.name() << "'" << std::endl;
		exit(EXIT_FAILURE);
	}

	auto wrapper = std::dynamic_pointer_cast<IWrapper<std::unique_ptr<Interface>>>(
		_bindings.at(interface_type)
	);

	return wrapper->get();
}

template <typename AFactory>
requires IsFactory<AFactory>
auto Container::get() const noexcept -> AFactory
{
	auto wrapper =
		std::dynamic_pointer_cast<IWrapper<AFactory>>(_bindings.at(ObjectType<AFactory>())
		);

	return wrapper->get();
}