#ifndef ASYNCHRONOUS_CONTINUATION_H
#define ASYNCHRONOUS_CONTINUATION_H

#include <functional>
#include <memory>
#include <componentThread.h>
#include <lockSet.h>

namespace smo {

/**
 * AsynchronousContinuation - Template base class for async sequence management
 *
 * This template provides a common pattern for managing asynchronous operations
 * that need to maintain object lifetime through a sequence of callbacks.
 *
 * The template parameter OriginalCbFnT represents the signature of the original
 * callback that will be invoked when the async sequence completes.
 */
template <class OriginalCbFnT>
class AsynchronousContinuation
{
public:
	explicit AsynchronousContinuation(OriginalCbFnT originalCbFn)
	: originalCbFn(std::move(originalCbFn))
	{}

	/**		EXPLANATION:
	 * Each numbered segmented sequence persists the lifetime of the
	 * continuation object by taking a copy of its shared_ptr.
	 */
	typedef void (SegmentFn)(
		std::shared_ptr<AsynchronousContinuation<OriginalCbFnT>>
			lifetimePreservingConveyance);

public:
	OriginalCbFnT originalCbFn;
};

/**
 * NonPostedAsynchronousContinuation - For continuations that don't post
 * callbacks
 *
 * Note: We intentionally do not create a
 * LockedNonPostedAsynchronousContinuation because the only way to implement
 * non-posted locking would be via busy-spinning or sleeplocks. This would
 * eliminate the throughput advantage from our Qspinning mechanism, which
 * relies on re-posting to the io_service queue when locks are unavailable.
 */
template <class OriginalCbFnT>
class NonPostedAsynchronousContinuation
:	public AsynchronousContinuation<OriginalCbFnT>
{
public:
	explicit NonPostedAsynchronousContinuation(OriginalCbFnT originalCbFn)
	:	AsynchronousContinuation<OriginalCbFnT>(originalCbFn)
	{}

	/**
	 * @brief Call the original callback with perfect forwarding
	 * (immediate execution)
	 *
	 * This implementation calls the original callback immediately without
	 * posting to any thread or queue. Used for non-posted continuations.
	 *
	 * @param args Arguments to forward to the original callback
	 */
	template<typename... Args>
	void callOriginalCb(Args&&... args)
	{
		if (AsynchronousContinuation<OriginalCbFnT>::originalCbFn)
		{
			AsynchronousContinuation<OriginalCbFnT>::originalCbFn(
				std::forward<Args>(args)...);
		}
	}
};

template <class OriginalCbFnT>
class PostedAsynchronousContinuation
:	public AsynchronousContinuation<OriginalCbFnT>
{
public:
	PostedAsynchronousContinuation(
		const std::shared_ptr<ComponentThread> &caller,
		OriginalCbFnT originalCbFn)
	:	AsynchronousContinuation<OriginalCbFnT>(originalCbFn),
	caller(caller)
	{}

	template<typename... Args>
	void callOriginalCb(Args&&... args)
	{
		if (AsynchronousContinuation<OriginalCbFnT>::originalCbFn)
		{
			caller->getIoService().post(
				std::bind(
					AsynchronousContinuation<OriginalCbFnT>::originalCbFn,
					std::forward<Args>(args)...));
		}
	}

public:
	std::shared_ptr<ComponentThread> caller;
};

template <class OriginalCbFnT>
class SerializedAsynchronousContinuation
:	public PostedAsynchronousContinuation<OriginalCbFnT>
{
public:
	SerializedAsynchronousContinuation(
		const std::shared_ptr<ComponentThread> &caller,
		OriginalCbFnT originalCbFn,
		std::vector<std::reference_wrapper<SpinLock>> requiredLocks = {})
	:	PostedAsynchronousContinuation<OriginalCbFnT>(caller, originalCbFn),
		requiredLocks(*this, std::move(requiredLocks))
	{}

	template<typename... Args>
	void callOriginalCb(Args&&... args)
	{
		requiredLocks.release();
		PostedAsynchronousContinuation<OriginalCbFnT>::callOriginalCb(
			std::forward<Args>(args)...);
	}

public:
	LockSet<OriginalCbFnT> requiredLocks;
};

} // namespace smo

#endif // ASYNCHRONOUS_CONTINUATION_H