use rxrust::ops::filter_map::FilterMapOp;

use super::EventCommon;
use crate::{
  data_widget::compose_child_as_data_widget, impl_compose_child_for_listener, impl_listener,
  impl_query_self_only, prelude::*,
};
use std::{
  convert::Infallible,
  time::{Duration, Instant},
};

mod from_mouse;
const MULTI_TAP_DURATION: Duration = Duration::from_millis(250);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PointerId(usize);

/// The pointer is a hardware-agnostic device that can target a specific set of
/// screen coordinates. Having a single event model for pointers can simplify
/// creating Web sites and applications and provide a good user experience
/// regardless of the user's hardware. However, for scenarios when
/// device-specific handling is desired, pointer events defines a pointerType
/// property to inspect the device type which produced the event.
/// Reference: <https://developer.mozilla.org/en-US/docs/Web/API/Pointer_events#term_pointer_event>
#[derive(Debug, Clone)]
pub struct PointerEvent {
  /// A unique identifier for the pointer causing the event.
  pub id: PointerId,
  /// The width (magnitude on the X axis), in pixels, of the contact geometry of
  /// the pointer.
  pub width: f32,
  /// the height (magnitude on the Y axis), in pixels, of the contact geometry
  /// of the pointer.
  pub height: f32,
  /// the normalized pressure of the pointer input in the range of 0 to 1, where
  /// 0 and 1 represent the minimum and maximum pressure the hardware is capable
  /// of detecting, respectively. tangentialPressure
  /// The normalized tangential pressure of the pointer input (also known as
  /// barrel pressure or cylinder stress) in the range -1 to 1, where 0 is the
  /// neutral position of the control.
  pub pressure: f32,
  /// The plane angle (in degrees, in the range of -90 to 90) between the Y–Z
  /// plane and the plane containing both the pointer (e.g. pen stylus) axis and
  /// the Y axis.
  pub tilt_x: f32,
  /// The plane angle (in degrees, in the range of -90 to 90) between the X–Z
  /// plane and the plane containing both the pointer (e.g. pen stylus) axis and
  /// the X axis.
  pub tilt_y: f32,
  /// The clockwise rotation of the pointer (e.g. pen stylus) around its major
  /// axis in degrees, with a value in the range 0 to 359.
  pub twist: f32,
  ///  Indicates the device type that caused the event (mouse, pen, touch, etc.)
  pub point_type: PointerType,
  /// Indicates if the pointer represents the primary pointer of this pointer
  /// type.
  pub is_primary: bool,

  pub common: EventCommon,
}

bitflags! {
  #[derive(Default)]
  pub struct MouseButtons: u8 {
    /// Primary button (usually the left button)
    const PRIMARY = 0b0000_0001;
    /// Secondary button (usually the right button)
    const SECONDARY = 0b0000_0010;
    /// Auxiliary button (usually the mouse wheel button or middle button)
    const AUXILIARY = 0b0000_0100;
    /// 4th button (typically the "Browser Back" button)
    const FOURTH = 0b0000_1000;
    /// 5th button (typically the "Browser Forward" button)
    const FIFTH = 0b0001_0000;
  }
}

#[derive(Debug, Clone, PartialEq)]
pub enum PointerType {
  /// The event was generated by a mouse device.
  Mouse,
  /// The event was generated by a pen or stylus device.
  Pen,
  /// The event was generated by a touch, such as a finger.
  Touch,
}

impl std::borrow::Borrow<EventCommon> for PointerEvent {
  #[inline]
  fn borrow(&self) -> &EventCommon { &self.common }
}

impl std::borrow::BorrowMut<EventCommon> for PointerEvent {
  #[inline]
  fn borrow_mut(&mut self) -> &mut EventCommon { &mut self.common }
}

impl std::ops::Deref for PointerEvent {
  type Target = EventCommon;
  #[inline]
  fn deref(&self) -> &Self::Target { &self.common }
}

impl std::ops::DerefMut for PointerEvent {
  #[inline]
  fn deref_mut(&mut self) -> &mut Self::Target { &mut self.common }
}

#[derive(Declare)]
pub struct PointerDownListener {
  #[declare(builtin, convert=custom)]
  on_pointer_down: MutRefItemSubject<'static, PointerEvent, Infallible>,
}

#[derive(Declare)]
pub struct PointerUpListener {
  #[declare(builtin, convert=custom)]
  on_pointer_up: MutRefItemSubject<'static, PointerEvent, Infallible>,
}

#[derive(Declare)]
pub struct PointerMoveListener {
  #[declare(builtin, convert=custom)]
  on_pointer_move: MutRefItemSubject<'static, PointerEvent, Infallible>,
}

#[derive(Declare)]
pub struct TapListener {
  #[declare(builtin, convert=custom)]
  on_tap: MutRefItemSubject<'static, PointerEvent, Infallible>,
}

#[derive(Declare)]
pub struct PointerCancelListener {
  #[declare(builtin, convert=custom)]
  pub on_pointer_cancel: MutRefItemSubject<'static, PointerEvent, Infallible>,
}
#[derive(Declare)]
pub struct PointerEnterListener {
  #[declare(builtin, convert=custom)]
  on_pointer_enter: MutRefItemSubject<'static, PointerEvent, Infallible>,
}

#[derive(Declare)]
pub struct PointerLeaveListener {
  #[declare(builtin, convert=custom)]
  pub on_pointer_leave: MutRefItemSubject<'static, PointerEvent, Infallible>,
}

macro_rules! impl_pointer_listener {
  ($listener:ident, $declarer: ident, $field: ident, $event_ty: ident, $stream_name: ident) => {
    impl_listener!($listener, $declarer, $field, $event_ty, $stream_name);
    impl_compose_child_for_listener!($listener);
  };
}

impl_pointer_listener!(
  PointerDownListener,
  PointerDownListenerDeclarer,
  on_pointer_down,
  PointerEvent,
  point_down_stream
);

impl_pointer_listener!(
  PointerUpListener,
  PointerUpListenerDeclarer,
  on_pointer_up,
  PointerEvent,
  point_up_stream
);

impl_pointer_listener!(
  PointerMoveListener,
  PointerMoveListenerDeclarer,
  on_pointer_move,
  PointerEvent,
  pointer_move_stream
);

impl_pointer_listener!(
  PointerCancelListener,
  PointerCancelListenerDeclarer,
  on_pointer_cancel,
  PointerEvent,
  pointer_cancel_stream
);

impl_pointer_listener!(
  PointerEnterListener,
  PointerEnterListenerDeclarer,
  on_pointer_enter,
  PointerEvent,
  pointer_enter_stream
);

impl_pointer_listener!(
  PointerLeaveListener,
  PointerLeaveListenerDeclarer,
  on_pointer_leave,
  PointerEvent,
  pointer_leave_stream
);

impl TapListenerDeclarer {
  pub fn on_tap(mut self, handler: impl for<'r> FnMut(&'r mut PointerEvent) + 'static) -> Self {
    self.tap_subject().subscribe(handler);
    self
  }

  pub fn on_x_times_tap(
    mut self,
    (times, handler): (usize, impl for<'r> FnMut(&'r mut PointerEvent) + 'static),
  ) -> Self {
    self
      .tap_subject()
      .filter_map(x_times_tap_map_filter(times, MULTI_TAP_DURATION))
      .subscribe(handler);
    self
  }

  pub fn on_double_tap(self, handler: impl for<'r> FnMut(&'r mut PointerEvent) + 'static) -> Self {
    self.on_x_times_tap((2, handler))
  }

  pub fn on_triple_tap(self, handler: impl for<'r> FnMut(&'r mut PointerEvent) + 'static) -> Self {
    self.on_x_times_tap((3, handler))
  }

  fn tap_subject(&mut self) -> MutRefItemSubject<'static, PointerEvent, Infallible> {
    self.on_tap.get_or_insert_with(Default::default).clone()
  }
}

impl Query for TapListener {
  impl_query_self_only!();
}

impl TapListener {
  /// Return an observable stream of this event.
  pub fn tap_steam(&self) -> MutRefItemSubject<'static, PointerEvent, Infallible> {
    self.on_tap.clone()
  }

  /// Return an observable stream of double tap event
  #[inline]
  pub fn double_tap_stream(
    &self,
  ) -> FilterMapOp<
    MutRefItemSubject<'static, PointerEvent, Infallible>,
    impl FnMut(&mut PointerEvent) -> Option<&mut PointerEvent>,
    &mut PointerEvent,
  > {
    self.x_times_tap_stream(2, MULTI_TAP_DURATION)
  }

  /// Return an observable stream of tripe tap event
  #[inline]
  pub fn triple_tap_stream(
    &self,
  ) -> FilterMapOp<
    MutRefItemSubject<'static, PointerEvent, Infallible>,
    impl FnMut(&mut PointerEvent) -> Option<&mut PointerEvent>,
    &mut PointerEvent,
  > {
    self.x_times_tap_stream(2, MULTI_TAP_DURATION)
  }

  /// Return an observable stream of x-tap event that user tapped 'x' times in
  /// the specify duration `dur`.
  pub fn x_times_tap_stream(
    &self,
    x: usize,
    dur: Duration,
  ) -> FilterMapOp<
    MutRefItemSubject<'static, PointerEvent, Infallible>,
    impl FnMut(&mut PointerEvent) -> Option<&mut PointerEvent>,
    &mut PointerEvent,
  > {
    self.tap_steam().filter_map(x_times_tap_map_filter(x, dur))
  }
}

fn x_times_tap_map_filter(
  x: usize,
  dur: Duration,
) -> impl FnMut(&mut PointerEvent) -> Option<&mut PointerEvent> {
  assert!(x > 0);
  struct TapInfo {
    pointer_id: PointerId,
    stamps: Vec<Instant>,
  }

  let mut type_info: Option<TapInfo> = None;
  move |e: &mut PointerEvent| {
    let now = Instant::now();
    match &mut type_info {
      Some(info) if info.pointer_id == e.id => {
        if info.stamps.len() + 1 == x {
          if now.duration_since(info.stamps[0]) <= dur {
            // emit x-tap event and reset the tap info
            type_info = None;
            Some(e)
          } else {
            // remove the expired tap
            info.stamps.remove(0);
            info.stamps.push(now);
            None
          }
        } else {
          info.stamps.push(now);
          None
        }
      }
      _ => {
        type_info = Some(TapInfo { pointer_id: e.id, stamps: vec![now] });
        None
      }
    }
  }
}
impl EventListener for TapListener {
  type Event = PointerEvent;
  #[inline]
  fn dispatch(&self, event: &mut PointerEvent) { self.on_tap.clone().next(event) }
}

impl ComposeChild for TapListener {
  type Child = Widget;
  #[inline]
  fn compose_child(this: State<Self>, child: Self::Child) -> Widget {
    let widget = dynamic_compose_focus_node(child);
    compose_child_as_data_widget(widget, this)
  }
}

#[cfg(test)]
mod tests {
  use super::*;
  use crate::test::MockBox;
  use futures::executor::LocalPool;
  use std::{cell::RefCell, rc::Rc};
  use winit::event::{DeviceId, ElementState, ModifiersState, MouseButton, WindowEvent};

  fn env(times: usize) -> (Window, Rc<RefCell<usize>>) {
    let size = Size::new(400., 400.);
    let count = Rc::new(RefCell::new(0));
    let c_count = count.clone();
    let w = widget! {
      MockBox {
        size,
        on_x_times_tap: (times, move |_| *c_count.borrow_mut() += 1)
      }
    };
    let mut wnd = Window::default_mock(w, Some(size));
    wnd.draw_frame();

    (wnd, count)
  }

  #[test]
  fn double_tap() {
    let (mut wnd, count) = env(2);

    let mut local_pool = LocalPool::new();
    let device_id = unsafe { DeviceId::dummy() };
    observable::interval(Duration::from_millis(10), local_pool.spawner())
      .take(8)
      .subscribe(move |i| {
        wnd.processes_native_event(WindowEvent::MouseInput {
          device_id,
          state: if i % 2 == 0 {
            ElementState::Pressed
          } else {
            ElementState::Released
          },
          button: MouseButton::Left,
          modifiers: ModifiersState::default(),
        });
      });

    local_pool.run();

    assert_eq!(*count.borrow(), 2);

    let (mut wnd, count) = env(2);
    observable::interval(Duration::from_millis(251), local_pool.spawner())
      .take(8)
      .subscribe(move |i| {
        wnd.processes_native_event(WindowEvent::MouseInput {
          device_id,
          state: if i % 2 == 0 {
            ElementState::Pressed
          } else {
            ElementState::Released
          },
          button: MouseButton::Left,
          modifiers: ModifiersState::default(),
        });
      });

    local_pool.run();
    assert_eq!(*count.borrow(), 0);
  }

  #[test]
  fn tripe_tap() {
    let (mut wnd, count) = env(3);

    let mut local_pool = LocalPool::new();
    let device_id = unsafe { DeviceId::dummy() };
    observable::interval(Duration::from_millis(10), local_pool.spawner())
      .take(12)
      .subscribe(move |i| {
        wnd.processes_native_event(WindowEvent::MouseInput {
          device_id,
          state: if i % 2 == 0 {
            ElementState::Pressed
          } else {
            ElementState::Released
          },
          button: MouseButton::Left,
          modifiers: ModifiersState::default(),
        });
      });

    local_pool.run();

    assert_eq!(*count.borrow(), 2);
  }
}