use std::{
    future::Future,
    ptr::NonNull,
    task::{Poll, Waker},
};

use crate::task::{Cell, Harness, Header, Schedule};

pub(crate) struct RawTask {
    ptr: NonNull<Header>, // 非空指向 Header 的裸指针
}

impl Clone for RawTask {
    fn clone(&self) -> Self {
        *self // 实际上是个裸指针
    }
}

impl Copy for RawTask {}

// 函数表
pub(crate) struct Vtable {
    /// Poll the future
    pub(crate) poll: unsafe fn(NonNull<Header>),
    /// Deallocate the memory
    /// 释放内存
    pub(crate) dealloc: unsafe fn(NonNull<Header>),

    /// Read the task output, if complete
    /// 读取任务输出,如果完成
    pub(crate) try_read_output: unsafe fn(NonNull<Header>, *mut (), &Waker),

    /// The join handle has been dropped
    /// 缓慢的丢弃 join handle
    pub(crate) drop_join_handle_slow: unsafe fn(NonNull<Header>),

    /// Set future output
    #[cfg(feature = "sync")]
    pub(crate) finish: unsafe fn(NonNull<Header>, *mut ()),
}

/// Get the vtable for the requested `T` and `S` generics.
/// 生成 vtable (函数表)
pub(super) fn vtable<T: Future, S: Schedule>() -> &'static Vtable {
    &Vtable {
        poll: poll::<T, S>, // 调用 poll
        dealloc: dealloc::<T, S>, // 释放资源
        try_read_output: try_read_output::<T, S>, // 尝试读取输出
        drop_join_handle_slow: drop_join_handle_slow::<T, S>,
        #[cfg(feature = "sync")]
        finish: finish::<T, S>,
    }
}

impl RawTask {
    pub(crate) fn new<T, S>(owner_id: usize, task: T, scheduler: S) -> RawTask
    where
        T: Future,
        S: Schedule,
    {
        // 指向 new Cell 的裸指针
        let ptr = Box::into_raw(Cell::new(owner_id, task, scheduler));
        // 指向 Header 的裸指针 | Header 是 Cell 的第一个字段
        let ptr = unsafe { NonNull::new_unchecked(ptr as *mut Header) };

        RawTask { ptr }
    }
    // 由 Header 生成 RawTask
    pub(crate) unsafe fn from_raw(ptr: NonNull<Header>) -> RawTask {
        RawTask { ptr }
    }
    // 获取 header 字段的引用
    pub(crate) fn header(&self) -> &Header {
        unsafe { self.ptr.as_ref() }
    }

    /// Safety: mutual exclusion is required to call this function.
    /// 执行 函数表的 poll 函数
    pub(crate) fn poll(self) {
        let vtable: &Vtable = self.header().vtable;
        unsafe { (vtable.poll)(self.ptr) }
    }
    // 执行 函数表的 dealloc 函数 | 释放内存
    pub(crate) fn dealloc(self) {
        let vtable = self.header().vtable;
        unsafe {
            (vtable.dealloc)(self.ptr);
        }
    }

    /// Safety: `dst` must be a `*mut Poll<super::Result<T::Output>>` where `T`
    /// is the future stored by the task.
    /// 尝试读取任务输出, 必须确保 dst 是一个 `*mut Poll<super::Result<T::Output>>` 类型
    pub(crate) unsafe fn try_read_output(self, dst: *mut (), waker: &Waker) {
        let vtable = self.header().vtable;
        (vtable.try_read_output)(self.ptr, dst, waker);
    }
    // 缓慢的丢弃 join handle
    pub(crate) fn drop_join_handle_slow(self) {
        let vtable = self.header().vtable;
        unsafe { (vtable.drop_join_handle_slow)(self.ptr) }
    }

    #[cfg(feature = "sync")]
    pub(crate) unsafe fn finish(self, val_slot: *mut ()) {
        let vtable = self.header().vtable;
        unsafe { (vtable.finish)(self.ptr, val_slot) }
    }
}

// 指向 poll 函数, poll future
unsafe fn poll<T: Future, S: Schedule>(ptr: NonNull<Header>) {
    let harness = Harness::<T, S>::from_raw(ptr);
    harness.poll();
}
// 指向 dealloc 函数,释放内存
unsafe fn dealloc<T: Future, S: Schedule>(ptr: NonNull<Header>) {
    let harness: Harness<T, S> = Harness::<T, S>::from_raw(ptr);
    harness.dealloc();
}

#[cfg(feature = "sync")]
unsafe fn finish<T: Future, S: Schedule>(ptr: NonNull<Header>, val: *mut ()) {
    let harness = Harness::<T, S>::from_raw(ptr);
    let val = &mut *(val as *mut Option<<T as Future>::Output>);
    harness.finish(val.take().unwrap());
}
// 尝试读取输出
unsafe fn try_read_output<T: Future, S: Schedule>(
    ptr: NonNull<Header>,
    dst: *mut (),
    waker: &Waker,
) {
    let out = &mut *(dst as *mut Poll<T::Output>);

    let harness = Harness::<T, S>::from_raw(ptr);
    harness.try_read_output(out, waker);
}
// 缓慢丢弃 join handle
unsafe fn drop_join_handle_slow<T: Future, S: Schedule>(ptr: NonNull<Header>) {
    let harness = Harness::<T, S>::from_raw(ptr);
    harness.drop_join_handle_slow()
}