namespace kcenon::common::concepts {

/// A type that can contain either a value or an error
template<typename T>
concept Resultable = requires(T t) {
    { t.is_ok() } -> std::convertible_to<bool>;
    { t.is_err() } -> std::convertible_to<bool>;
};

/// A type that supports unwrapping (value extraction)
template<typename T>
concept Unwrappable = requires(T t) {
    { t.unwrap() } -> std::same_as<typename T::value_type&>;
    { t.unwrap_or(std::declval<typename T::value_type>()) } 
        -> std::same_as<typename T::value_type>;
};

/// A type that supports monadic operations
template<typename T>
concept Mappable = requires(T t) {
    { t.map(std::declval<std::function<int(typename T::value_type)>>()) };
    { t.and_then(std::declval<std::function<T(typename T::value_type)>>()) };
};

}  // namespace concepts

namespace kcenon::common::concepts {

/// A callable type
template<typename F, typename... Args>
concept Invocable = std::invocable<F, Args...>;

/// A callable type that returns void
template<typename F, typename... Args>
concept VoidCallable = Invocable<F, Args...> && 
    std::is_void_v<std::invoke_result_t<F, Args...>>;

/// A type that satisfies the Job interface
template<typename T>
concept JobLike = requires(T t) {
    { t.execute() } -> std::same_as<VoidResult>;
    { t.get_name() } -> std::convertible_to<std::string>;
    { t.get_priority() } -> std::convertible_to<int>;
};

/// A type that satisfies the Executor interface
template<typename T>
concept ExecutorLike = requires(T t) {
    { t.worker_count() } -> std::convertible_to<size_t>;
    { t.is_running() } -> std::convertible_to<bool>;
    { t.pending_tasks() } -> std::convertible_to<size_t>;
    { t.shutdown(true) } -> std::same_as<void>;
};

}  // namespace concepts

namespace kcenon::common::concepts {

/// A type that can be used as an event
template<typename T>
concept EventType = std::is_class_v<T> && 
    std::is_copy_constructible_v<T>;

/// A type that can be used as an event handler
template<typename H, typename E>
concept EventHandler = requires(H h, const E& e) {
    { h(e) } -> std::same_as<void>;
};

/// A type that can be used as an event filter
template<typename F, typename E>
concept EventFilter = requires(F f, const E& e) {
    { f(e) } -> std::convertible_to<bool>;
};

}  // namespace concepts

namespace kcenon::common::concepts {

/// A type that can be used as a service interface
template<typename T>
concept ServiceInterface = std::is_polymorphic_v<T> &&
    std::has_virtual_destructor_v<T>;

/// A type that can be used as a service implementation
template<typename TImpl, typename TInterface>
concept ServiceImplementation = 
    ServiceInterface<TInterface> &&
    std::is_base_of_v<TInterface, TImpl> &&
    std::is_constructible_v<TImpl>;

/// A type that can be used as a factory function
template<typename F, typename T>
concept ServiceFactory = requires(F f, IServiceContainer& c) {
    { f(c) } -> std::convertible_to<std::shared_ptr<T>>;
};

}  // namespace concepts

namespace kcenon::common::concepts {

/// A serializable configuration type
template<typename T>
concept ConfigSection = 
    std::is_default_constructible_v<T> &&
    std::is_copy_constructible_v<T>;

/// A validatable type
template<typename T>
concept Validatable = requires(T t) {
    { t.validate() } -> std::same_as<VoidResult>;
};

}  // namespace concepts

template<typename F,
         typename = std::enable_if_t<
             std::is_invocable_v<F> &&
             std::is_void_v<std::invoke_result_t<F>>>>
void execute_async(F&& func);

template<VoidCallable F>
void execute_async(F&& func);

#if __cplusplus >= 202002L && defined(__cpp_concepts)
    #define COMMON_HAS_CONCEPTS 1
#else
    #define COMMON_HAS_CONCEPTS 0
#endif

#if COMMON_HAS_CONCEPTS
    template<concepts::VoidCallable F>
    void execute_async(F&& func);
#else
    template<typename F,
             typename = std::enable_if_t<std::is_invocable_v<F>>>
    void execute_async(F&& func);
#endif