// Current: Multiple similar adapters
typed_adapter<T>      // Type-safe adapter
smart_adapter<T>      // Smart pointer aware
adapter_base          // Base class for custom adapters
callback_adapter<T>   // For callback-based APIs

// patterns/adapters/adapter.h

// Adapter configuration via traits
template<typename T>
struct adapter_traits {
    using value_type = T;
    using pointer_type = T*;
    using reference_type = T&;
    static constexpr bool is_smart_pointer = false;
    static constexpr bool supports_weak = false;
};

// Specialization for shared_ptr
template<typename T>
struct adapter_traits<std::shared_ptr<T>> {
    using value_type = T;
    using pointer_type = std::shared_ptr<T>;
    using reference_type = T&;
    static constexpr bool is_smart_pointer = true;
    static constexpr bool supports_weak = true;
    using weak_type = std::weak_ptr<T>;
};

// Specialization for unique_ptr
template<typename T>
struct adapter_traits<std::unique_ptr<T>> {
    using value_type = T;
    using pointer_type = std::unique_ptr<T>;
    using reference_type = T&;
    static constexpr bool is_smart_pointer = true;
    static constexpr bool supports_weak = false;
};

// Single unified adapter
template<typename T, typename Traits = adapter_traits<T>>
class adapter {
public:
    using value_type = typename Traits::value_type;
    using pointer_type = typename Traits::pointer_type;
    
    // Construct from value
    explicit adapter(T value) : value_(std::move(value)) {}
    
    // Access
    auto get() const noexcept -> decltype(auto) {
        if constexpr (Traits::is_smart_pointer) {
            return value_.get();
        } else {
            return &value_;
        }
    }
    
    auto operator*() const -> typename Traits::reference_type {
        if constexpr (Traits::is_smart_pointer) {
            return *value_;
        } else {
            return value_;
        }
    }
    
    auto operator->() const noexcept {
        return get();
    }
    
    // Weak reference support (only for shared_ptr)
    auto weak() const requires (Traits::supports_weak) {
        return typename Traits::weak_type(value_);
    }
    
    // Check validity
    explicit operator bool() const noexcept {
        if constexpr (Traits::is_smart_pointer) {
            return static_cast<bool>(value_);
        } else {
            return true;  // Value types are always valid
        }
    }
    
    // Type-safe casting
    template<typename U>
    auto as() const -> std::optional<adapter<U>> {
        if constexpr (std::is_base_of_v<U, value_type>) {
            return adapter<U>(static_cast<U>(*get()));
        } else if constexpr (Traits::is_smart_pointer) {
            if (auto casted = std::dynamic_pointer_cast<U>(value_)) {
                return adapter<std::shared_ptr<U>>(std::move(casted));
            }
        }
        return std::nullopt;
    }
    
private:
    T value_;
};

// Deduction guides
template<typename T>
adapter(T) -> adapter<T>;

template<typename T>
adapter(std::shared_ptr<T>) -> adapter<std::shared_ptr<T>>;

template<typename T>
adapter(std::unique_ptr<T>) -> adapter<std::unique_ptr<T>>;

// Factory functions for convenience
template<typename T, typename... Args>
auto make_adapter(Args&&... args) {
    return adapter<T>(T(std::forward<Args>(args)...));
}

template<typename T, typename... Args>
auto make_shared_adapter(Args&&... args) {
    return adapter(std::make_shared<T>(std::forward<Args>(args)...));
}

// Deprecated aliases
template<typename T>
using typed_adapter [[deprecated("Use adapter<T> instead")]] = adapter<T>;

template<typename T>
using smart_adapter [[deprecated("Use adapter<std::shared_ptr<T>> instead")]] = 
    adapter<std::shared_ptr<T>>;