use std::{marker::Unsize, mem::MaybeUninit, ops::CoerceUnsized, sync::mpsc::Sender};

use crate::{
    HasUi, Widget,
    util::{RefCounter, SlotId},
};

pub type WidgetId = SlotId;

/// An identifier for a widget that can index a UI or event ctx to get it.
/// This is a strong handle that does not impl Clone, and when it is dropped,
/// a signal is sent to the owning UI to clean up the resources.
///
/// TODO: ergonomic clones when they get put in rust-analyzer & don't cause ICEs?
pub struct WidgetHandle<W: ?Sized = dyn Widget> {
    pub(super) id: WidgetId,
    counter: RefCounter,
    send: Sender<WidgetId>,
    ty: *const W,
}

/// A weak handle to a widget.
/// Will not keep it alive, but can still be used for indexing like WidgetHandle.
pub struct WidgetRef<W: ?Sized = dyn Widget> {
    pub(super) id: WidgetId,
    #[allow(unused)]
    ty: *const W,
}

pub struct WidgetHandles<W: ?Sized = dyn Widget> {
    pub h: WidgetHandle<W>,
    pub r: WidgetRef<W>,
}

impl<W: Widget + ?Sized + Unsize<dyn Widget>> WidgetHandle<W> {
    pub fn any(self) -> WidgetHandle<dyn Widget> {
        self
    }
}

impl<W: ?Sized> WidgetHandle<W> {
    pub(crate) fn new(id: WidgetId, send: Sender<WidgetId>) -> Self {
        Self {
            id,
            counter: RefCounter::new(),
            send,
            ty: unsafe { MaybeUninit::zeroed().assume_init() },
        }
    }

    pub fn id(&self) -> WidgetId {
        self.id
    }

    pub fn refs(&self) -> u32 {
        self.counter.refs()
    }

    pub fn weak(&self) -> WidgetRef<W> {
        let Self { ty, id, .. } = *self;
        WidgetRef { ty, id }
    }

    pub fn handles(self) -> WidgetHandles<W> {
        let r = self.weak();
        WidgetHandles { h: self, r }
    }
}

impl<W: ?Sized> WidgetRef<W> {
    pub fn id(&self) -> WidgetId {
        self.id
    }
}

impl<W: ?Sized> Drop for WidgetHandle<W> {
    fn drop(&mut self) {
        if self.counter.drop() {
            let _ = self.send.send(self.id);
        }
    }
}

pub trait WidgetIdFn<State, W: ?Sized = dyn Widget>: FnOnce(&mut State) -> WidgetHandle<W> {}
impl<State, W: ?Sized, F: FnOnce(&mut State) -> WidgetHandle<W>> WidgetIdFn<State, W> for F {}

pub trait IdLike {
    type Widget: Widget + ?Sized + 'static;
    fn id(&self) -> WidgetId;
}

impl<W: Widget + ?Sized> IdLike for &WidgetHandle<W> {
    type Widget = W;
    fn id(&self) -> WidgetId {
        self.id
    }
}

impl<W: Widget + ?Sized> IdLike for WidgetHandle<W> {
    type Widget = W;
    fn id(&self) -> WidgetId {
        self.id
    }
}

impl<W: Widget + ?Sized> IdLike for WidgetRef<W> {
    type Widget = W;
    fn id(&self) -> WidgetId {
        self.id
    }
}

impl IdLike for WidgetId {
    type Widget = dyn Widget;
    fn id(&self) -> WidgetId {
        *self
    }
}

impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<WidgetHandle<U>> for WidgetHandle<T> {}
impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<WidgetRef<U>> for WidgetRef<T> {}

impl<W: ?Sized> Clone for WidgetRef<W> {
    fn clone(&self) -> Self {
        *self
    }
}
impl<W: ?Sized> Copy for WidgetRef<W> {}
impl<W: ?Sized> PartialEq for WidgetRef<W> {
    fn eq(&self, other: &Self) -> bool {
        self.id == other.id
    }
}

impl<W> PartialEq for WidgetHandle<W> {
    fn eq(&self, other: &Self) -> bool {
        self.id == other.id
    }
}

impl<W> std::fmt::Debug for WidgetHandle<W> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.id.fmt(f)
    }
}

impl<'a, W: Widget + 'a, State: HasUi> FnOnce<(&'a mut State,)> for WidgetRef<W> {
    type Output = &'a mut W;

    extern "rust-call" fn call_once(self, args: (&'a mut State,)) -> Self::Output {
        &mut args.0.ui_mut()[self]
    }
}