fission-core 0.9.0

use super::{ControllerContext, InputController};
use crate::event::{ExternalDragEvent, InputEvent, PointerEvent};
use crate::scrollbar::{
    scrollbar_drag_offset, scrollbar_drag_offset_with_grab, scrollbar_geometry_for_node,
    scrollbar_hit_test, scrollbar_point_for_node, ScrollbarDragState, ScrollbarHitKind,
};
use crate::{ActionEnvelope, ActionId, ActionInput, DragSessionPayload, DragSessionState};
use fission_ir::op::RichTextAnnotation;
use fission_ir::{semantics::ActionTrigger, Op, WidgetId};
use fission_layout::LayoutPoint;

pub struct GestureController;

impl InputController for GestureController {
    fn handle_event(&mut self, ctx: &mut ControllerContext, event: &InputEvent) -> bool {
        match event {
            InputEvent::Pointer(pe) => {
                match pe {
                    PointerEvent::Down { point, button, .. } => {
                        ctx.gesture.start_point = Some(*point);
                        ctx.gesture.last_point = Some(*point);
                        ctx.gesture.is_panning = false;
                        ctx.gesture.pressed_button = Some(button.clone());
                        ctx.gesture.scrollbar_drag = None;

                        if matches!(button, crate::event::PointerButton::Primary) {
                            if let Some(hit) =
                                scrollbar_hit_test(ctx.ir, ctx.layout, ctx.scroll, *point)
                            {
                                let pointer_to_thumb_start = match hit.kind {
                                    ScrollbarHitKind::Thumb => hit.pointer_to_thumb_start,
                                    ScrollbarHitKind::Rail => hit.geometry.thumb_extent() * 0.5,
                                };
                                let new_offset = match hit.kind {
                                    ScrollbarHitKind::Thumb => hit.geometry.offset,
                                    ScrollbarHitKind::Rail => {
                                        scrollbar_drag_offset(hit.geometry, hit.layout_point)
                                    }
                                };
                                ctx.scroll.set_offset(hit.geometry.node_id, new_offset);
                                ctx.gesture.target_node = Some(hit.geometry.node_id);
                                ctx.gesture.dragging_payload = None;
                                ctx.gesture.scrollbar_drag = Some(ScrollbarDragState {
                                    node_id: hit.geometry.node_id,
                                    pointer_to_thumb_start,
                                });
                                return true;
                            }
                        }

                        if let Some(hit) = crate::hit_test::hit_test_with_scroll(
                            ctx.ir, ctx.layout, ctx.scroll, *point,
                        ) {
                            ctx.gesture.target_node = Some(hit);
                            ctx.gesture.dragging_payload = self.find_drag_payload(ctx, hit);
                        } else {
                            ctx.gesture.target_node = None;
                            ctx.gesture.dragging_payload = None;
                        }
                    }
                    PointerEvent::Move { point, .. } => {
                        if let Some(drag) = ctx.gesture.scrollbar_drag {
                            if let Some(geometry) = scrollbar_geometry_for_node(
                                ctx.ir,
                                ctx.layout,
                                ctx.scroll,
                                drag.node_id,
                            ) {
                                let new_offset = scrollbar_drag_offset_with_grab(
                                    geometry,
                                    scrollbar_point_for_node(
                                        ctx.ir,
                                        ctx.scroll,
                                        drag.node_id,
                                        *point,
                                    ),
                                    drag.pointer_to_thumb_start,
                                );
                                ctx.scroll.set_offset(drag.node_id, new_offset);
                            }
                            ctx.gesture.last_point = Some(*point);
                            return true;
                        }

                        if let Some(start) = ctx.gesture.start_point {
                            let dx = point.x - start.x;
                            let dy = point.y - start.y;
                            let dist_sq = dx * dx + dy * dy;
                            let threshold = 5.0 * 5.0;

                            if !ctx.gesture.is_panning && dist_sq > threshold {
                                ctx.gesture.is_panning = true;
                                if let Some(payload) = ctx.gesture.dragging_payload.clone() {
                                    let target = ctx.gesture.target_node;
                                    let source_identifier =
                                        target.and_then(|id| self.semantic_identifier(ctx, id));
                                    ctx.gesture.drag_session = Some(DragSessionState {
                                        source_node: target,
                                        source_identifier,
                                        payload: DragSessionPayload::Internal(payload),
                                        point: *point,
                                        target_node: None,
                                        target_identifier: None,
                                    });
                                    self.update_drag_target(ctx, *point);
                                }
                                // Dispatch DragStart now
                                if let Some(target) = ctx.gesture.target_node {
                                    self.dispatch_trigger(
                                        ctx,
                                        target,
                                        ActionTrigger::DragStart,
                                        *point,
                                        None,
                                    );
                                }
                            }

                            if ctx.gesture.is_panning {
                                if let Some(session) = ctx.gesture.drag_session.as_mut() {
                                    session.point = *point;
                                }
                                self.update_drag_target(ctx, *point);

                                let last = ctx.gesture.last_point.unwrap_or(start);
                                let delta = LayoutPoint {
                                    x: point.x - last.x,
                                    y: point.y - last.y,
                                };
                                ctx.gesture.last_point = Some(*point);

                                // Try dispatching DragUpdate
                                let dispatched = if let Some(target) = ctx.gesture.target_node {
                                    self.dispatch_trigger(
                                        ctx,
                                        target,
                                        ActionTrigger::DragUpdate,
                                        *point,
                                        Some(delta),
                                    )
                                } else {
                                    false
                                };

                                if dispatched {
                                    return true;
                                }

                                // Fallback to Scroll Panning if DragUpdate not handled
                                if self.handle_pan_update(ctx, delta) {
                                    return true;
                                }
                            }
                        }
                    }
                    PointerEvent::Up {
                        point, modifiers, ..
                    } => {
                        let scrollbar_drag = ctx.gesture.scrollbar_drag.take();
                        let mut handled = false;
                        let was_secondary = matches!(
                            ctx.gesture.pressed_button,
                            Some(crate::event::PointerButton::Secondary)
                        );
                        if ctx.gesture.is_panning {
                            // Internal Drop
                            if let Some(payload) = ctx.gesture.dragging_payload.take() {
                                if let Some(up_hit) = crate::hit_test::hit_test_with_scroll(
                                    ctx.ir, ctx.layout, ctx.scroll, *point,
                                ) {
                                    let _ = self.dispatch_internal_drop(
                                        ctx, up_hit, payload, *point, *modifiers,
                                    );
                                }
                            }

                            if let Some(target) = ctx.gesture.target_node {
                                self.dispatch_trigger(
                                    ctx,
                                    target,
                                    ActionTrigger::DragEnd,
                                    *point,
                                    None,
                                );
                            }
                            handled = true;
                        } else if was_secondary {
                            // Secondary click (right-click)
                            if let Some(target) = ctx.gesture.target_node {
                                if let Some(up_hit) = crate::hit_test::hit_test_with_scroll(
                                    ctx.ir, ctx.layout, ctx.scroll, *point,
                                ) {
                                    if up_hit == target
                                        || self.is_descendant(ctx, up_hit, target)
                                        || self.is_descendant(ctx, target, up_hit)
                                    {
                                        if let Some(menu_owner) =
                                            self.find_context_menu_owner(ctx, up_hit)
                                        {
                                            ctx.context_menu.open(menu_owner, *point);
                                            handled = true;
                                        }

                                        let rich_text_path = self.path_for_node(ctx, up_hit);
                                        if !handled {
                                            if let Some((annotation_node_id, annotation)) =
                                                crate::input::hover::resolve_rich_text_annotation_at_point(
                                                    ctx,
                                                    &rich_text_path,
                                                    *point,
                                                )
                                            {
                                                handled = self.dispatch_annotation_trigger(
                                                    ctx,
                                                    annotation_node_id,
                                                    &annotation,
                                                    ActionTrigger::SecondaryClick,
                                                    *point,
                                                );
                                            }
                                        }

                                        if !handled
                                            && self.dispatch_trigger(
                                                ctx,
                                                target,
                                                ActionTrigger::SecondaryClick,
                                                *point,
                                                None,
                                            )
                                        {
                                            handled = true;
                                        }
                                    }
                                }
                            }
                        } else {
                            // Tap (primary click)
                            if let Some(target) = ctx.gesture.target_node {
                                if let Some(up_hit) = crate::hit_test::hit_test_with_scroll(
                                    ctx.ir, ctx.layout, ctx.scroll, *point,
                                ) {
                                    if up_hit == target
                                        || self.is_descendant(ctx, up_hit, target)
                                        || self.is_descendant(ctx, target, up_hit)
                                    {
                                        let rich_text_path = self.path_for_node(ctx, up_hit);
                                        if let Some((annotation_node_id, annotation)) =
                                            crate::input::hover::resolve_rich_text_annotation_at_point(
                                                ctx,
                                                &rich_text_path,
                                                *point,
                                            )
                                        {
                                            handled = self.dispatch_annotation_trigger(
                                                ctx,
                                                annotation_node_id,
                                                &annotation,
                                                ActionTrigger::Default,
                                                *point,
                                            );
                                        }

                                        if !handled
                                            && self.dispatch_trigger(
                                                ctx,
                                                target,
                                                ActionTrigger::Default,
                                                *point,
                                                None,
                                            )
                                        {
                                            handled = true;
                                        }
                                    }
                                }
                            }
                        }

                        if !was_secondary {
                            ctx.context_menu.close();
                        }
                        ctx.gesture.start_point = None;
                        ctx.gesture.is_panning = false;
                        ctx.gesture.dragging_payload = None;
                        self.clear_drag_target(ctx, *point);
                        ctx.gesture.drag_session = None;
                        ctx.gesture.pressed_button = None;
                        if scrollbar_drag.is_some() {
                            ctx.gesture.target_node = None;
                            return true;
                        }
                        return handled;
                    }
                    _ => {}
                }
            }
            InputEvent::ExternalDrag(event) => match event {
                ExternalDragEvent::Hover { point, paths, .. } => {
                    ctx.gesture.drag_session = Some(DragSessionState {
                        source_node: None,
                        source_identifier: None,
                        payload: DragSessionPayload::ExternalFiles(paths.clone()),
                        point: *point,
                        target_node: ctx
                            .gesture
                            .drag_session
                            .as_ref()
                            .and_then(|s| s.target_node),
                        target_identifier: ctx
                            .gesture
                            .drag_session
                            .as_ref()
                            .and_then(|s| s.target_identifier.clone()),
                    });
                    self.update_drag_target(ctx, *point);
                    return true;
                }
                ExternalDragEvent::Cancel => {
                    let point = ctx
                        .gesture
                        .drag_session
                        .as_ref()
                        .map(|session| session.point)
                        .unwrap_or(LayoutPoint::ZERO);
                    self.clear_drag_target(ctx, point);
                    ctx.gesture.drag_session = None;
                    return true;
                }
                ExternalDragEvent::Drop {
                    point,
                    paths,
                    modifiers,
                } => {
                    ctx.gesture.drag_session = Some(DragSessionState {
                        source_node: None,
                        source_identifier: None,
                        payload: DragSessionPayload::ExternalFiles(paths.clone()),
                        point: *point,
                        target_node: ctx
                            .gesture
                            .drag_session
                            .as_ref()
                            .and_then(|s| s.target_node),
                        target_identifier: ctx
                            .gesture
                            .drag_session
                            .as_ref()
                            .and_then(|s| s.target_identifier.clone()),
                    });
                    self.update_drag_target(ctx, *point);
                    if let Some(target) = ctx
                        .gesture
                        .drag_session
                        .as_ref()
                        .and_then(|s| s.target_node)
                    {
                        let _ = self.dispatch_external_drop(
                            ctx,
                            target,
                            paths.clone(),
                            *point,
                            *modifiers,
                        );
                    }
                    self.clear_drag_target(ctx, *point);
                    ctx.gesture.drag_session = None;
                    return true;
                }
            },
            _ => {}
        }
        false
    }
}

impl GestureController {
    fn path_for_node(&self, ctx: &ControllerContext, node_id: WidgetId) -> Vec<WidgetId> {
        let mut path = Vec::new();
        let mut curr = Some(node_id);
        while let Some(id) = curr {
            path.push(id);
            curr = ctx.ir.nodes.get(&id).and_then(|node| node.parent);
        }
        path
    }

    fn is_descendant(&self, ctx: &ControllerContext, child: WidgetId, ancestor: WidgetId) -> bool {
        let mut curr = Some(child);
        while let Some(id) = curr {
            if id == ancestor {
                return true;
            }
            if let Some(node) = ctx.ir.nodes.get(&id) {
                curr = node.parent;
            } else {
                break;
            }
        }
        false
    }

    fn find_context_menu_owner(
        &self,
        ctx: &ControllerContext,
        start_node: WidgetId,
    ) -> Option<WidgetId> {
        let mut current_id = Some(start_node);
        while let Some(node_id) = current_id {
            let Some(node) = ctx.ir.nodes.get(&node_id) else {
                break;
            };
            if let Op::Semantics(semantics) = &node.op {
                if semantics.context_menu && !semantics.disabled {
                    return Some(node_id);
                }
            }
            current_id = node.parent;
        }
        None
    }

    fn dispatch_annotation_trigger(
        &self,
        ctx: &mut ControllerContext,
        node_id: WidgetId,
        annotation: &RichTextAnnotation,
        trigger: ActionTrigger,
        point: LayoutPoint,
    ) -> bool {
        let Some(action_entry) = annotation
            .actions
            .iter()
            .find(|entry| entry.trigger == trigger)
        else {
            return false;
        };
        let Some(payload) = &action_entry.payload_data else {
            return false;
        };

        let input = crate::input::scoped_action_input(
            ctx.ir,
            node_id,
            ActionInput::Pointer {
                x: point.x,
                y: point.y,
                delta_x: 0.0,
                delta_y: 0.0,
            },
        );
        ctx.dispatched_actions.push((
            node_id,
            ActionEnvelope {
                id: ActionId::from_u128(action_entry.action_id),
                payload: payload.clone(),
            },
            input,
        ));
        true
    }

    fn find_drag_payload(&self, ctx: &ControllerContext, start_node: WidgetId) -> Option<Vec<u8>> {
        let mut current_id = Some(start_node);
        while let Some(node_id) = current_id {
            if let Some(node) = ctx.ir.nodes.get(&node_id) {
                if let Op::Semantics(sem) = &node.op {
                    if let Some(p) = &sem.drag_payload {
                        return Some(p.clone());
                    }
                }
                current_id = node.parent;
            } else {
                break;
            }
        }
        None
    }

    fn semantic_identifier(&self, ctx: &ControllerContext, start_node: WidgetId) -> Option<String> {
        let mut current_id = Some(start_node);
        while let Some(node_id) = current_id {
            if let Some(node) = ctx.ir.nodes.get(&node_id) {
                if let Op::Semantics(sem) = &node.op {
                    if let Some(identifier) = &sem.identifier {
                        return Some(identifier.clone());
                    }
                }
                current_id = node.parent;
            } else {
                break;
            }
        }
        None
    }

    fn find_drop_target(&self, ctx: &ControllerContext, start_node: WidgetId) -> Option<WidgetId> {
        let mut current_id = Some(start_node);
        while let Some(node_id) = current_id {
            if let Some(node) = ctx.ir.nodes.get(&node_id) {
                if let Op::Semantics(sem) = &node.op {
                    if sem
                        .actions
                        .entries
                        .iter()
                        .any(|entry| entry.trigger == ActionTrigger::Drop)
                    {
                        return Some(node_id);
                    }
                }
                current_id = node.parent;
            } else {
                break;
            }
        }
        None
    }

    fn update_drag_target(&self, ctx: &mut ControllerContext, point: LayoutPoint) {
        let next_target =
            crate::hit_test::hit_test_with_scroll(ctx.ir, ctx.layout, ctx.scroll, point)
                .and_then(|hit| self.find_drop_target(ctx, hit));

        let previous_target = ctx
            .gesture
            .drag_session
            .as_ref()
            .and_then(|s| s.target_node);
        if previous_target == next_target {
            return;
        }

        if let Some(previous) = previous_target {
            self.dispatch_trigger(ctx, previous, ActionTrigger::DragLeave, point, None);
        }
        if let Some(next) = next_target {
            self.dispatch_trigger(ctx, next, ActionTrigger::DragEnter, point, None);
        }

        let next_identifier = next_target.and_then(|id| self.semantic_identifier(ctx, id));
        if let Some(session) = ctx.gesture.drag_session.as_mut() {
            session.target_node = next_target;
            session.target_identifier = next_identifier;
        }
    }

    fn clear_drag_target(&self, ctx: &mut ControllerContext, point: LayoutPoint) {
        if let Some(previous) = ctx
            .gesture
            .drag_session
            .as_ref()
            .and_then(|s| s.target_node)
        {
            self.dispatch_trigger(ctx, previous, ActionTrigger::DragLeave, point, None);
        }
        if let Some(session) = ctx.gesture.drag_session.as_mut() {
            session.target_node = None;
            session.target_identifier = None;
        }
    }

    fn dispatch_internal_drop(
        &self,
        ctx: &mut ControllerContext,
        target_node: WidgetId,
        payload: Vec<u8>,
        point: LayoutPoint,
        modifiers: u8,
    ) -> bool {
        let mut current_id = Some(target_node);
        while let Some(node_id) = current_id {
            if let Some(node) = ctx.ir.nodes.get(&node_id) {
                if let Op::Semantics(sem) = &node.op {
                    for entry in &sem.actions.entries {
                        if entry.trigger == ActionTrigger::Drop {
                            let envelope = ActionEnvelope {
                                id: ActionId::from_u128(entry.action_id),
                                payload: entry.payload_data.clone().unwrap_or_default(),
                            };

                            let input = crate::input::scoped_action_input(
                                ctx.ir,
                                node_id,
                                ActionInput::InternalDrop {
                                    payload: payload.clone(),
                                    x: point.x,
                                    y: point.y,
                                    modifiers,
                                },
                            );

                            ctx.dispatched_actions.push((node_id, envelope, input));
                            return true;
                        }
                    }
                }
                current_id = node.parent;
            } else {
                break;
            }
        }
        false
    }

    fn dispatch_external_drop(
        &self,
        ctx: &mut ControllerContext,
        target_node: WidgetId,
        paths: Vec<String>,
        point: LayoutPoint,
        modifiers: u8,
    ) -> bool {
        let mut current_id = Some(target_node);
        while let Some(node_id) = current_id {
            if let Some(node) = ctx.ir.nodes.get(&node_id) {
                if let Op::Semantics(sem) = &node.op {
                    for entry in &sem.actions.entries {
                        if entry.trigger == ActionTrigger::Drop {
                            let envelope = ActionEnvelope {
                                id: ActionId::from_u128(entry.action_id),
                                payload: entry.payload_data.clone().unwrap_or_default(),
                            };

                            let input = crate::input::scoped_action_input(
                                ctx.ir,
                                node_id,
                                ActionInput::Drop {
                                    paths: paths.clone(),
                                    x: point.x,
                                    y: point.y,
                                    modifiers,
                                },
                            );

                            ctx.dispatched_actions.push((node_id, envelope, input));
                            return true;
                        }
                    }
                }
                current_id = node.parent;
            } else {
                break;
            }
        }
        false
    }

    fn dispatch_trigger(
        &self,
        ctx: &mut ControllerContext,
        start_node: WidgetId,
        trigger: ActionTrigger,
        point: LayoutPoint,
        delta: Option<LayoutPoint>,
    ) -> bool {
        let mut current_id = Some(start_node);
        while let Some(node_id) = current_id {
            if let Some(node) = ctx.ir.nodes.get(&node_id) {
                if let Op::Semantics(sem) = &node.op {
                    for entry in &sem.actions.entries {
                        if entry.trigger == trigger {
                            let envelope = ActionEnvelope {
                                id: ActionId::from_u128(entry.action_id),
                                payload: entry.payload_data.clone().unwrap_or_default(),
                            };

                            let input = crate::input::scoped_action_input(
                                ctx.ir,
                                node_id,
                                ActionInput::Pointer {
                                    x: point.x,
                                    y: point.y,
                                    delta_x: delta.map(|d| d.x).unwrap_or(0.0),
                                    delta_y: delta.map(|d| d.y).unwrap_or(0.0),
                                },
                            );

                            ctx.dispatched_actions.push((node_id, envelope, input));
                            return true;
                        }
                    }
                }
                current_id = node.parent;
            } else {
                break;
            }
        }
        false
    }

    fn handle_pan_update(&self, ctx: &mut ControllerContext, delta: LayoutPoint) -> bool {
        if let Some(target) = ctx.gesture.target_node {
            let mut current = Some(target);
            while let Some(id) = current {
                if let Some(node) = ctx.ir.nodes.get(&id) {
                    if let fission_ir::Op::Semantics(sem) = &node.op {
                        if sem.draggable {
                            return false;
                        }
                    }
                    if let fission_ir::Op::Layout(fission_ir::op::LayoutOp::Scroll {
                        direction,
                        ..
                    }) = &node.op
                    {
                        let current_offset = ctx.scroll.get_offset(id);
                        let move_val = match direction {
                            fission_ir::op::FlexDirection::Row => -delta.x,
                            fission_ir::op::FlexDirection::Column => -delta.y,
                        };

                        let mut new_offset = current_offset + move_val;

                        if let Some(geom) = ctx.layout.get_node_geometry(id) {
                            let max_offset =
                                if matches!(direction, fission_ir::op::FlexDirection::Row) {
                                    (geom.content_size.width - geom.rect.width()).max(0.0)
                                } else {
                                    (geom.content_size.height - geom.rect.height()).max(0.0)
                                };
                            new_offset = new_offset.clamp(0.0, max_offset);
                        }

                        ctx.scroll.set_offset(id, new_offset);
                        return true;
                    }
                    current = node.parent;
                } else {
                    break;
                }
            }
        }
        false
    }
}