/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */

#pragma once

#include <concepts>
#include <utility>
#include <type_traits>

namespace OpenVulkano
{
	class RenderResource;

	class IRenderResourceHelper
	{
		friend class RenderResource;

	protected:
		void UpdateRenderResource(RenderResource& resource);

		void ResetRenderResource(RenderResource& resource);

		virtual void Release() = 0;
	};

	template <class T>
	concept Renderable = std::is_convertible_v<T, RenderResource&>;

	class RenderResource final
	{
		friend class IRenderResourceHelper;

		IRenderResourceHelper* renderObject = nullptr;

	public:
		RenderResource() = default;
		RenderResource(const RenderResource& ignored) { /* Do not copy, copy will be created by renderer */ }
		RenderResource(RenderResource&& move) : renderObject(move.renderObject) { move.renderObject = nullptr; }

		~RenderResource()
		{
			Release();
		}

		void Release()
		{
			if (!renderObject) return;
			renderObject->Release();
			renderObject = nullptr;
		}

		template<class T>
		T* As() { return static_cast<T*>(renderObject); }

		template<class T>
		operator T() { return static_cast<T>(renderObject); }

		operator bool() const { return renderObject; }
	};

	inline void IRenderResourceHelper::UpdateRenderResource(RenderResource& resource)
	{
		resource.renderObject = this;
	}

	inline void IRenderResourceHelper::ResetRenderResource(RenderResource& resource)
	{
		resource.renderObject = nullptr;
	}

	template<Renderable API_INDEPENDENT_CLASS>
	class IRenderResource : public IRenderResourceHelper
	{
		API_INDEPENDENT_CLASS* m_owner;

	protected:
		IRenderResource(API_INDEPENDENT_CLASS* owner) : m_owner(owner)
		{
			if (m_owner) UpdateRenderResource(GetOwnerResource());
		}

		IRenderResource(const IRenderResource<API_INDEPENDENT_CLASS>& copy) = delete;

		IRenderResource(IRenderResource<API_INDEPENDENT_CLASS>&& move)
			: m_owner(move.m_owner)
		{
			if (m_owner) UpdateRenderResource(GetOwnerResource());
			move.m_owner = nullptr;
		}

		RenderResource& GetOwnerResource() { return static_cast<RenderResource&>(*m_owner); }

	public:
		virtual ~IRenderResource()
		{
			if (m_owner) ResetRenderResource(GetOwnerResource());
		}

		void UpdateAddress(API_INDEPENDENT_CLASS* owner)
		{
			m_owner = owner;
		}

		operator API_INDEPENDENT_CLASS*() const { return m_owner; }

		API_INDEPENDENT_CLASS* GetOwner() const { return m_owner; }
	};

	/**
	 * This is a convenience class to create a Renderable class.
	 * You can also just create a RenderResource instance a conversion operator inside your own class to make it Renderable; and you probably want to delete your move constructor in that case.
	 */
	template <class T>
	class RenderResourceHolder
	{
		RenderResource renderResource;

	protected:
		RenderResourceHolder() = default;
		RenderResourceHolder(const RenderResourceHolder& ignored) {}
		RenderResourceHolder(RenderResourceHolder&& move)
				: renderResource(std::move(move.renderResource))
		{
			if (IRenderResource<T>* renderRes = renderResource)
				renderRes->UpdateAddress(static_cast<T*>(this));
		}

		~RenderResourceHolder() = default;

	public:
		operator RenderResource&() { return renderResource; }

		RenderResource& GetRenderResource() { return renderResource; }

		template<Renderable RT>
		operator RT() const { return renderResource; }

		bool HasRenderResource() const { return renderResource; }
	};
}