#pragma once
#include "type_descriptor.hpp"
#include <algorithm>
#include <array>
#include <concepts>
#include <cstddef>
#include <functional>
#include <initializer_list>
#include <memory>
#include <limits>
#include <mutex>
#include <shared_mutex>
#include <span>
#include <stdexcept>
#include <string>
#include <string_view>
#include <typeinfo>
#include <type_traits>
#include <utility>
#include <vector>
namespace structive {
struct Null_Shared_Mutex {
    void lock() {}
    void unlock() {}
    void lock_shared() {}
    void unlock_shared() {}
};
struct Shared_Mutex_Policy {
    using mutex_type = std::shared_mutex;
};
struct No_Lock_Policy {
    using mutex_type = Null_Shared_Mutex;
};
template <class Mutex>
concept Shared_Lockable = requires(Mutex& mutex) {
    mutex.lock();
    mutex.unlock();
    mutex.lock_shared();
    mutex.unlock_shared();
};
template <class Policy>
concept Synchronization_Policy = requires {
    typename Policy::mutex_type;
} && Shared_Lockable<typename Policy::mutex_type>;
namespace detail {
template <class Mutex, bool Stores_Mutexes = !std::same_as<Mutex, Null_Shared_Mutex>>
class Mutex_Storage;
template <class Mutex>
class Mutex_Storage<Mutex, true> {
    std::unique_ptr<Mutex[]> mutexes_;
public:
    Mutex_Storage() = default;
    explicit Mutex_Storage(std::size_t count) : mutexes_(count ? std::make_unique<Mutex[]>(count) : nullptr) {}
    void reset(std::size_t count) {
        mutexes_ = count ? std::make_unique<Mutex[]>(count) : nullptr;
    }
    Mutex& get(std::size_t index) noexcept {
        return mutexes_[index];
    }
    Mutex& get(std::size_t index) const noexcept {
        return mutexes_[index];
    }
};
template <class Mutex>
class Mutex_Storage<Mutex, false> {
    static Mutex& mutex() noexcept {
        static Mutex value;
        return value;
    }
public:
    Mutex_Storage() = default;
    explicit Mutex_Storage(std::size_t) {}
    void reset(std::size_t) {}
    Mutex& get(std::size_t) noexcept {
        return mutex();
    }
    Mutex& get(std::size_t) const noexcept {
        return mutex();
    }
};
}
enum class Runtime_Access_Result {
    ok,
    unknown_property,
    not_readable,
    not_writable,
    type_mismatch
};
using Runtime_Read_Callback = void (*)(void*, std::size_t, std::string_view, const std::type_info&, const void*);
class Property_Object_Base {
    struct Runtime_Interface {
        const std::type_info& (*object_type)() noexcept;
        std::size_t (*property_count)() noexcept;
        Runtime_Access_Result (*read)(const Property_Object_Base&, std::string_view, void*, Runtime_Read_Callback);
        Runtime_Access_Result (*write)(Property_Object_Base&, std::string_view, const std::type_info&, const void*);
    };
    const Runtime_Interface* runtime_interface_{};
protected:
    explicit Property_Object_Base(const Runtime_Interface* runtime_interface) noexcept : runtime_interface_(runtime_interface) {}
    Property_Object_Base(const Property_Object_Base&) noexcept = default;
    Property_Object_Base(Property_Object_Base&&) noexcept = default;
    Property_Object_Base& operator=(const Property_Object_Base&) noexcept = default;
    Property_Object_Base& operator=(Property_Object_Base&&) noexcept = default;
    ~Property_Object_Base() = default;
    template <class Object, Synchronization_Policy Policy>
    friend class Property_Object;
public:
    const std::type_info& runtime_object_type() const noexcept {
        return runtime_interface_->object_type();
    }
    std::size_t runtime_property_count() const noexcept {
        return runtime_interface_->property_count();
    }
    Runtime_Access_Result runtime_read(std::string_view key, void* context, Runtime_Read_Callback callback) const {
        return runtime_interface_->read(*this, key, context, callback);
    }
    Runtime_Access_Result runtime_write(std::string_view key, const std::type_info& value_type, const void* value) {
        return runtime_interface_->write(*this, key, value_type, value);
    }
};
struct Property_Synchronization {
    Synchronization_Plan plan;
};
inline Property_Synchronization property_synchronization(Synchronization_Plan plan) {
    return {std::move(plan)};
}
template <class Object, Synchronization_Source_Type Source>
Property_Synchronization property_synchronization(Source&& source) requires Property_Described_Object<Object> {
    using Schema = type_descriptor_schema_t<Object>;
    return {materialize_synchronization_plan<Schema>(std::forward<Source>(source))};
}
struct Resolved_Synchronization_View {
    static constexpr std::size_t unsynchronized_slot = std::numeric_limits<std::size_t>::max();
    std::span<const std::size_t> lock_slots;
    std::size_t lock_count{};
    std::size_t slot(std::size_t index) const noexcept {
        return lock_slots[index];
    }
    bool uses_lock(std::size_t index) const noexcept {
        return slot(index) != unsynchronized_slot;
    }
};
template <class Derived, Synchronization_Policy Lock_Policy = Shared_Mutex_Policy>
class Property_Object : public Property_Object_Base {
public:
    using object_type = Derived;
    using mutex_type = typename Lock_Policy::mutex_type;
private:
    static constexpr bool uses_real_mutexes = !std::same_as<mutex_type, Null_Shared_Mutex>;
    struct Empty_Guard_Locks {};
    struct Dynamic_Lock_Targets {
        std::vector<std::size_t> slots;
        std::vector<std::size_t> unsynchronized_properties;
    };
    template <std::size_t Capacity>
    struct Static_Lock_Targets {
        std::array<std::size_t, Capacity> slots{};
        std::size_t slot_count{};
        std::array<std::size_t, Capacity> unsynchronized_properties{};
        std::size_t unsynchronized_count{};
    };
    std::unique_ptr<std::size_t[]> custom_lock_layout_;
    [[no_unique_address]] detail::Mutex_Storage<mutex_type> mutex_storage_;
    static const auto& default_resolved_synchronization() {
        static const auto resolved = resolve_synchronization_plan(type_descriptor<Derived>(), type_descriptor<Derived>().synchronization_plan());
        return resolved;
    }
    template <class Schema>
    void initialize(const Schema& schema, const Synchronization_Plan& plan) {
        auto resolved = resolve_synchronization_plan(schema, plan);
        auto layout = std::make_unique<std::size_t[]>(Schema::property_count + 1);
        layout[0] = resolved.lock_count;
        std::copy(resolved.lock_slots.begin(), resolved.lock_slots.end(), layout.get() + 1);
        custom_lock_layout_ = std::move(layout);
        mutex_storage_.reset(resolved.lock_count);
    }
    void copy_synchronization_from(const Property_Object& other) {
        using Schema = type_descriptor_schema_t<Derived>;
        if (other.custom_lock_layout_) {
            auto layout = std::make_unique<std::size_t[]>(Schema::property_count + 1);
            std::copy_n(other.custom_lock_layout_.get(), Schema::property_count + 1, layout.get());
            custom_lock_layout_ = std::move(layout);
        } else {
            custom_lock_layout_.reset();
        }
        mutex_storage_.reset(lock_count());
    }
    std::size_t lock_count() const noexcept {
        return custom_lock_layout_ ? custom_lock_layout_[0] : default_resolved_synchronization().lock_count;
    }
    std::size_t slot(std::size_t index) const noexcept {
        return custom_lock_layout_ ? custom_lock_layout_[index + 1] : default_resolved_synchronization().slot(index);
    }
    mutex_type& mutex(std::size_t index) noexcept {
        return mutex_storage_.get(index);
    }
    mutex_type& mutex(std::size_t index) const noexcept {
        return mutex_storage_.get(index);
    }
    template <std::size_t Capacity>
    static void sort_unique_prefix(std::array<std::size_t, Capacity>& values, std::size_t& count) {
        for (std::size_t index = 1; index < count; ++index) {
            auto value = values[index];
            auto position = index;
            while (position > 0 && value < values[position - 1]) {
                values[position] = values[position - 1];
                --position;
            }
            values[position] = value;
        }
        if (count == 0) {
            return;
        }
        std::size_t write = 1;
        for (std::size_t read = 1; read < count; ++read) {
            if (values[read] != values[write - 1]) {
                values[write++] = values[read];
            }
        }
        count = write;
    }
    static bool runtime_property_readable(std::size_t index) {
        using Schema = type_descriptor_schema_t<Derived>;
        static const auto table = []<std::size_t... Index>(std::index_sequence<Index...>) {
            return std::array<bool, Schema::property_count>{Schema::template property_type<Index>::readable...};
        }(std::make_index_sequence<Schema::property_count>{});
        return table[index];
    }
    static bool runtime_property_writable(std::size_t index) {
        using Schema = type_descriptor_schema_t<Derived>;
        static const auto table = []<std::size_t... Index>(std::index_sequence<Index...>) {
            return std::array<bool, Schema::property_count>{Schema::template property_type<Index>::writable...};
        }(std::make_index_sequence<Schema::property_count>{});
        return table[index];
    }
    Dynamic_Lock_Targets collect_dynamic_lock_targets(std::span<const std::string_view> keys, bool shared_access) const {
        using Schema = type_descriptor_schema_t<Derived>;
        Dynamic_Lock_Targets targets;
        targets.slots.reserve(keys.size());
        targets.unsynchronized_properties.reserve(keys.size());
        for (auto key : keys) {
            auto index = schema_property_index<Schema>(key);
            if (!index) {
                throw std::invalid_argument("Unknown property: " + std::string(key));
            }
            bool allowed = shared_access ? runtime_property_readable(*index) : runtime_property_writable(*index);
            if (!allowed) {
                throw std::invalid_argument(std::string(shared_access ? "Property is not readable: " : "Property is not writable: ") + std::string(key));
            }
            auto lock_slot = slot(*index);
            if (lock_slot == Resolved_Synchronization_View::unsynchronized_slot) {
                targets.unsynchronized_properties.push_back(*index);
            } else {
                targets.slots.push_back(lock_slot);
            }
        }
        std::sort(targets.slots.begin(), targets.slots.end());
        targets.slots.erase(std::unique(targets.slots.begin(), targets.slots.end()), targets.slots.end());
        std::sort(targets.unsynchronized_properties.begin(), targets.unsynchronized_properties.end());
        targets.unsynchronized_properties.erase(std::unique(targets.unsynchronized_properties.begin(), targets.unsynchronized_properties.end()), targets.unsynchronized_properties.end());
        return targets;
    }
    template <bool Shared_Access, std::size_t... Index>
    Static_Lock_Targets<sizeof...(Index)> collect_static_lock_targets() const {
        using Schema = type_descriptor_schema_t<Derived>;
        static_assert(((Shared_Access ? Schema::template property_type<Index>::readable : Schema::template property_type<Index>::writable) && ...));
        Static_Lock_Targets<sizeof...(Index)> targets;
        auto collect = [&]<std::size_t Property_Index>() {
            auto lock_slot = slot(Property_Index);
            if (lock_slot == Resolved_Synchronization_View::unsynchronized_slot) {
                targets.unsynchronized_properties[targets.unsynchronized_count++] = Property_Index;
            } else {
                targets.slots[targets.slot_count++] = lock_slot;
            }
        };
        (collect.template operator()<Index>(), ...);
        sort_unique_prefix(targets.slots, targets.slot_count);
        sort_unique_prefix(targets.unsynchronized_properties, targets.unsynchronized_count);
        return targets;
    }
    template <bool Shared_Access>
    auto collect_all_static_lock_targets() const {
        using Schema = type_descriptor_schema_t<Derived>;
        Static_Lock_Targets<Schema::property_count> targets;
        auto collect = [&]<std::size_t Index>() {
            constexpr bool allowed = Shared_Access ? Schema::template property_type<Index>::readable : Schema::template property_type<Index>::writable;
            if constexpr (allowed) {
                auto lock_slot = slot(Index);
                if (lock_slot == Resolved_Synchronization_View::unsynchronized_slot) {
                    targets.unsynchronized_properties[targets.unsynchronized_count++] = Index;
                } else {
                    targets.slots[targets.slot_count++] = lock_slot;
                }
            }
        };
        [&]<std::size_t... Index>(std::index_sequence<Index...>) {
            (collect.template operator()<Index>(), ...);
        }(std::make_index_sequence<Schema::property_count>{});
        sort_unique_prefix(targets.slots, targets.slot_count);
        sort_unique_prefix(targets.unsynchronized_properties, targets.unsynchronized_count);
        return targets;
    }
    template <std::size_t Index, class View>
    decltype(auto) read_unlocked(const View& view) const {
        using Schema = type_descriptor_schema_t<Derived>;
        const auto& descriptor = type_descriptor<Derived>().template property<Index>();
        using Accessor = typename Schema::template property_type<Index>::accessor_type;
        if constexpr (Accessor::synchronized_view_read) {
            return descriptor.accessor.read(view);
        } else {
            return descriptor.accessor.read(static_cast<const Derived&>(*this));
        }
    }
    template <std::size_t Index, class Value>
    void write_unlocked(Value&& value) {
        const auto& descriptor = type_descriptor<Derived>().template property<Index>();
        descriptor.accessor.write(static_cast<Derived&>(*this), std::forward<Value>(value));
    }
    class Single_Read_View {
        const Property_Object* owner_{};
        std::size_t property_index_{};
        std::size_t lock_slot_{};
    public:
        Single_Read_View(const Property_Object& owner, std::size_t property_index, std::size_t lock_slot) : owner_(&owner), property_index_(property_index), lock_slot_(lock_slot) {}
        template <auto Member>
        decltype(auto) get() const {
            using Schema = type_descriptor_schema_t<Derived>;
            constexpr auto index = schema_member_property_index_v<Schema, Member>;
            static_assert(index < Schema::property_count);
            using Property = typename Schema::template property_type<index>;
            static_assert(Property::readable);
            if constexpr (!Property::writable && !Property::accessor_type::synchronized_view_read) {
                return owner_->template read_unlocked<index>(*this);
            }
            if (owner_->slot(index) != lock_slot_ || (lock_slot_ == Resolved_Synchronization_View::unsynchronized_slot && index != property_index_)) {
                throw std::logic_error("Computed property reads outside its synchronization slot");
            }
            return owner_->template read_unlocked<index>(*this);
        }
        template <Fixed_String Key>
        decltype(auto) get_key() const {
            using Schema = type_descriptor_schema_t<Derived>;
            constexpr auto index = schema_property_index_v<Schema, Key>;
            static_assert(index < Schema::property_count);
            using Property = typename Schema::template property_type<index>;
            static_assert(Property::readable);
            if constexpr (!Property::writable && !Property::accessor_type::synchronized_view_read) {
                return owner_->template read_unlocked<index>(*this);
            }
            if (owner_->slot(index) != lock_slot_ || (lock_slot_ == Resolved_Synchronization_View::unsynchronized_slot && index != property_index_)) {
                throw std::logic_error("Computed property reads outside its synchronization slot");
            }
            return owner_->template read_unlocked<index>(*this);
        }
    };
    template <std::size_t Index>
    auto read_one() const {
        using Schema = type_descriptor_schema_t<Derived>;
        static_assert(Schema::template property_type<Index>::readable);
        using Property = typename Schema::template property_type<Index>;
        using Value = typename Property::value_type;
        if constexpr ((!Property::writable && !Property::accessor_type::synchronized_view_read) || (!uses_real_mutexes && !Property::accessor_type::synchronized_view_read)) {
            return Value(read_unlocked<Index>(*this));
        }
        auto lock_slot = slot(Index);
        Single_Read_View view{*this, Index, lock_slot};
        if constexpr (!uses_real_mutexes) {
            return Value(read_unlocked<Index>(view));
        }
        if (lock_slot == Resolved_Synchronization_View::unsynchronized_slot) {
            return Value(read_unlocked<Index>(view));
        }
        std::shared_lock lock{mutex(lock_slot)};
        return Value(read_unlocked<Index>(view));
    }
    template <std::size_t Index, class Value>
    void write_one(Value&& value) {
        using Schema = type_descriptor_schema_t<Derived>;
        static_assert(Schema::template property_type<Index>::writable);
        if constexpr (!uses_real_mutexes) {
            write_unlocked<Index>(std::forward<Value>(value));
            return;
        }
        auto lock_slot = slot(Index);
        if (lock_slot == Resolved_Synchronization_View::unsynchronized_slot) {
            write_unlocked<Index>(std::forward<Value>(value));
            return;
        }
        std::unique_lock lock{mutex(lock_slot)};
        write_unlocked<Index>(std::forward<Value>(value));
    }
private:
    class Basic_Read_Guard {
        const Property_Object* owner_{};
        std::vector<std::size_t> slots_;
        std::vector<std::size_t> unsynchronized_properties_;
        [[no_unique_address]] std::conditional_t<uses_real_mutexes, std::vector<std::shared_lock<mutex_type>>, Empty_Guard_Locks> locks_;
        bool holds(std::size_t index) const {
            auto lock_slot = owner_->slot(index);
            if (lock_slot == Resolved_Synchronization_View::unsynchronized_slot) {
                return std::binary_search(unsynchronized_properties_.begin(), unsynchronized_properties_.end(), index);
            }
            return std::binary_search(slots_.begin(), slots_.end(), lock_slot);
        }
        friend class Property_Object;
        Basic_Read_Guard(const Property_Object& owner, Dynamic_Lock_Targets targets) : owner_(&owner), slots_(std::move(targets.slots)), unsynchronized_properties_(std::move(targets.unsynchronized_properties)) {
            if constexpr (uses_real_mutexes) {
                locks_.reserve(slots_.size());
                for (auto lock_slot : slots_) {
                    locks_.emplace_back(owner_->mutex(lock_slot));
                }
            }
        }
    public:
        template <std::size_t Index>
        decltype(auto) get_index() const {
            using Schema = type_descriptor_schema_t<Derived>;
            static_assert(Index < Schema::property_count);
            static_assert(Schema::template property_type<Index>::readable);
            if (!holds(Index)) {
                throw std::logic_error("Property is outside the held synchronization set");
            }
            return owner_->template read_unlocked<Index>(*this);
        }
        template <auto Member>
        decltype(auto) get() const {
            using Schema = type_descriptor_schema_t<Derived>;
            constexpr auto index = schema_member_property_index_v<Schema, Member>;
            static_assert(index < Schema::property_count);
            return get_index<index>();
        }
        template <Fixed_String Key>
        decltype(auto) get_key() const {
            using Schema = type_descriptor_schema_t<Derived>;
            constexpr auto index = schema_property_index_v<Schema, Key>;
            static_assert(index < Schema::property_count);
            return get_index<index>();
        }
    };
    class Basic_Write_Guard {
        Property_Object* owner_{};
        std::vector<std::size_t> slots_;
        std::vector<std::size_t> unsynchronized_properties_;
        [[no_unique_address]] std::conditional_t<uses_real_mutexes, std::vector<std::unique_lock<mutex_type>>, Empty_Guard_Locks> locks_;
        bool holds(std::size_t index) const {
            auto lock_slot = owner_->slot(index);
            if (lock_slot == Resolved_Synchronization_View::unsynchronized_slot) {
                return std::binary_search(unsynchronized_properties_.begin(), unsynchronized_properties_.end(), index);
            }
            return std::binary_search(slots_.begin(), slots_.end(), lock_slot);
        }
        friend class Property_Object;
        Basic_Write_Guard(Property_Object& owner, Dynamic_Lock_Targets targets) : owner_(&owner), slots_(std::move(targets.slots)), unsynchronized_properties_(std::move(targets.unsynchronized_properties)) {
            if constexpr (uses_real_mutexes) {
                locks_.reserve(slots_.size());
                for (auto lock_slot : slots_) {
                    locks_.emplace_back(owner_->mutex(lock_slot));
                }
            }
        }
    public:
        template <std::size_t Index>
        decltype(auto) get_index() const {
            using Schema = type_descriptor_schema_t<Derived>;
            static_assert(Index < Schema::property_count);
            static_assert(Schema::template property_type<Index>::readable);
            if (!holds(Index)) {
                throw std::logic_error("Property is outside the held synchronization set");
            }
            return owner_->template read_unlocked<Index>(*this);
        }
        template <auto Member>
        decltype(auto) get() const {
            using Schema = type_descriptor_schema_t<Derived>;
            constexpr auto index = schema_member_property_index_v<Schema, Member>;
            static_assert(index < Schema::property_count);
            return get_index<index>();
        }
        template <Fixed_String Key>
        decltype(auto) get_key() const {
            using Schema = type_descriptor_schema_t<Derived>;
            constexpr auto index = schema_property_index_v<Schema, Key>;
            static_assert(index < Schema::property_count);
            return get_index<index>();
        }
        template <std::size_t Index, class Value>
        void set_index(Value&& value) {
            using Schema = type_descriptor_schema_t<Derived>;
            static_assert(Index < Schema::property_count);
            static_assert(Schema::template property_type<Index>::writable);
            if (!holds(Index)) {
                throw std::logic_error("Property is outside the held synchronization set");
            }
            owner_->template write_unlocked<Index>(std::forward<Value>(value));
        }
        template <auto Member, class Value>
        void set(Value&& value) {
            using Schema = type_descriptor_schema_t<Derived>;
            constexpr auto index = schema_member_property_index_v<Schema, Member>;
            static_assert(index < Schema::property_count);
            set_index<index>(std::forward<Value>(value));
        }
        template <Fixed_String Key, class Value>
        void set_key(Value&& value) {
            using Schema = type_descriptor_schema_t<Derived>;
            constexpr auto index = schema_property_index_v<Schema, Key>;
            static_assert(index < Schema::property_count);
            set_index<index>(std::forward<Value>(value));
        }
    };
    template <std::size_t Capacity>
    class Static_Read_Guard {
        const Property_Object* owner_{};
        Static_Lock_Targets<Capacity> targets_;
        [[no_unique_address]] std::conditional_t<uses_real_mutexes, std::array<std::shared_lock<mutex_type>, Capacity>, Empty_Guard_Locks> locks_{};
        bool holds(std::size_t index) const {
            auto lock_slot = owner_->slot(index);
            if (lock_slot == Resolved_Synchronization_View::unsynchronized_slot) {
                return std::binary_search(targets_.unsynchronized_properties.begin(), targets_.unsynchronized_properties.begin() + static_cast<std::ptrdiff_t>(targets_.unsynchronized_count), index);
            }
            return std::binary_search(targets_.slots.begin(), targets_.slots.begin() + static_cast<std::ptrdiff_t>(targets_.slot_count), lock_slot);
        }
        friend class Property_Object;
        Static_Read_Guard(const Property_Object& owner, Static_Lock_Targets<Capacity> targets) : owner_(&owner), targets_(std::move(targets)) {
            if constexpr (uses_real_mutexes) {
                for (std::size_t index = 0; index < targets_.slot_count; ++index) {
                    locks_[index] = std::shared_lock<mutex_type>{owner_->mutex(targets_.slots[index])};
                }
            }
        }
    public:
        template <std::size_t Index>
        decltype(auto) get_index() const {
            using Schema = type_descriptor_schema_t<Derived>;
            static_assert(Index < Schema::property_count);
            static_assert(Schema::template property_type<Index>::readable);
            if (!holds(Index)) {
                throw std::logic_error("Property is outside the held synchronization set");
            }
            return owner_->template read_unlocked<Index>(*this);
        }
        template <auto Member>
        decltype(auto) get() const {
            using Schema = type_descriptor_schema_t<Derived>;
            constexpr auto index = schema_member_property_index_v<Schema, Member>;
            static_assert(index < Schema::property_count);
            return get_index<index>();
        }
        template <Fixed_String Key>
        decltype(auto) get_key() const {
            using Schema = type_descriptor_schema_t<Derived>;
            constexpr auto index = schema_property_index_v<Schema, Key>;
            static_assert(index < Schema::property_count);
            return get_index<index>();
        }
    };
    template <std::size_t Capacity>
    class Static_Write_Guard {
        Property_Object* owner_{};
        Static_Lock_Targets<Capacity> targets_;
        [[no_unique_address]] std::conditional_t<uses_real_mutexes, std::array<std::unique_lock<mutex_type>, Capacity>, Empty_Guard_Locks> locks_{};
        bool holds(std::size_t index) const {
            auto lock_slot = owner_->slot(index);
            if (lock_slot == Resolved_Synchronization_View::unsynchronized_slot) {
                return std::binary_search(targets_.unsynchronized_properties.begin(), targets_.unsynchronized_properties.begin() + static_cast<std::ptrdiff_t>(targets_.unsynchronized_count), index);
            }
            return std::binary_search(targets_.slots.begin(), targets_.slots.begin() + static_cast<std::ptrdiff_t>(targets_.slot_count), lock_slot);
        }
        friend class Property_Object;
        Static_Write_Guard(Property_Object& owner, Static_Lock_Targets<Capacity> targets) : owner_(&owner), targets_(std::move(targets)) {
            if constexpr (uses_real_mutexes) {
                for (std::size_t index = 0; index < targets_.slot_count; ++index) {
                    locks_[index] = std::unique_lock<mutex_type>{owner_->mutex(targets_.slots[index])};
                }
            }
        }
    public:
        template <std::size_t Index>
        decltype(auto) get_index() const {
            using Schema = type_descriptor_schema_t<Derived>;
            static_assert(Index < Schema::property_count);
            static_assert(Schema::template property_type<Index>::readable);
            if (!holds(Index)) {
                throw std::logic_error("Property is outside the held synchronization set");
            }
            return owner_->template read_unlocked<Index>(*this);
        }
        template <auto Member>
        decltype(auto) get() const {
            using Schema = type_descriptor_schema_t<Derived>;
            constexpr auto index = schema_member_property_index_v<Schema, Member>;
            static_assert(index < Schema::property_count);
            return get_index<index>();
        }
        template <Fixed_String Key>
        decltype(auto) get_key() const {
            using Schema = type_descriptor_schema_t<Derived>;
            constexpr auto index = schema_property_index_v<Schema, Key>;
            static_assert(index < Schema::property_count);
            return get_index<index>();
        }
        template <std::size_t Index, class Value>
        void set_index(Value&& value) {
            using Schema = type_descriptor_schema_t<Derived>;
            static_assert(Index < Schema::property_count);
            static_assert(Schema::template property_type<Index>::writable);
            if (!holds(Index)) {
                throw std::logic_error("Property is outside the held synchronization set");
            }
            owner_->template write_unlocked<Index>(std::forward<Value>(value));
        }
        template <auto Member, class Value>
        void set(Value&& value) {
            using Schema = type_descriptor_schema_t<Derived>;
            constexpr auto index = schema_member_property_index_v<Schema, Member>;
            static_assert(index < Schema::property_count);
            set_index<index>(std::forward<Value>(value));
        }
        template <Fixed_String Key, class Value>
        void set_key(Value&& value) {
            using Schema = type_descriptor_schema_t<Derived>;
            constexpr auto index = schema_property_index_v<Schema, Key>;
            static_assert(index < Schema::property_count);
            set_index<index>(std::forward<Value>(value));
        }
    };
public:
    using Read_Guard = Basic_Read_Guard;
    using Write_Guard = Basic_Write_Guard;
private:
    template <class Function>
    void for_each_readable_impl(Function&& function) const {
        using Schema = type_descriptor_schema_t<Derived>;
        const auto& schema = type_descriptor<Derived>();
        schema.for_each_property([&](auto index, const auto& descriptor) {
            constexpr std::size_t property_index = decltype(index)::value;
            if constexpr (Schema::template property_type<property_index>::readable) {
                auto value = read_one<property_index>();
                std::invoke(function, index, descriptor, value);
            }
        });
    }
    template <class Function>
    void for_each_readable_locked_impl(Function&& function) const {
        using Schema = type_descriptor_schema_t<Derived>;
        auto targets = collect_all_static_lock_targets<true>();
        Static_Read_Guard<Schema::property_count> guard{*this, std::move(targets)};
        type_descriptor<Derived>().for_each_property([&](auto index, const auto& descriptor) {
            constexpr std::size_t property_index = decltype(index)::value;
            if constexpr (Schema::template property_type<property_index>::readable) {
                std::invoke(function, index, descriptor, guard.template get_index<property_index>());
            }
        });
    }
    template <class Function>
    void with_all_writable_locked_impl(Function&& function) {
        using Schema = type_descriptor_schema_t<Derived>;
        auto targets = collect_all_static_lock_targets<false>();
        Static_Write_Guard<Schema::property_count> guard{*this, std::move(targets)};
        std::invoke(std::forward<Function>(function), guard);
    }
    static const std::type_info& runtime_object_type_impl() noexcept {
        return typeid(Derived);
    }
    static std::size_t runtime_property_count_impl() noexcept {
        using Schema = type_descriptor_schema_t<Derived>;
        return Schema::property_count;
    }
    Runtime_Access_Result runtime_read_impl_local(std::string_view key, void* context, Runtime_Read_Callback callback) const {
        using Schema = type_descriptor_schema_t<Derived>;
        auto index = schema_property_index<Schema>(key);
        if (!index) {
            return Runtime_Access_Result::unknown_property;
        }
        if (!runtime_property_readable(*index)) {
            return Runtime_Access_Result::not_readable;
        }
        Runtime_Access_Result result = Runtime_Access_Result::unknown_property;
        visit_schema_property(type_descriptor<Derived>(), key, [&](auto property_index_constant, const auto&) {
            constexpr std::size_t property_index = decltype(property_index_constant)::value;
            using Property = typename Schema::template property_type<property_index>;
            using Value = typename Property::value_type;
            if constexpr (!Property::writable && !Property::accessor_type::synchronized_view_read) {
                if constexpr (std::is_reference_v<decltype(read_unlocked<property_index>(*this))>) {
                    auto&& value = read_unlocked<property_index>(*this);
                    callback(context, property_index, key, typeid(Value), std::addressof(value));
                } else {
                    Value value = read_unlocked<property_index>(*this);
                    callback(context, property_index, key, typeid(Value), std::addressof(value));
                }
            } else {
                auto lock_slot = slot(property_index);
                Single_Read_View view{*this, property_index, lock_slot};
                auto emit = [&] {
                    if constexpr (std::is_reference_v<decltype(read_unlocked<property_index>(view))>) {
                        auto&& value = read_unlocked<property_index>(view);
                        callback(context, property_index, key, typeid(Value), std::addressof(value));
                    } else {
                        Value value = read_unlocked<property_index>(view);
                        callback(context, property_index, key, typeid(Value), std::addressof(value));
                    }
                };
                if constexpr (!uses_real_mutexes) {
                    emit();
                } else if (lock_slot == Resolved_Synchronization_View::unsynchronized_slot) {
                    emit();
                } else {
                    std::shared_lock lock{mutex(lock_slot)};
                    emit();
                }
            }
            result = Runtime_Access_Result::ok;
        });
        return result;
    }
    static Runtime_Access_Result runtime_read_impl(const Property_Object_Base& base, std::string_view key, void* context, Runtime_Read_Callback callback) {
        const auto& self = static_cast<const Property_Object&>(base);
        return self.runtime_read_impl_local(key, context, callback);
    }
    Runtime_Access_Result runtime_write_impl_local(std::string_view key, const std::type_info& value_type, const void* value) {
        using Schema = type_descriptor_schema_t<Derived>;
        auto index = schema_property_index<Schema>(key);
        if (!index) {
            return Runtime_Access_Result::unknown_property;
        }
        if (!runtime_property_writable(*index)) {
            return Runtime_Access_Result::not_writable;
        }
        Runtime_Access_Result result = Runtime_Access_Result::unknown_property;
        visit_schema_property(type_descriptor<Derived>(), key, [&](auto property_index_constant, const auto&) {
            constexpr std::size_t property_index = decltype(property_index_constant)::value;
            using Property = typename Schema::template property_type<property_index>;
            using Accessor = typename Property::accessor_type;
            using Value = typename Property::value_type;
            if constexpr (!Schema::template property_type<property_index>::writable || !requires(const Accessor& accessor, Derived& object, const Value& candidate) { accessor.write(object, candidate); }) {
                result = Runtime_Access_Result::not_writable;
            } else if (value_type != typeid(Value)) {
                result = Runtime_Access_Result::type_mismatch;
            } else {
                write_one<property_index>(*static_cast<const Value*>(value));
                result = Runtime_Access_Result::ok;
            }
        });
        return result;
    }
    static Runtime_Access_Result runtime_write_impl(Property_Object_Base& base, std::string_view key, const std::type_info& value_type, const void* value) {
        auto& self = static_cast<Property_Object&>(base);
        return self.runtime_write_impl_local(key, value_type, value);
    }
    static const Property_Object_Base::Runtime_Interface* runtime_interface() noexcept {
        static const Property_Object_Base::Runtime_Interface value{
            &runtime_object_type_impl,
            &runtime_property_count_impl,
            &runtime_read_impl,
            &runtime_write_impl
        };
        return &value;
    }
protected:
    Property_Object() : Property_Object_Base(runtime_interface()), mutex_storage_(default_resolved_synchronization().lock_count) {}
    explicit Property_Object(Property_Synchronization synchronization) : Property_Object_Base(runtime_interface()) {
        initialize(type_descriptor<Derived>(), synchronization.plan);
    }
    Property_Object(const Property_Object& other) : Property_Object_Base(runtime_interface()) {
        copy_synchronization_from(other);
    }
    Property_Object(Property_Object&& other) : Property_Object_Base(runtime_interface()) {
        copy_synchronization_from(other);
    }
    Property_Object& operator=(const Property_Object&) noexcept {
        return *this;
    }
    Property_Object& operator=(Property_Object&&) noexcept {
        return *this;
    }
    ~Property_Object() = default;
public:
    const auto& schema() const noexcept {
        return type_descriptor<Derived>();
    }
    Resolved_Synchronization_View resolved_synchronization() const noexcept {
        using Schema = type_descriptor_schema_t<Derived>;
        if (custom_lock_layout_) {
            return {{custom_lock_layout_.get() + 1, Schema::property_count}, custom_lock_layout_[0]};
        }
        const auto& resolved = default_resolved_synchronization();
        return {resolved.lock_slots, resolved.lock_count};
    }
    Derived& unsafe_object() noexcept {
        return static_cast<Derived&>(*this);
    }
    const Derived& unsafe_object() const noexcept {
        return static_cast<const Derived&>(*this);
    }
    template <auto Member>
    auto read() const requires Schema_Readable_Property_Member<type_descriptor_schema_t<Derived>, Member> {
        using Schema = type_descriptor_schema_t<Derived>;
        constexpr auto index = schema_member_property_index_v<Schema, Member>;
        static_assert(index < Schema::property_count);
        return read_one<index>();
    }
    template <Fixed_String Key>
    auto read_key() const requires Schema_Readable_Property_Key<type_descriptor_schema_t<Derived>, Key> {
        using Schema = type_descriptor_schema_t<Derived>;
        constexpr auto index = schema_property_index_v<Schema, Key>;
        static_assert(index < Schema::property_count);
        return read_one<index>();
    }
    template <auto Member, class Value>
    void write(Value&& value) requires Schema_Writable_Property_Member<type_descriptor_schema_t<Derived>, Member> {
        using Schema = type_descriptor_schema_t<Derived>;
        constexpr auto index = schema_member_property_index_v<Schema, Member>;
        static_assert(index < Schema::property_count);
        write_one<index>(std::forward<Value>(value));
    }
    template <Fixed_String Key, class Value>
    void write_key(Value&& value) requires Schema_Writable_Property_Key<type_descriptor_schema_t<Derived>, Key> {
        using Schema = type_descriptor_schema_t<Derived>;
        constexpr auto index = schema_property_index_v<Schema, Key>;
        static_assert(index < Schema::property_count);
        write_one<index>(std::forward<Value>(value));
    }
    template <auto Member>
    std::size_t lock_slot() const noexcept {
        using Schema = type_descriptor_schema_t<Derived>;
        constexpr auto index = schema_member_property_index_v<Schema, Member>;
        static_assert(index < Schema::property_count);
        return slot(index);
    }
private:
    Basic_Read_Guard lock_shared_impl(std::span<const std::string_view> keys) const {
        return Basic_Read_Guard{*this, collect_dynamic_lock_targets(keys, true)};
    }
    Basic_Read_Guard lock_shared_impl(std::initializer_list<std::string_view> keys) const {
        return lock_shared_impl(std::span<const std::string_view>{keys.begin(), keys.size()});
    }
    Basic_Write_Guard lock_unique_impl(std::span<const std::string_view> keys) {
        return Basic_Write_Guard{*this, collect_dynamic_lock_targets(keys, false)};
    }
    Basic_Write_Guard lock_unique_impl(std::initializer_list<std::string_view> keys) {
        return lock_unique_impl(std::span<const std::string_view>{keys.begin(), keys.size()});
    }
    template <auto... Members>
    auto lock_shared_impl() const {
        using Schema = type_descriptor_schema_t<Derived>;
        static_assert((Schema_Property_Member<Schema, Members> && ...));
        auto targets = collect_static_lock_targets<true, schema_member_property_index_v<Schema, Members>...>();
        return Static_Read_Guard<sizeof...(Members)>{*this, std::move(targets)};
    }
    template <auto... Members>
    auto lock_unique_impl() {
        using Schema = type_descriptor_schema_t<Derived>;
        static_assert((Schema_Property_Member<Schema, Members> && ...));
        auto targets = collect_static_lock_targets<false, schema_member_property_index_v<Schema, Members>...>();
        return Static_Write_Guard<sizeof...(Members)>{*this, std::move(targets)};
    }
public:
    Read_Guard lock_shared(std::span<const std::string_view> keys) const {
        return lock_shared_impl(keys);
    }
    Read_Guard lock_shared(std::initializer_list<std::string_view> keys) const {
        return lock_shared_impl(keys);
    }
    Write_Guard lock_unique(std::span<const std::string_view> keys) {
        return lock_unique_impl(keys);
    }
    Write_Guard lock_unique(std::initializer_list<std::string_view> keys) {
        return lock_unique_impl(keys);
    }
    template <auto... Members>
    auto lock_shared() const requires (Schema_Readable_Property_Member<type_descriptor_schema_t<Derived>, Members> && ...) {
        return lock_shared_impl<Members...>();
    }
    template <auto... Members>
    auto lock_unique() requires (Schema_Writable_Property_Member<type_descriptor_schema_t<Derived>, Members> && ...) {
        return lock_unique_impl<Members...>();
    }
    template <class Function>
    void for_each_readable(Function&& function) const {
        for_each_readable_impl(std::forward<Function>(function));
    }
    template <class Function>
    void for_each_readable_locked(Function&& function) const {
        for_each_readable_locked_impl(std::forward<Function>(function));
    }
    template <class Function>
    void with_all_writable_locked(Function&& function) {
        with_all_writable_locked_impl(std::forward<Function>(function));
    }
};
}