use crate::ffi::CStr;
use crate::io;
use crate::num::NonZeroUsize;
use crate::ptr;
use crate::sys::c;
use crate::sys::handle::Handle;
use crate::sys::stack_overflow;
use crate::time::Duration;

use libc::c_void;

use super::to_u16s;

pub const DEFAULT_MIN_STACK_SIZE: usize = 2 * 1024 * 1024;

pub struct Thread {
    handle: Handle,
}

impl Thread {
    // 不安全: 有关安全要求，请参见 thread::Builder::spawn_unchecked
    pub unsafe fn new(stack: usize, p: Box<dyn FnOnce()>) -> io::Result<Thread> {
        let p = Box::into_raw(box p);

        // FIXME 在 UNIX 上，我们会防止栈大小过小，但这是因为 pthread 强制栈的大小至少为 PTHREAD_STACK_MIN 个字节。
        // Windows 没有这样的下限，只是低于某个阈值您什么也做不了。
        // 但是，该阈值是特定于应用程序和体系结构的。
        // 舍入到下一个 64 kB，因为这是 NT 内核所做的，也可能使其明确。
        //
        //
        //
        let stack_size = (stack + 0xfffe) & (!0xfffe);
        let ret = c::CreateThread(
            ptr::null_mut(),
            stack_size,
            thread_start,
            p as *mut _,
            c::STACK_SIZE_PARAM_IS_A_RESERVATION,
            ptr::null_mut(),
        );

        return if ret as usize == 0 {
            // 线程无法启动，结果 p 没有被使用。
            // 因此，重建 box 使其被释放是安全的。
            drop(Box::from_raw(p));
            Err(io::Error::last_os_error())
        } else {
            Ok(Thread { handle: Handle::new(ret) })
        };

        extern "system" fn thread_start(main: *mut c_void) -> c::DWORD {
            unsafe {
                // 接下来，设置我们的栈溢出处理程序，如果我们用完栈，可能会触发该处理程序。
                //
                let _handler = stack_overflow::Handler::new();
                // 最后，让我们运行一些代码。
                Box::from_raw(main as *mut Box<dyn FnOnce()>)();
            }
            0
        }
    }

    pub fn set_name(name: &CStr) {
        if let Ok(utf8) = name.to_str() {
            if let Ok(utf16) = to_u16s(utf8) {
                unsafe {
                    c::SetThreadDescription(c::GetCurrentThread(), utf16.as_ptr());
                };
            };
        };
    }

    pub fn join(self) {
        let rc = unsafe { c::WaitForSingleObject(self.handle.raw(), c::INFINITE) };
        if rc == c::WAIT_FAILED {
            panic!("failed to join on thread: {}", io::Error::last_os_error());
        }
    }

    pub fn yield_now() {
        // 如果没有其他线程要执行，则此函数将返回 0，但这也意味着 yield 没用，因此实际上不必担心这种情况。
        //
        //
        unsafe {
            c::SwitchToThread();
        }
    }

    pub fn sleep(dur: Duration) {
        unsafe { c::Sleep(super::dur2timeout(dur)) }
    }

    pub fn handle(&self) -> &Handle {
        &self.handle
    }

    pub fn into_handle(self) -> Handle {
        self.handle
    }
}

pub fn available_concurrency() -> io::Result<NonZeroUsize> {
    let res = unsafe {
        let mut sysinfo: c::SYSTEM_INFO = crate::mem::zeroed();
        c::GetSystemInfo(&mut sysinfo);
        sysinfo.dwNumberOfProcessors as usize
    };
    match res {
        0 => Err(io::Error::new_const(
            io::ErrorKind::NotFound,
            &"The number of hardware threads is not known for the target platform",
        )),
        cpus => Ok(unsafe { NonZeroUsize::new_unchecked(cpus) }),
    }
}

#[cfg_attr(test, allow(dead_code))]
pub mod guard {
    pub type Guard = !;
    pub unsafe fn current() -> Option<Guard> {
        None
    }
    pub unsafe fn init() -> Option<Guard> {
        None
    }
}