#pragma once
#include <mcp/core/Render_Types.hpp>
#include <nlohmann/json.hpp>
#include <render_2D/plottable/Plottables.hpp>
#include <render_3D/Render_3D.hpp>
#include <deque>
#include <limits>
#include <ranges>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
namespace aethera::web::detail {
struct Renderable_Field_Role_Category {};
template <Renderable_Field_Role Role>
struct Renderable_Field_Role_Attribute {
    using attribute_category = Renderable_Field_Role_Category;
    static constexpr bool single_valued = true;
    static constexpr bool inheritable = false;
    static constexpr auto value = Role;
};
template <auto Member, structive::Fixed_String Key, structive::Fixed_String Description,
          structive::Fixed_String Editor>
struct Prop_Field {
    static constexpr auto member = Member;
    static constexpr auto key = Key;
    static constexpr auto description = Description;
    static constexpr auto editor = Editor;
    static constexpr auto role = Renderable_Field_Role::prop;
};
template <typename Tag, auto Member, structive::Fixed_String Key, structive::Fixed_String Description>
struct State_Field {
    using tag_type = Tag;
    static constexpr auto member = Member;
    static constexpr auto key = Key;
    static constexpr auto description = Description;
    static constexpr auto role = Renderable_Field_Role::state;
};
template <typename Object, typename... Fields>
struct Renderable_Adapter final : public structive::Property_Object<Renderable_Adapter<Object, Fields...>, structive::No_Lock_Policy> {
public:
    explicit Renderable_Adapter(Object& value) : object(&value) {}
    void identify(std::string_view id) {
        if constexpr (std::derived_from<Object, aethera::Renderable>)
            double_buffer::detail::Internal_Access::layer<aethera::Renderable>(object)
                .diagnostic_component_id = id;
    }
private:
    template <typename Adapter, typename Field>
    friend struct Renderable_Field_Accessor;
    Object* object;
};
template <typename Adapter, typename Field>
struct Renderable_Field_Accessor;
template <typename Object, typename... Fields, auto Member, structive::Fixed_String Key,
          structive::Fixed_String Description, structive::Fixed_String Editor>
struct Renderable_Field_Accessor<Renderable_Adapter<Object, Fields...>, Prop_Field<Member, Key, Description, Editor>> {
    using object_type = Renderable_Adapter<Object, Fields...>;
    using value_type = typename structive::Member_Pointer_Traits<decltype(Member)>::value_type;
    using storage_identity = void;
    using dependency_spec = structive::No_Property_Dependencies;
    static constexpr auto description = Description;
    static constexpr auto editor = Editor;
    static constexpr bool readable = true;
    static constexpr bool writable = true;
    static constexpr bool synchronized_view_read = false;
    static constexpr bool trusted_object_access = true;
    [[nodiscard]] value_type read(const object_type& adapter) const {
        return adapter.object->template get<Member>();
    }
    void write(object_type& adapter, value_type value) const {
        adapter.object->template set<Member>(std::move(value));
    }
};
template <typename Object, typename... Fields, typename Tag, auto Member, structive::Fixed_String Key, structive::Fixed_String Description>
struct Renderable_Field_Accessor<Renderable_Adapter<Object, Fields...>, State_Field<Tag, Member, Key, Description>> {
    using object_type = Renderable_Adapter<Object, Fields...>;
    using value_type = typename structive::Member_Pointer_Traits<decltype(Member)>::value_type;
    using storage_identity = void;
    using dependency_spec = structive::No_Property_Dependencies;
    static constexpr auto description = Description;
    static constexpr bool readable = true;
    static constexpr bool writable = false;
    static constexpr bool synchronized_view_read = false;
    static constexpr bool trusted_object_access = true;
    [[nodiscard]] value_type read(const object_type& adapter) const {
        value_type result{};
        adapter.object->template access_state<Tag>([&](const auto& state) {
            result = state.*Member;
        });
        return result;
    }
};
template <typename Adapter, typename Field>
constexpr auto renderable_field_descriptor() {
    using Accessor = Renderable_Field_Accessor<Adapter, Field>;
    using Role = Renderable_Field_Role_Attribute<Field::role>;
    using Key = structive::Key_Attribute<Field::key>;
    return structive::Property_Descriptor<Accessor, Key, Role>{{}, {Key{}, Role{}}};
}
}
namespace structive {
template <typename Object, typename... Fields>
struct Type_Descriptor<aethera::web::detail::Renderable_Adapter<Object, Fields...>> {
    static auto get() {
        using Adapter = aethera::web::detail::Renderable_Adapter<Object, Fields...>;
        return object<Adapter>(synchronization(sync_all_unsynchronized),
                               aethera::web::detail::renderable_field_descriptor<Adapter, Fields>()...);
    }
};
}
namespace aethera::web::detail {
template <typename Value>
[[nodiscard]] constexpr std::string_view renderable_editor(
    mcp::Type_Tag<Value>) noexcept {
    return mcp::protocol_editor<Value>();
}
[[nodiscard]] constexpr std::string_view renderable_editor(
    mcp::Type_Tag<Color>) noexcept { return "color"; }
[[nodiscard]] constexpr std::string_view renderable_editor(
    mcp::Type_Tag<render_3d::Linear_Color>) noexcept { return "color"; }
[[nodiscard]] constexpr std::string_view renderable_editor(
    mcp::Type_Tag<render_2d::Point_F>) noexcept { return "point2"; }
[[nodiscard]] constexpr std::string_view renderable_editor(
    mcp::Type_Tag<render_2d::Size>) noexcept { return "size"; }
[[nodiscard]] constexpr std::string_view renderable_editor(
    mcp::Type_Tag<render_3d::Extent>) noexcept { return "size"; }
[[nodiscard]] constexpr std::string_view renderable_editor(
    mcp::Type_Tag<render_2d::Rect_F>) noexcept { return "rect"; }
[[nodiscard]] constexpr std::string_view renderable_editor(
    mcp::Type_Tag<render_2d::Axis_Range>) noexcept { return "range"; }
[[nodiscard]] constexpr std::string_view renderable_editor(
    mcp::Type_Tag<render_2d::Plot_Partition_Grid>) noexcept {
    return "partition-grid";
}
[[nodiscard]] constexpr std::string_view renderable_editor(
    mcp::Type_Tag<render_2d::Pen>) noexcept { return "pen"; }
[[nodiscard]] constexpr std::string_view renderable_editor(
    mcp::Type_Tag<render_2d::Brush>) noexcept { return "brush"; }
[[nodiscard]] constexpr std::string_view renderable_editor(
    mcp::Type_Tag<render_2d::Font>) noexcept { return "font"; }
[[nodiscard]] constexpr std::string_view renderable_editor(
    mcp::Type_Tag<render_2d::Color_Map>) noexcept { return "color-map"; }
[[nodiscard]] constexpr std::string_view renderable_editor(
    mcp::Type_Tag<render_3d::Vec3>) noexcept { return "vector3"; }
[[nodiscard]] constexpr std::string_view renderable_editor(
    mcp::Type_Tag<render_3d::Matrix4>) noexcept { return "matrix4"; }
[[nodiscard]] constexpr std::string_view renderable_editor(
    mcp::Type_Tag<std::vector<render_3d::Marker>>) noexcept {
    return "marker-list";
}

inline std::string_view protocol_field_label(std::string_view key) {
    static constexpr std::pair<std::string_view, std::string_view> labels[] = {
        {"position", "位置"}, {"viewport", "视口尺寸"}, {"background", "背景颜色"},
        {"clear_color", "清屏颜色"}, {"view_active", "启用视图"},
        {"initial_view", "初始相机视图"}, {"projection", "投影方式"},
        {"controller", "Datoviz 相机模式"}, {"turntable_control", "Turntable 控制"},
        {"arcball_control", "Arcball 控制"}, {"fly_control", "Fly 控制"},
        {"panzoom_control", "Panzoom 控制"}, {"vertical_field_of_view_degrees", "垂直视场角"},
        {"near_plane", "近裁剪面"}, {"far_plane", "远裁剪面"},
        {"x_axis", "X 坐标轴"}, {"y_axis", "Y 坐标轴"}, {"z_axis", "Z 坐标轴"},
        {"pixel_length", "轴线长度"}, {"orientation", "轴线方向"}, {"tick_length", "主刻度长度"},
        {"sub_tick_length", "次刻度长度"}, {"axis_pen", "轴线画笔"}, {"unit_text", "单位文字"},
        {"unit_text_font", "单位字体"}, {"unit_text_pen", "单位文字画笔"},
        {"unit_text_background_brush", "单位文字背景"}, {"label_rotation_degrees", "标签旋转角度"},
        {"coordinate_range", "坐标范围"}, {"precision", "小数精度"}, {"locale", "数字区域格式"},
        {"wheel_enabled", "允许滚轮缩放"}, {"drag_enabled", "允许拖动平移"},
        {"visible_count", "可见数量"}, {"tick_label_spacing_px", "刻度文字间距"},
        {"estimated_label_width_px", "预计标签宽度"}, {"format", "时间格式"},
        {"newest_at_start", "最新数据置于起点"}, {"center_frequency", "中心频率"},
        {"partition_count", "分区数量"}, {"partition_grid", "分区网格"},
        {"interpolation_mode", "插值模式"}, {"visible_range_only", "仅处理可见范围"},
        {"frequency_range", "频率范围"}, {"power_range", "功率范围"}, {"i_range", "同相范围"},
        {"q_range", "正交范围"}, {"phase_offset_radians", "相位偏移"}, {"pen", "画笔"},
        {"samples", "样本数据"}, {"rows", "瀑布图行数据"}, {"color_map", "颜色映射"},
        {"tooltip_enabled", "启用提示框"}, {"tooltip_font", "提示框字体"},
        {"tooltip_text_pen", "提示文字画笔"}, {"tooltip_background_brush", "提示框背景"},
        {"frequency_bin_count", "频率箱数量"}, {"frequency_point_size", "频率网格数量"},
        {"power_point_size", "功率网格数量"}, {"attenuation_rate", "衰减速率"},
        {"interpolate", "启用插值"}, {"spectra", "频谱历史"}, {"blocks", "扫频块数据"},
        {"bins_per_block", "每块频点数"}, {"block_count", "扫频块数量"},
        {"max_hold_visible", "显示最大保持"}, {"min_hold_visible", "显示最小保持"},
        {"max_marker_visible", "显示最大标记"}, {"min_marker_visible", "显示最小标记"},
        {"sweep_region_visible", "显示扫频区域"}, {"sweep_frequency_range", "扫频范围"},
        {"max_brush", "最大保持画刷"}, {"current_brush", "当前曲线画刷"},
        {"min_brush", "最小保持画刷"}, {"max_pen", "最大保持画笔"},
        {"current_pen", "当前曲线画笔"}, {"min_pen", "最小保持画笔"},
        {"selected_marker_pen", "选中标记画笔"}, {"marker_pen", "标记画笔"},
        {"middle_frequency_pen", "中心频率画笔"}, {"sweep_region_brush", "扫频区域画刷"},
        {"current_frequency_pen", "当前频率指示线"}, {"custom_markers", "自定义标记"},
        {"selected_marker", "当前选中标记"}, {"point_lifetime_ms", "点保留时间"},
        {"type", "星座类型"}, {"point_color", "数据点颜色"}, {"anchor_color", "参考点颜色"},
        {"points", "星座点数据"}, {"label_font", "标签字体"}, {"label_pen", "标签画笔"},
        {"selection_brush", "选区画刷"}, {"selection_border_pen", "选区边框画笔"},
        {"selected_regions", "已选区域"}, {"cache_enabled", "启用绘制缓存"},
        {"transform", "空间变换"}, {"visible", "是否可见"},
        {"depth_test", "深度测试"}, {"items", "项目数据"},
        {"next_tick", "下一时间刻度"},
        {"sample_count", "样本数量"}, {"rendered_point_count", "已绘制点数量"},
        {"selectable_marker_count", "可选标记数量"}, {"stored_block_count", "已保存数据块数量"},
        {"stored_point_count", "已保存数据点数量"}, {"history_count", "历史帧数量"},
        {"latest_spectrum_point_count", "最新频谱点数量"}, {"rendered_cell_count", "已绘制单元数量"},
        {"row_count", "瀑布图行数量"}, {"point_count", "数据点数量"},
        {"selected_region_count", "已选区域数量"}, {"item_count", "项目数量"},
        {"prepared_item_count", "已准备项目数量"}, {"prepared_revision", "已准备修订号"}
    };
    const auto found = std::ranges::find_if(labels, [key](const auto& entry) {
        return entry.first == key;
    });
    return found == std::end(labels) ? key : found->second;
}
template <typename Adapter>
nlohmann::json adapter_schema(const Adapter& adapter, std::string_view id, std::string_view label, std::string_view kind) {
    nlohmann::json fields = nlohmann::json::array();
    structive::type_descriptor<Adapter>().for_each_property([&](auto, const auto& field) {
        using Field = std::remove_cvref_t<decltype(field)>;
        using Value = typename Field::value_type;
        const bool editable = field.template attribute<Renderable_Field_Role_Category>().value == Renderable_Field_Role::prop;
        const auto field_label = protocol_field_label(field.key());
        std::string_view editor = renderable_editor(mcp::Type_Tag<Value>{});
        if constexpr (requires { Field::accessor_type::editor; }) {
            if (!Field::accessor_type::editor.view().empty()) editor = Field::accessor_type::editor.view();
        }
        nlohmann::json item{
            {"key", field.key()}, {"label", field_label}, {"editor", editor},
            {"editable", editable},
            {"description", std::string(field_label) + "。协议字段：" + std::string(field.key()) + "。"},
            {"technical_description", std::string(Field::accessor_type::description.view())}
        };
        if (editable) item["value"] = mcp::encode_protocol_value(field.accessor.read(adapter));
        if constexpr (std::same_as<Value, render_3d::Linear_Color>) item["color_channel_scale"] = "normalized";
        else if constexpr (std::same_as<Value, Color>) item["color_channel_scale"] = "byte";
        if (editable) {
            if constexpr (std::is_enum_v<Value>) {
                item["options"] = nlohmann::json::array();
                for (const auto enum_value : magic_enum::enum_values<Value>()) {
                    const auto name = magic_enum::enum_name(enum_value);
                    item["options"].push_back({{"value", name}, {"label", name}});
                }
            }
        }
        fields.push_back(std::move(item));
    });
    return {
        {"id", id}, {"label", label}, {"kind", kind},
        {"fields", std::move(fields)}
    };
}
template <typename Adapter>
nlohmann::json adapter_values(const Adapter& adapter, Renderable_Field_Role role) {
    nlohmann::json result = nlohmann::json::object();
    structive::type_descriptor<Adapter>().for_each_property([&](auto, const auto& field) {
        if (field.template attribute<Renderable_Field_Role_Category>().value == role)
            result[field.key()] = mcp::encode_protocol_value(field.accessor.read(adapter));
    });
    return result;
}
template <typename Adapter>
nlohmann::json write_adapter_prop(Adapter& adapter, std::string_view key, const nlohmann::json& input) {
    nlohmann::json result{{"success", false}, {"key", key}};
    const bool found = structive::visit_schema_property(structive::type_descriptor<Adapter>(), key, [&](auto, const auto& field) {
        using Field = std::remove_cvref_t<decltype(field)>;
        using Value = typename Field::value_type;
        if constexpr (!Field::writable) {
            result["error"] = "property is read-only";
        }
        else {
            try {
                Value value{};
                mcp::decode_protocol_value(value, input);
                const auto status = adapter.runtime_write(key, typeid(Value), &value);
                if (status != structive::Runtime_Access_Result::ok) {
                    result["error"] = "property write was rejected";
                    return;
                }
                result["success"] = true;
                result["value"] = mcp::encode_protocol_value(field.accessor.read(adapter));
            }
            catch (const std::exception& error) {
                result["error"] = error.what();
            }
        }
    });
    if (!found) result["error"] = "unknown property";
    return result;
}
template <typename Adapter>
Renderable_Descriptor_Model<Adapter>::Renderable_Descriptor_Model(
    std::string id, std::string label, std::string kind, Adapter value) : component_id(std::move(id)), component_label(std::move(label)), component_kind(std::move(kind)), adapter(std::move(value)) {
    adapter.identify(component_id);
}
template <typename Adapter>
std::string_view Renderable_Descriptor_Model<Adapter>::id() const noexcept {
    return component_id;
}
template <typename Adapter>
nlohmann::json Renderable_Descriptor_Model<Adapter>::schema() const {
    return adapter_schema(adapter, component_id, component_label, component_kind);
}
template <typename Adapter>
nlohmann::json Renderable_Descriptor_Model<Adapter>::state() const {
    return {{"protocol", "aethera.component.state"}, {"version", 1},
            {"component", component_id},
            {"state", adapter_values(adapter, Renderable_Field_Role::state)}};
}
template <typename Adapter>
nlohmann::json Renderable_Descriptor_Model<Adapter>::values() const {
    return {{"component", component_id}, {"label", component_label},
            {"kind", component_kind},
            {"prop", adapter_values(adapter, Renderable_Field_Role::prop)},
            {"state", adapter_values(adapter, Renderable_Field_Role::state)}};
}
template <typename Adapter>
nlohmann::json Renderable_Descriptor_Model<Adapter>::write_prop(std::string_view key, const nlohmann::json& value) {
    return write_adapter_prop(adapter, key, value);
}
template <typename Adapter>
std::unique_ptr<Renderable_Descriptor> make_renderable_descriptor(
    std::string id, std::string label, std::string kind, Adapter adapter) {
    return std::make_unique < Renderable_Descriptor_Model<Adapter> > (
        std::move(id), std::move(label), std::move(kind), std::move(adapter));
}
}