michiu_ui 0.0.2

use crate::{
    ActiveEntitiesVec, ActiveMasksSecondary, BaseBasicLayoutsSecondary, BasicLayoutsSecondary,
    CapacityConfig, ChildrenSecondary, ComponentMask, Context, DebugStore, DirtyLayoutEntitiesVec,
    DirtyRenderEntitiesVec, Element, EntitiesSlot, EntityId, EventStore, FlexLayoutsSecondary,
    LayoutPoint, LayoutRect, LayoutStore, MichiuError, MichiuSoA, OptionTraceExt, ParentsSecondary,
    Pipeline, PointerEvents, Position, Rect, RectsSecondary, RenderStore, SessionSpawnedVec,
    TaffyNodesSecondary, TaffyResultTraceExt, TaffyTreeEntityId, TopologyStore, Val,
    define_sparse_secondary, handle_on_dnd_drag_start, handle_on_dnd_entity_drag,
    handle_on_dnd_entity_drop, handle_on_dnd_id_drag, handle_on_dnd_id_drop, handle_on_drag,
};
use slotmap::SparseSecondaryMap;

/// プレースホルダーを挿入してマウントする親先祖の制御方法
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum DndDragPlaceholderParent {
    Root,             // 自動的に最上位ルート要素の子としてアタッチ
    Custom(EntityId), // ユーザーが指定した特定の親コンテナの子としてアタッチ（範囲制限）
}

/// ドラッグ＆ドロップ動作の論理形式
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum DndDragPayload {
    /// Element 自体を移動する。
    /// ドロップ時に UI ツリーが自動的に更新される。
    Element,

    /// Element が持つ `EntityId` のみをドラッグデータとして転送する。
    /// UI ツリーは変更されず、アプリケーション側で並び替え等を行う。
    EntityId,
}

/// ドラッグ可能な要素が保持するスタイリング・動作設定
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct DndDragProperty {
    pub placeholder_parent: DndDragPlaceholderParent,
    pub drag_mode: DndDragPayload,
    // ドラッグ終了時に自動的に配置（相対並び替え／絶対座標）を更新するか
    pub update_position: bool,
}

/// ドロップ受け入れ先での取り込み形式
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum DndDropTarget {
    Child,   // ドロップ先の子要素として取り込む
    Sibling, // ドロップ先の兄弟要素（隣接位置）として取り込む
}

/// ドロップ受け入れ先（ドロップゾーン）が保持するスタイリング・動作設定
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct DndDropProperty {
    pub target: DndDropTarget,
    pub drag_mode: DndDragPayload,
}

#[derive(Debug, Clone)]
pub struct ActiveDragState {
    pub source_entity: EntityId,               // ドラッグ元の要素
    pub placeholder_entity: EntityId,          // ルートまたは親に浮かせているプレースホルダー
    pub current_drop_target: Option<EntityId>, // 現在ホバー侵入中のドロップターゲット要素
    pub start_mouse_pos: LayoutPoint,          // ドラッグ開始時のマウス座標
    pub start_rect: LayoutRect,                // ドラッグ元の初期サイズ・座標
    pub click_offset: LayoutPoint,             // ドラッグ開始時のマウスと要素左上端の相対的なズレ
    pub original_parent: Option<EntityId>,
}

/// プレースホルダーをアタッチする際の親要素の情報
#[derive(Debug, Clone)]
pub(crate) struct PlaceholderAttachment {
    pub(crate) parent_id: Option<EntityId>,
    pub(crate) rect: LayoutRect,
    pub(crate) border_left: f32,
    pub(crate) border_top: f32,
}

define_sparse_secondary!(pub struct DndDragPropertiesSparse(DndDragProperty));
define_sparse_secondary!(pub struct DndDropPropertiesSparse(DndDropProperty));

pub(crate) struct DndStore {
    pub(crate) dnd_drag_properties: DndDragPropertiesSparse,
    pub(crate) dnd_drop_properties: DndDropPropertiesSparse,
    pub(crate) dnd_active_drag_state: Option<ActiveDragState>,
}

impl Default for DndStore {
    fn default() -> Self {
        Self::new()
    }
}

impl DndStore {
    #[inline]
    #[must_use]
    pub(crate) fn new() -> Self {
        Self {
            dnd_drag_properties: DndDragPropertiesSparse(SparseSecondaryMap::new()),
            dnd_drop_properties: DndDropPropertiesSparse(SparseSecondaryMap::new()),
            dnd_active_drag_state: None,
        }
    }

    #[inline]
    #[must_use]
    pub(crate) fn with_capacity(c: &CapacityConfig) -> Self {
        Self {
            dnd_drag_properties: DndDragPropertiesSparse(SparseSecondaryMap::with_capacity(
                c.dnd_drag_properties,
            )),
            dnd_drop_properties: DndDropPropertiesSparse(SparseSecondaryMap::with_capacity(
                c.dnd_drop_properties,
            )),
            ..Default::default()
        }
    }

    #[inline]
    pub(crate) fn clear(&mut self) {
        self.dnd_drag_properties.clear();
        self.dnd_drop_properties.clear();
        self.dnd_active_drag_state = None;
    }

    #[inline]
    pub(crate) fn despawn(&mut self, id: EntityId) {
        self.dnd_drag_properties.remove(id);
        self.dnd_drop_properties.remove(id);

        if let Some(ref state) = self.dnd_active_drag_state
            && (state.source_entity == id || state.placeholder_entity == id)
        {
            self.dnd_active_drag_state = None;
        }
    }
}

impl DndStore {
    #[track_caller]
    fn resolve_dnd_placeholder_parent(
        root: EntityId,
        drag_prop: &DndDragProperty,
        lay_basic: &BasicLayoutsSecondary,
        out_rects: &RectsSecondary,
        debug: &mut DebugStore,
    ) -> PlaceholderAttachment {
        match drag_prop.placeholder_parent {
            DndDragPlaceholderParent::Root => PlaceholderAttachment {
                parent_id: Some(root),
                rect: out_rects.find_or_default(root, debug),
                border_left: 0.0,
                border_top: 0.0,
            },
            DndDragPlaceholderParent::Custom(p_id) => {
                let rect = out_rects.find_or_default(p_id, debug);
                let (border_left, border_top) = lay_basic
                    .find(p_id)
                    .map(|l| (l.border.left.to_px_or_zero(), l.border.top.to_px_or_zero()))
                    .unwrap_or_default();

                PlaceholderAttachment {
                    parent_id: Some(p_id),
                    rect,
                    border_left,
                    border_top,
                }
            }
        }
    }

    fn spawn_dnd_placeholder(
        root: EntityId,
        drag_prop: &DndDragProperty,
        topo_entities: &mut EntitiesSlot,
        topo_active_entities: &mut ActiveEntitiesVec,
        topo_active_masks: &mut ActiveMasksSecondary,
        topo_parents: &mut ParentsSecondary,
        topo_children: &mut ChildrenSecondary,
        topo_session_spawned: &mut SessionSpawnedVec,
        topo_is_structure_dirty: &mut bool,
        topo_is_sort_dirty: &mut bool,
        lay_dirty_entities: &mut DirtyLayoutEntitiesVec,
        lay_taffy_tree: &mut TaffyTreeEntityId,
        lay_taffy_nodes: &mut TaffyNodesSecondary,
        lay_basic: &BasicLayoutsSecondary,
        rnd_dirty_entities: &mut DirtyRenderEntitiesVec,
        out_rects: &RectsSecondary,
        debug: &mut DebugStore,
    ) -> EntityId {
        let placeholder =
            DndStore::resolve_dnd_placeholder_parent(root, drag_prop, lay_basic, out_rects, debug);

        let placeholder_id = TopologyStore::spawn(
            placeholder.parent_id,
            topo_entities,
            topo_active_entities,
            topo_active_masks,
            topo_parents,
            topo_children,
            topo_session_spawned,
            topo_is_structure_dirty,
            topo_is_sort_dirty,
            lay_taffy_tree,
            lay_taffy_nodes,
            rnd_dirty_entities,
            debug,
        );

        if let Some(p_id) = placeholder.parent_id {
            TopologyStore::add_child(
                p_id,
                placeholder_id,
                topo_active_masks,
                topo_parents,
                topo_children,
                topo_is_structure_dirty,
                topo_is_sort_dirty,
                lay_dirty_entities,
                lay_taffy_tree,
                lay_taffy_nodes,
                debug,
            );
        }

        placeholder_id
    }

    #[track_caller]
    fn setup_placeholder_properties(
        cx: &mut Context,
        pressed_id: EntityId,
        placeholder_id: EntityId,
        start_rect: LayoutRect,
    ) {
        // 元要素のレイアウトおよびビジュアル情報をコピー
        let basic = *cx.layouts.lay_base_basic.at_mut(pressed_id);
        cx.layouts.lay_base_basic.insert(placeholder_id, basic);
        cx.layouts.lay_basic.insert(placeholder_id, basic);

        let visual = cx.renders.rnd_base_visual.at(pressed_id).clone();
        cx.renders
            .rnd_base_visual
            .insert(placeholder_id, visual.clone());
        cx.renders.rnd_visual.insert(placeholder_id, visual);

        let interaction = cx.renders.rnd_interaction.at(pressed_id).clone();
        cx.renders
            .rnd_interaction
            .insert(placeholder_id, interaction);

        // ドラッグ元とプレースホルダーの状態を同期
        Pipeline::update_state(cx, pressed_id, ComponentMask::STATE_DND_DRAGGING, true);
        Pipeline::update_state(cx, placeholder_id, ComponentMask::STATE_DND_DRAG_OVER, true);

        // プレースホルダー側を Absolute 配置化
        let basic = cx.layouts.lay_basic.get_mut(placeholder_id);
        let base_basic = cx.layouts.lay_base_basic.get_mut(placeholder_id);
        for layout in [basic, base_basic].into_iter().flatten() {
            layout.position = Position::Absolute;
            layout.size.width = Val::Px(start_rect.width);
            layout.size.height = Val::Px(start_rect.height);
        }

        // ヒットテストを透過
        let visual = cx.renders.rnd_visual.get_mut(placeholder_id);
        let base_visual = cx.renders.rnd_base_visual.get_mut(placeholder_id);
        for vis in [visual, base_visual].into_iter().flatten() {
            vis.pointer_events = Some(PointerEvents::None);
        }

        let mask = cx.topology.topo_active_masks.at_mut(placeholder_id);
        mask.set(ComponentMask::STYLE_POINTER_EVENTS);
    }

    #[track_caller]
    fn transfer_children_to_placeholder(
        pressed_id: EntityId,
        placeholder_id: EntityId,
        topo_active_masks: &mut ActiveMasksSecondary,
        topo_parents: &mut ParentsSecondary,
        topo_children: &mut ChildrenSecondary,
        lay_dirty_entities: &mut DirtyLayoutEntitiesVec,
        lay_taffy_tree: &mut TaffyTreeEntityId,
        lay_taffy_nodes: &TaffyNodesSecondary,
        debug: &mut DebugStore,
    ) {
        for child_id in topo_children.at(pressed_id).clone() {
            // 子要素の親ポインタをプレースホルダーに付け替え
            topo_parents.insert(child_id, Some(placeholder_id));

            // プレースホルダー側の子要素リストへ追加
            topo_children.at_mut(placeholder_id).push(child_id);

            // Taffy 側の親子構造も、一時的にプレースホルダーに繋ぎ替え
            let src_node = *lay_taffy_nodes.at(pressed_id);
            let ph_node = *lay_taffy_nodes.at(placeholder_id);
            let child_node = *lay_taffy_nodes.at(child_id);

            lay_taffy_tree
                .remove_child(src_node, child_node)
                .unwrap_or_trace(Some(child_id), debug);
            lay_taffy_tree
                .add_child(ph_node, child_node)
                .unwrap_or_trace(Some(child_id), debug);
        }

        // 元の要素の子要素リストは一時的にクリア（プレースホルダーに避難しているため）
        topo_children.at_mut(pressed_id).clear();

        // 元要素とプレースホルダー要素の両方をダーティマーク
        for id in [pressed_id, placeholder_id] {
            LayoutStore::mark_layout_dirty(
                id,
                topo_active_masks,
                topo_parents,
                lay_dirty_entities,
                lay_taffy_tree,
                lay_taffy_nodes,
                debug,
            );
        }
    }

    #[track_caller]
    fn start_dnd_drag_session(cx: &mut Context, pressed_id: EntityId, logical_pos: LayoutPoint) {
        let drag_prop = *cx.states.dnd.dnd_drag_properties.at(pressed_id);
        let start_rect = cx
            .outputs
            .out_rects
            .find_or_default(pressed_id, &mut cx.debug);

        // 開始時のクリック位置と要素左上の相対的なズレを計算
        let click_offset =
            LayoutPoint::new(logical_pos.x - start_rect.x, logical_pos.y - start_rect.y);

        // ウィンドウのルート要素を自己解決
        let root = TopologyStore::find_root_entity(
            &cx.topology.topo_entities,
            &cx.topology.topo_parents,
            &cx.topology.topo_flat_dfs_sequence,
        )
        .unwrap_or_trace(None, &mut cx.debug, || MichiuError::RootEntityNotFound);

        // プレースホルダーをアタッチ先親の直下へ spawn して生成
        let placeholder_id = DndStore::spawn_dnd_placeholder(
            root,
            &drag_prop,
            &mut cx.topology.topo_entities,
            &mut cx.topology.topo_active_entities,
            &mut cx.topology.topo_active_masks,
            &mut cx.topology.topo_parents,
            &mut cx.topology.topo_children,
            &mut cx.topology.topo_session_spawned,
            &mut cx.topology.topo_is_structure_dirty,
            &mut cx.topology.topo_is_sort_dirty,
            &mut cx.layouts.lay_dirty_entities,
            &mut cx.layouts.lay_taffy_tree,
            &mut cx.layouts.lay_taffy_nodes,
            &cx.layouts.lay_basic,
            &mut cx.renders.rnd_dirty_entities,
            &cx.outputs.out_rects,
            &mut cx.debug,
        );

        // プレースホルダーの初期スタイル・透過・状態情報をセットアップ
        DndStore::setup_placeholder_properties(cx, pressed_id, placeholder_id, start_rect);

        // 元の要素から子要素トポロジーをプレースホルダーへ移行
        DndStore::transfer_children_to_placeholder(
            pressed_id,
            placeholder_id,
            &mut cx.topology.topo_active_masks,
            &mut cx.topology.topo_parents,
            &mut cx.topology.topo_children,
            &mut cx.layouts.lay_dirty_entities,
            &mut cx.layouts.lay_taffy_tree,
            &cx.layouts.lay_taffy_nodes,
            &mut cx.debug,
        );

        // プレースホルダーアタッチ前の、本当の元の親要素のIDを記録
        let original_parent = *cx.topology.topo_parents.at(pressed_id);

        // セッション開始
        cx.states.dnd.dnd_active_drag_state = Some(ActiveDragState {
            source_entity: pressed_id,
            placeholder_entity: placeholder_id,
            current_drop_target: None,
            start_mouse_pos: logical_pos,
            start_rect,
            click_offset,
            original_parent,
        });

        // ドラッグ開始コールバック
        handle_on_dnd_drag_start(
            cx,
            pressed_id,
            Element::from(pressed_id),
            Element::from(placeholder_id),
        );
    }

    #[track_caller]
    pub(crate) fn propagate_dnd_drag_events(
        cx: &mut Context,
        prev_pos: Option<LayoutPoint>,
        logical_pos: LayoutPoint,
    ) {
        let Some(pressed_id) = cx.events.evt_interaction_states.pressed else {
            return;
        };
        let Some(prev) = prev_pos else {
            return;
        };

        let delta = LayoutPoint::new(logical_pos.x - prev.x, logical_pos.y - prev.y);
        if delta.x == 0.0 && delta.y == 0.0 {
            return;
        }

        Pipeline::update_state(cx, pressed_id, ComponentMask::STATE_DRAGGED, true);
        cx.events.evt_interaction_states.dragged = Some(pressed_id);

        // D&D 設定（STYLE_DRAGGABLE）を持っている場合のセッションのキック
        if cx
            .topology
            .topo_active_masks
            .at(pressed_id)
            .has(ComponentMask::STYLE_DND_DRAGGABLE)
            && cx.states.dnd.dnd_active_drag_state.is_none()
        {
            DndStore::start_dnd_drag_session(cx, pressed_id, logical_pos);
        }

        handle_on_drag(cx, pressed_id, delta);
    }

    fn calculate_dnd_relative_local(
        root: EntityId,
        drag_prop: &DndDragProperty,
        lay_basic: &BasicLayoutsSecondary,
        out_rects: &RectsSecondary,
        debug: &mut DebugStore,
    ) -> (LayoutRect, f32, f32) {
        let p =
            DndStore::resolve_dnd_placeholder_parent(root, drag_prop, lay_basic, out_rects, debug);
        (p.rect, p.border_left, p.border_top)
    }

    pub(crate) fn update_inset_based_relative_local(
        root: EntityId,
        placeholder: EntityId,
        logical_pos: LayoutPoint,
        drag_prop: &DndDragProperty,
        drag_state: &ActiveDragState,
        topo_active_masks: &mut ActiveMasksSecondary,
        topo_parents: &ParentsSecondary,
        lay_dirty_entities: &mut DirtyLayoutEntitiesVec,
        lay_taffy_tree: &mut TaffyTreeEntityId,
        lay_basic: &mut BasicLayoutsSecondary,
        lay_base_basic: &mut BaseBasicLayoutsSecondary,
        lay_taffy_nodes: &TaffyNodesSecondary,
        rnd_dirty_entities: &mut DirtyRenderEntitiesVec,
        out_rects: &RectsSecondary,
        debug: &mut DebugStore,
    ) {
        // アタッチ先親コンテナ基準での相対ローカル座標を逆算して追従（Inset更新）
        let (parent_rect, b_l, b_t) =
            DndStore::calculate_dnd_relative_local(root, drag_prop, lay_basic, out_rects, debug);

        // マウスのドラッグ開始時クリックオフセットを用いて、ローカル Top-Left 座標を算出
        let local_x = logical_pos.x - (parent_rect.x + b_l) - drag_state.click_offset.x;
        let local_y = logical_pos.y - (parent_rect.y + b_t) - drag_state.click_offset.y;

        let basic = lay_basic.at_mut(placeholder);
        basic.inset.left = Val::Px(local_x);
        basic.inset.top = Val::Px(local_y);
        basic.inset.right = Val::Auto;
        basic.inset.bottom = Val::Auto;

        let base_basic = lay_base_basic.at_mut(placeholder);
        base_basic.inset.left = Val::Px(local_x);
        base_basic.inset.top = Val::Px(local_y);
        base_basic.inset.right = Val::Auto;
        base_basic.inset.bottom = Val::Auto;

        LayoutStore::mark_layout_dirty(
            placeholder,
            topo_active_masks,
            topo_parents,
            lay_dirty_entities,
            lay_taffy_tree,
            lay_taffy_nodes,
            debug,
        );
        RenderStore::mark_render_dirty(placeholder, topo_active_masks, rnd_dirty_entities);
    }

    pub(crate) fn detect_drop_target_during_intrusion(
        src_id: EntityId,
        hit_id: Option<EntityId>,
        placeholder: EntityId,
        topo_active_masks: &ActiveMasksSecondary,
        topo_parents: &ParentsSecondary,
    ) -> Option<EntityId> {
        let hit_id = hit_id?;
        // ヒットした要素がドラッグ元自身、またはその子孫である場合は、
        // 自身のサブツリーをすべてスキップするためにドラッグ元の親から探索を開始
        let is_descendant = TopologyStore::is_descendant_of(hit_id, src_id, topo_parents);
        let mut current_id = if hit_id == src_id || is_descendant {
            *topo_parents.at(src_id)
        } else {
            Some(hit_id)
        };

        while let Some(id) = current_id {
            let is_dnd = topo_active_masks
                .at(id)
                .has(ComponentMask::STYLE_DND_DROPPABLE);

            if id != placeholder && is_dnd {
                return Some(id); // ドロップ先を見つけたら即座に返す
            }
            current_id = *topo_parents.at(id);
        }

        None
    }

    pub(crate) fn sync_state_drag_in(cx: &mut Context, found_drop_target: Option<EntityId>) {
        let Some(mut drag_state) = cx.states.dnd.dnd_active_drag_state.take() else {
            return;
        };

        if found_drop_target == drag_state.current_drop_target {
            cx.states.dnd.dnd_active_drag_state = Some(drag_state);
            return;
        }

        if let Some(old_target) = drag_state.current_drop_target {
            Pipeline::update_state(cx, old_target, ComponentMask::STATE_DND_DRAG_IN, false);
        }
        if let Some(new_target) = found_drop_target {
            Pipeline::update_state(cx, new_target, ComponentMask::STATE_DND_DRAG_IN, true);
        }

        drag_state.current_drop_target = found_drop_target;
        cx.states.dnd.dnd_active_drag_state = Some(drag_state);
    }

    pub(crate) fn callback_drag_prop(
        cx: &mut Context,
        src_id: EntityId,
        found_drop_target: Option<EntityId>,
        drag_prop: &DndDragProperty,
    ) {
        match drag_prop.drag_mode {
            DndDragPayload::Element => {
                handle_on_dnd_entity_drag(
                    cx,
                    src_id,
                    Element::from(src_id),
                    found_drop_target.map(Element::from),
                );
            }
            DndDragPayload::EntityId => {
                handle_on_dnd_id_drag(cx, src_id, src_id, found_drop_target);
            }
        }
    }

    #[inline]
    fn remove_dragged_elemet(
        src_id: EntityId,
        drag_state: &ActiveDragState,
        topo_active_masks: &mut ActiveMasksSecondary,
        topo_children: &mut ChildrenSecondary,
        topo_parents: &ParentsSecondary,
        lay_dirty_entities: &mut DirtyLayoutEntitiesVec,
        lay_taffy_tree: &mut TaffyTreeEntityId,
        lay_taffy_nodes: &TaffyNodesSecondary,
        debug: &mut DebugStore,
    ) {
        let Some(src_parent_id) = drag_state.original_parent else {
            return;
        };

        topo_children.at_mut(src_parent_id).retain(|x| *x != src_id);

        // 旧親側の Taffy 順序も再同期
        LayoutStore::resync_taffy_children_order(
            src_parent_id,
            topo_children,
            lay_taffy_tree,
            lay_taffy_nodes,
            debug,
        );
        LayoutStore::mark_layout_dirty(
            src_parent_id,
            topo_active_masks,
            topo_parents,
            lay_dirty_entities,
            lay_taffy_tree,
            lay_taffy_nodes,
            debug,
        );
    }

    #[track_caller]
    fn dnd_rewrite_tree_topology(
        src_id: EntityId,
        target_id: EntityId,
        holder: EntityId,
        drag_prop: &DndDragProperty,
        evt_current_pointer_position: Option<LayoutPoint>,
        topo_active_masks: &mut ActiveMasksSecondary,
        topo_parents: &mut ParentsSecondary,
        topo_children: &mut ChildrenSecondary,
        topo_is_structure_dirty: &mut bool,
        topo_is_sort_dirty: &mut bool,
        lay_dirty_entities: &mut DirtyLayoutEntitiesVec,
        lay_taffy_tree: &mut TaffyTreeEntityId,
        lay_taffy_nodes: &mut TaffyNodesSecondary,
        lay_basic: &mut BasicLayoutsSecondary,
        lay_base_basic: &mut BaseBasicLayoutsSecondary,
        lay_flex: &FlexLayoutsSecondary,
        out_rects: &RectsSecondary,
        debug: &mut DebugStore,
    ) {
        let basic = lay_basic.at_mut(src_id);

        // ドラッグ元要素の配置
        if basic.position == Position::Absolute {
            // 絶対配置: 位置移動（補正）を伴うアタッチ
            if drag_prop.update_position {
                // プレースホルダーの最終的な絶対画面座標を取得
                let ph_abs_rect = out_rects.find_or_default(holder, debug);
                // 新しい親（target_id）の絶対画面座標とボーダー厚みを取得
                let target_rect = out_rects.find_or_default(target_id, debug);

                let border = LayoutStore::get_physical_border(target_rect, basic.border);

                // 新しい親を基準にした新しいローカル相対位置を逆算して割り出す
                let new_inset_left = ph_abs_rect.x - (target_rect.x + border.left);
                let new_inset_top = ph_abs_rect.y - (target_rect.y + border.top);

                let new_inset = Rect {
                    top: Val::Px(new_inset_top),
                    right: Val::Auto,
                    bottom: Val::Auto,
                    left: Val::Px(new_inset_left),
                };

                basic.inset = new_inset;
                lay_base_basic.at_mut(src_id).inset = new_inset;
            }

            // ドロップ先コンテナ（target_id）の末尾の子要素としてマウント
            TopologyStore::add_child(
                target_id,
                src_id,
                topo_active_masks,
                topo_parents,
                topo_children,
                topo_is_structure_dirty,
                topo_is_sort_dirty,
                lay_dirty_entities,
                lay_taffy_tree,
                lay_taffy_nodes,
                debug,
            );

            return;
        }
        // 相対配置: マウス座標に基づいた子要素の動的並び替えアタッチ
        if drag_prop.update_position {
            let mouse_pos = evt_current_pointer_position.unwrap_or_default();
            let insert_idx = TopologyStore::calculate_insert_index(
                target_id,
                mouse_pos,
                topo_children,
                lay_flex,
                out_rects,
            );

            // 算出されたインデックス位置へ挿入
            topo_children.at_mut(target_id).insert(insert_idx, src_id);
            topo_parents.insert(src_id, Some(target_id));

            // Taffy 側のノード順序を物理並び替え結果に沿って一括して再同期
            LayoutStore::resync_taffy_children_order(
                target_id,
                topo_children,
                lay_taffy_tree,
                lay_taffy_nodes,
                debug,
            );
        } else {
            // 自動更新オフの場合は末尾に通常アタッチ
            TopologyStore::add_child(
                target_id,
                src_id,
                topo_active_masks,
                topo_parents,
                topo_children,
                topo_is_structure_dirty,
                topo_is_sort_dirty,
                lay_dirty_entities,
                lay_taffy_tree,
                lay_taffy_nodes,
                debug,
            );
        }
        LayoutStore::mark_layout_dirty(
            target_id,
            topo_active_masks,
            topo_parents,
            lay_dirty_entities,
            lay_taffy_tree,
            lay_taffy_nodes,
            debug,
        );
    }

    /// ドラッグ＆ドロップの終了・ドロップ確定処理
    pub(crate) fn handle_dnd_drop(cx: &mut Context, drag_state: &ActiveDragState) {
        let src_id = drag_state.source_entity;
        let holder = drag_state.placeholder_entity;

        let Some(drag_prop) = cx.states.dnd.dnd_drag_properties.find(src_id).copied() else {
            return;
        };

        // 疑似クラスの解除
        Pipeline::update_state(cx, src_id, ComponentMask::STATE_DND_DRAGGING, false);
        if let Some(target_id) = drag_state.current_drop_target {
            Pipeline::update_state(cx, target_id, ComponentMask::STATE_DND_DRAG_IN, false);
        }

        cx.events.evt_interaction_states.pressed = None;
        cx.events.evt_interaction_states.dragged = None;

        let drop_success = drag_state.current_drop_target;

        // トポロジー書き換え（要素移動時のみ）
        if let Some(target_id) = drop_success
            && drag_prop.drag_mode == DndDragPayload::Element
            && cx.states.dnd.dnd_drop_properties.contains(target_id)
        {
            DndStore::remove_dragged_elemet(
                src_id,
                drag_state,
                &mut cx.topology.topo_active_masks,
                &mut cx.topology.topo_children,
                &cx.topology.topo_parents,
                &mut cx.layouts.lay_dirty_entities,
                &mut cx.layouts.lay_taffy_tree,
                &cx.layouts.lay_taffy_nodes,
                &mut cx.debug,
            );
            DndStore::dnd_rewrite_tree_topology(
                src_id,
                target_id,
                holder,
                &drag_prop,
                cx.events.evt_current_pointer_position,
                &mut cx.topology.topo_active_masks,
                &mut cx.topology.topo_parents,
                &mut cx.topology.topo_children,
                &mut cx.topology.topo_is_structure_dirty,
                &mut cx.topology.topo_is_sort_dirty,
                &mut cx.layouts.lay_dirty_entities,
                &mut cx.layouts.lay_taffy_tree,
                &mut cx.layouts.lay_taffy_nodes,
                &mut cx.layouts.lay_basic,
                &mut cx.layouts.lay_base_basic,
                &cx.layouts.lay_flex,
                &cx.outputs.out_rects,
                &mut cx.debug,
            );
            cx.topology.topo_is_structure_dirty = true;
            cx.topology.topo_is_sort_dirty = true;
        }

        // 子要素のツリー構造復元
        TopologyStore::restore_child(
            src_id,
            holder,
            &mut cx.topology.topo_parents,
            &mut cx.topology.topo_children,
            &mut cx.layouts.lay_taffy_tree,
            &mut cx.layouts.lay_taffy_nodes,
            &mut cx.debug,
        );
        cx.topology.topo_children.at_mut(holder).clear();

        for id in [src_id, holder] {
            LayoutStore::mark_layout_dirty(
                id,
                &mut cx.topology.topo_active_masks,
                &cx.topology.topo_parents,
                &mut cx.layouts.lay_dirty_entities,
                &mut cx.layouts.lay_taffy_tree,
                &cx.layouts.lay_taffy_nodes,
                &mut cx.debug,
            );
        }

        match drag_prop.drag_mode {
            DndDragPayload::Element => {
                handle_on_dnd_entity_drop(
                    cx,
                    src_id,
                    Element::from(src_id),
                    drop_success.map(Element::from),
                );
            }
            DndDragPayload::EntityId => {
                handle_on_dnd_id_drop(cx, src_id, src_id, drop_success);
            }
        }

        // プレースホルダー破棄
        TopologyStore::despawn_internal(
            holder,
            &mut cx.window,
            &mut cx.system,
            &mut cx.reactive,
            &mut cx.events,
            &mut cx.contents,
            &mut cx.topology,
            &mut cx.states,
            &mut cx.layouts,
            &mut cx.renders,
            &mut cx.outputs,
            &mut cx.debug,
            &mut cx.acce,
        );

        if let Some(pos) = cx.events.evt_current_pointer_position {
            EventStore::inject_pointer_move(cx, pos);
        }

        RenderStore::mark_render_dirty(
            src_id,
            &mut cx.topology.topo_active_masks,
            &mut cx.renders.rnd_dirty_entities,
        );
    }
}