use crate::{
    group_bounds, AnyElement, Bounds, DispatchPhase, Element, ElementId, IdentifiedElement,
    IntoAnyElement, LayoutId, MouseMoveEvent, ParentElement, Pixels, SharedString, Style,
    StyleCascade, StyleRefinement, Styled, ViewContext,
};
use refineable::CascadeSlot;
use std::sync::{
    atomic::{AtomicBool, Ordering::SeqCst},
    Arc,
};

pub trait Hoverable {
    fn hover_style(&mut self) -> &mut StyleRefinement;

    fn hover(mut self, f: impl FnOnce(&mut StyleRefinement) -> &mut StyleRefinement) -> Self
    where
        Self: Sized,
    {
        f(self.hover_style());
        self
    }
}

pub struct HoverableElement<E> {
    hover_style: StyleRefinement,
    group: Option<SharedString>,
    cascade_slot: CascadeSlot,
    hovered: Arc<AtomicBool>,
    child: E,
}

impl<E: Styled + Element> HoverableElement<E> {
    pub fn new(mut child: E) -> Self {
        let cascade_slot = child.style_cascade().reserve();
        HoverableElement {
            hover_style: StyleRefinement::default(),
            group: None,
            cascade_slot,
            hovered: Arc::new(AtomicBool::new(false)),
            child,
        }
    }

    pub fn replace_child<E2: Element<ViewState = E::ViewState>>(
        self,
        replace: impl FnOnce(E) -> E2,
    ) -> HoverableElement<E2> {
        HoverableElement {
            hover_style: self.hover_style,
            group: self.group,
            cascade_slot: self.cascade_slot,
            hovered: self.hovered,
            child: replace(self.child),
        }
    }
}

impl<E> IntoAnyElement<E::ViewState> for HoverableElement<E>
where
    E: Styled + Element,
{
    fn into_any(self) -> AnyElement<E::ViewState> {
        AnyElement::new(self)
    }
}

impl<E> Element for HoverableElement<E>
where
    E: Styled + Element,
{
    type ViewState = E::ViewState;
    type ElementState = E::ElementState;

    fn id(&self) -> Option<ElementId> {
        self.child.id()
    }

    fn layout(
        &mut self,
        state: &mut Self::ViewState,
        element_state: Option<Self::ElementState>,
        cx: &mut ViewContext<Self::ViewState>,
    ) -> (LayoutId, Self::ElementState) {
        self.child.layout(state, element_state, cx)
    }

    fn paint(
        &mut self,
        bounds: Bounds<Pixels>,
        state: &mut Self::ViewState,
        element_state: &mut Self::ElementState,
        cx: &mut ViewContext<Self::ViewState>,
    ) {
        let target_bounds = self
            .group
            .as_ref()
            .and_then(|group| group_bounds(group, cx))
            .unwrap_or(bounds);

        let hovered = target_bounds.contains_point(cx.mouse_position());

        let slot = self.cascade_slot;
        let style = hovered.then_some(self.hover_style.clone());
        self.child.style_cascade().set(slot, style);
        self.hovered.store(hovered, SeqCst);

        let hovered = self.hovered.clone();
        cx.on_mouse_event(move |_, event: &MouseMoveEvent, phase, cx| {
            if phase == DispatchPhase::Capture {
                if target_bounds.contains_point(event.position) != hovered.load(SeqCst) {
                    cx.notify();
                }
            }
        });

        self.child.paint(bounds, state, element_state, cx);
    }
}

impl<E> ParentElement for HoverableElement<E>
where
    E: Styled + ParentElement,
{
    fn children_mut(&mut self) -> &mut smallvec::SmallVec<[AnyElement<E::ViewState>; 2]> {
        self.child.children_mut()
    }

    fn group_mut(&mut self) -> &mut Option<SharedString> {
        self.child.group_mut()
    }
}

impl<E: Styled + Element> Hoverable for HoverableElement<E> {
    fn hover_style(&mut self) -> &mut StyleRefinement {
        &mut self.hover_style
    }
}

impl<E: Styled + Element> Styled for HoverableElement<E> {
    fn style_cascade(&mut self) -> &mut StyleCascade {
        self.child.style_cascade()
    }

    fn computed_style(&mut self) -> &Style {
        self.child.computed_style()
    }
}

impl<E: Styled + IdentifiedElement> IdentifiedElement for HoverableElement<E> {}