use parking_lot::{Once, OnceState};
use std::error::Error;
use std::fmt::{Debug, Display, Formatter};
use std::ops::{Deref, DerefMut};


static INITIALIZED: Once = Once::new();


pub fn initialize() {
    INITIALIZED.call_once(|| {
        crate::os::initialize();
    });
}

pub fn initialized() -> bool {
    INITIALIZED.state() != OnceState::New
}



// keep `x`, preventing llvm from optimizing it away as an unused variable.
pub fn keep<T>(x: T) -> T {
    unsafe { asm!["" : : "r"(&x)] }
    x
}



// asserts (at compile time) that some object is `Sync` or `Send`.
pub fn assert_send(_: impl Send) {
}
pub fn assert_sync(_: impl Sync) {
}
pub fn assert_send_sync(_: impl Send + Sync) {
}



// a trait that encompasses all types.
pub trait Any {}

impl<T> Any for T {
}



// an opaque error that be converted from any other error type.
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
pub struct BlackHole;

impl<T> Into<Result<T, BlackHole>> for BlackHole {
    fn into(self) -> Result<T, BlackHole> {
        Err(BlackHole)
    }
}

// we cannot (yet) `impl std::error::Error`, or we'd run into orphan rule conflicts. wait until impl specialization is
// available.
//
//     impl Error for BlackHole {
//         fn description(&self) -> &str {
//             d!["BlackHole"]
//         }
//
//         fn cause(&self) -> Option<&Error> {
//             None
//         }
//     }

impl Display for BlackHole {
    fn fmt(&self, formatter: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
        match cfg!(debug) {
            true => writeln!(formatter, "BlackHole"),
            false => Ok(()),
        }
    }
}

impl<T> From<T> for BlackHole
where
    T: Error,
{
    fn from(_: T) -> BlackHole {
        BlackHole
    }
}



// // an type that can be converted from `BlackHole` and implements `std::error::Error`.
// //
// // this type exists because `BlackHole` cannot implement `Error` (due to conflicting implementations of From<> in
// // libcore`.
// #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
// pub struct BlackHoleError;
//
// impl Display for BlackHoleError {
//     fn fmt(&self, _: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
//         Ok(())
//     }
// }
//
// impl Error for BlackHoleError {
//     fn description(&self) -> &str {
//         d!["BlackHoleError"]
//     }
//
//     fn cause(&self) -> Option<&Error> {
//         None
//     }
// }
//
// impl From<BlackHole> for BlackHoleError {
//     fn from(_: BlackHole) -> BlackHoleError {
//         BlackHoleError
//     }
// }



// // a struct that wraps another type and marks it as `Sync`.
// #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
// pub struct SyncSafe<T> {
//     pub value: T,
// }
//
// impl<T> SyncSafe<T> {
//     pub fn into(self) -> T {
//         self.value
//     }
// }
//
// unsafe impl<T> Sync for SyncSafe<T> {
// }
//
// impl<T> Deref for SyncSafe<T> {
//     type Target = T;
//
//     fn deref(&self) -> &T {
//         &self.value
//     }
// }
//
// impl<T> DerefMut for SyncSafe<T> {
//     fn deref_mut(&mut self) -> &mut T {
//         &mut self.value
//     }
// }



// a wrapper type that ensures its wrapped item implements debug.
pub struct DefaultDebug<T>(pub T);

impl<T> Debug for DefaultDebug<T> {
    default fn fmt(&self, formatter: &mut Formatter) -> Result<(), std::fmt::Error> {
        if cfg!(debug) {
            write!(formatter, "{}", unsafe { std::intrinsics::type_name::<T>() })
        } else {
            Ok(())
        }
    }
}

impl<T> Debug for DefaultDebug<T>
where
    T: Debug,
{
    fn fmt(&self, formatter: &mut Formatter) -> Result<(), std::fmt::Error> {
        self.0.fmt(formatter)
    }
}

impl<T> Deref for DefaultDebug<T> {
    type Target = T;

    fn deref(&self) -> &T {
        &self.0
    }
}

impl<T> DerefMut for DefaultDebug<T> {
    fn deref_mut(&mut self) -> &mut T {
        &mut self.0
    }
}



// returns a slice as an array, if `byte_length(array) == byte_length(slice)`. this function is unsafe because `T` may
// not be a blittable type.
pub unsafe fn slice_as_array<T, TArray>(data: &[T]) -> Option<&TArray>
where
    TArray: AsRef<[T]>,
{
    let a = std::mem::size_of::<TArray>();
    let b = std::mem::size_of::<T>() * data.len();

    match a == b {
        true => Some(&*(data.as_ptr() as *const TArray)),
        false => None,
    }
}



// convert a singular `T` into a single element slice of `T`.
pub fn as_slice<T>(item: &T) -> &[T] {
    // safe: the memory layout of a singular `T` is always the same as an array of one `T`.
    unsafe { std::slice::from_raw_parts(item, 1) }
}

// convert a singular `T` into a single element slice of `T`.
pub fn as_slice_mut<T>(item: &mut T) -> &mut [T] {
    // safe: the memory layout of a singular `T` is always the same as an array of one `T`.
    unsafe { std::slice::from_raw_parts_mut(item, 1) }
}

// convert an `Option<T>` into a zero or single element slice of `T`.
pub fn option_as_slice<T>(value: &Option<T>) -> &[T] {
    match value {
        Some(x) => as_slice(x),
        None => &[],
    }
}

// convert an `Option<T>` into a zero or single element slice of `T`.
pub fn option_as_slice_mut<T>(value: &mut Option<T>) -> &mut [T] {
    match value {
        Some(x) => as_slice_mut(x),
        None => &mut [],
    }
}



// /// turns a generator into an `Iterator`.
// pub fn generate<TSource, TItem>(source: TSource) -> impl Iterator<Item = TItem>
//     where TSource: Generator<Return = (), Yield = TItem> {

//     return GeneratorObject { source, done: false };


//     struct GeneratorObject<TSource> {
//         done:   bool,
//         source: TSource,
//     }

//     impl<TSource> Iterator for GeneratorObject<TSource> where TSource: Generator<Return = ()> {
//         type Item = TSource::Yield;

//         fn next(&mut self) -> Option<TSource::Yield> {
//             if self.done {
//                 return None;
//             }

//             match unsafe { self.source.resume() } {
//                 GeneratorState::Yielded(x) => {
//                     Some(x)
//                 },
//                 GeneratorState::Complete(()) => {
//                     self.done = true;
//                     None
//                 }
//             }
//         }
//     }
// }



// a bitfield.
#[repr(C)]
#[derive(Debug, Copy, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct BitField<TStorage, TAlignment>
where
    TStorage: AsRef<[u8]> + AsMut<[u8]>,
{
    storage:   TStorage,
    alignment: [TAlignment; 0],
}

impl<TStorage, TAlignment> BitField<TStorage, TAlignment>
where
    TStorage: AsRef<[u8]> + AsMut<[u8]>,
{
    #[inline]
    pub fn new(storage: TStorage) -> Self {
        BitField { storage, alignment: [] }
    }

    #[inline]
    pub fn get(&self, index: usize) -> bool {
        let storage = self.storage.as_ref();

        debug_assert![storage.len() >= index / 8];

        let byte = storage[index / 8];
        let shift = if cfg!(target_endian = "little") {
            index % 8
        } else {
            7 - (index % 8)
        };
        let mask = 1 << shift;

        byte & mask != 0
    }

    #[inline]
    pub fn set(&mut self, index: usize, value: bool) {
        let storage = self.storage.as_mut();

        debug_assert![storage.len() >= index / 8];

        let byte = &mut storage[index / 8];
        let shift = if cfg!(target_endian = "little") {
            index % 8
        } else {
            7 - (index % 8)
        };
        let mask = 1 << shift;

        match value {
            true => *byte |= mask,
            false => *byte &= !mask,
        }
    }

    #[inline]
    pub fn get_value<T>(&self, offset: usize, width: usize) -> T
    where
        T: From<u64>,
    {
        let storage = self.storage.as_ref();

        debug_assert![width <= 64];
        debug_assert![storage.len() > (offset + width) / 8];

        let mut value = 0u64;

        for i in 0..width {
            if self.get(offset + i) {
                let shift = if cfg!(target_endian = "big") { width - i - 1 } else { i };

                value |= 1 << shift;
            }
        }

        value.into()
    }

    #[inline]
    pub fn set_value<T>(&mut self, offset: usize, width: usize, value: T)
    where
        T: Into<u64>,
    {
        let storage = self.storage.as_ref();
        let value = Into::<u64>::into(value);

        debug_assert![width <= 64];
        debug_assert![storage.len() > (offset + width) / 8];

        for i in 0..width {
            let index = if cfg!(target_endian = "big") { width - i - 1 } else { i };
            let mask = 1 << i;

            self.set(index + offset, value & mask != 0);
        }
    }
}



// extensions to `std::vec::Vec`.
pub trait VecExt {
    /// clears this `vec<t>`. if `t` is copy, this method optimizes the clear by truncating the vec's length to zero,
    /// unlike `vec::<t>::clear()`.
    fn clear_vec(&mut self);
}

impl<T> VecExt for Vec<T> {
    default fn clear_vec(&mut self) {
        self.clear();
    }
}


impl<T> VecExt for Vec<T>
where
    T: Copy,
{
    fn clear_vec(&mut self) {
        // safe: `T` is copy.
        unsafe {
            self.set_len(0);
        }
    }
}



// extensions to `bool`.
pub trait BoolExt {
    fn as_option(&self) -> Option<()>;
}

impl BoolExt for bool {
    fn as_option(&self) -> Option<()> {
        match self {
            true => Some(()),
            false => None,
        }
    }
}