#pragma once
#include "accessor.hpp"
#include "attributes.hpp"
#include "meta.hpp"
#include <cstddef>
#include <tuple>
#include <string_view>
#include <type_traits>
#include <utility>
namespace structive {
template <class Value, class... Attributes>
consteval bool constraints_compatible() {
    return (([] {
        if constexpr (Property_Constraint<Attributes>) {
            return Property_Constraint_For<Attributes, Value>;
        }
        return true;
    }()) && ...);
}
template <Property_Accessor Accessor, class... Attributes>
struct Property_Descriptor {
    using property_descriptor_tag = void;
    using accessor_type = Accessor;
    using object_type = typename Accessor::object_type;
    using value_type = typename Accessor::value_type;
    using storage_identity = typename Accessor::storage_identity;
    using attribute_types = Type_List<Attributes...>;
    static constexpr bool readable = Accessor::readable;
    static constexpr bool writable = Accessor::writable;
    static constexpr bool synchronized_view_read = Accessor::synchronized_view_read;
    static constexpr bool trusted_object_access = Accessor::trusted_object_access;
    static_assert(unique_single_value_categories<Attributes...>());
    using key_type = find_attribute_in_list_t<Key_Category, attribute_types>;
    static_assert(!std::same_as<key_type, void>);
    static_assert(key_type::value.view().size() > 0);
    static_assert(constraints_compatible<value_type, Attributes...>());
    [[no_unique_address]] Accessor accessor{};
    std::tuple<Attributes...> attributes;
    template <class Category>
    using attribute_type = find_attribute_in_list_t<Category, attribute_types>;
    template <class Category>
    static constexpr bool has_attribute = !std::same_as<attribute_type<Category>, void>;
    template <class Category>
    constexpr decltype(auto) attribute() const requires has_attribute<Category> {
        using target = attribute_type<Category>;
        return std::get<target>(attributes);
    }
    constexpr std::string_view key() const noexcept {
        return key_type::value.view();
    }
    template <class Function>
    constexpr void for_each_attribute(Function&& function) const {
        std::apply([&](const auto&... values) {
            (function(values), ...);
        }, attributes);
    }
    template <class Function>
    constexpr void for_each_constraint(Function&& function) const {
        std::apply([&](const auto&... values) {
            ([&] {
                using type = std::remove_cvref_t<decltype(values)>;
                if constexpr (Property_Constraint<type>) {
                    function(values);
                }
            }(), ...);
        }, attributes);
    }
};
template <class Type>
concept Property_Descriptor_Type = requires {
    typename Type::property_descriptor_tag;
    typename Type::object_type;
    typename Type::value_type;
    typename Type::accessor_type;
    typename Type::storage_identity;
};
template <auto Member, class... Attributes>
constexpr auto property(Attributes&&... attributes) {
    using accessor = Member_Accessor<Member>;
    return Property_Descriptor<accessor, std::decay_t<Attributes>...>{{}, {std::forward<Attributes>(attributes)...}};
}
template <auto Member, class... Attributes>
constexpr auto field(Attributes&&... attributes) {
    return property<Member>(std::forward<Attributes>(attributes)...);
}
template <class Object, class Value, class Function, class... Attributes>
constexpr auto computed_property(Function&& function, Attributes&&... attributes) {
    using accessor = Synchronized_Computed_Accessor<Object, Value, std::decay_t<Function>>;
    return Property_Descriptor<accessor, std::decay_t<Attributes>...>{accessor{std::forward<Function>(function)}, {std::forward<Attributes>(attributes)...}};
}
template <auto Getter, class... Attributes> requires Trusted_Getter_Function<Getter>
constexpr auto trusted_computed_property(Attributes&&... attributes) {
    using accessor = Trusted_Computed_Accessor<Getter>;
    return Property_Descriptor<accessor, std::decay_t<Attributes>...>{{}, {std::forward<Attributes>(attributes)...}};
}
template <auto Getter, auto Setter, class... Attributes> requires Trusted_Getter_Function<Getter> && Trusted_Setter_Function_For<Setter, trusted_getter_object_t<Getter>, trusted_getter_value_t<Getter>>
constexpr auto trusted_accessor_property(Attributes&&... attributes) {
    using accessor = Trusted_Getter_Setter_Accessor<Getter, Setter>;
    return Property_Descriptor<accessor, std::decay_t<Attributes>...>{{}, {std::forward<Attributes>(attributes)...}};
}
}