//! `GHOST_Types.h`
use super::*;
use libc::{
    c_int,
};
use std::{
    marker::{
	PhantomData,
    },
};

/// Trait for opaque types that represent GHOST handles.
///
/// API maps to `GHOST_DECLARE_HANDLE`, and ABI maps exactly for `Handle<T>` where `T` is an implementor of this.
///
/// See [`handle`](../handle/index.html) for implementors.
pub trait GhostHandle: private::Sealed{}

/// Opaque handle type for GHOST C++ object pointers.
///
/// These have the same ABI as structs defined with `GHOST_DECLARE_HANDLE`, but it is irrelevant as its use is just for typing pointers. This field should not be instantiated itself, but instead passed as `&Handle<T>` or `&mut Handle<T>` to provide safe interfaces for these C APIs.
///
/// The following is safe:
/// ```
/// # use ghost::{error::GhostResult, c::*, handle::*};
/// extern "C" {fn some_internal_call(window: GHOST_WindowHandle) -> GHOST_TSuccess;}
///
/// fn do_something_to_window(window: &mut Handle<Window>) -> GhostResult
/// {
///    unsafe {
///       some_internal_call(window as GHOST_WindowHandle).into() // `GHOST_WindowHandle` is an alias for `*mut Handle<Window>`
///    }
/// }
/// ```
#[repr(C)]
#[derive(Debug)]
pub struct Handle<T>(c_int, PhantomData<T>)
where T: GhostHandle;

pub type GHOST_TInt8 = libc::c_char;
pub type GHOST_TUns8 = libc::c_uchar;
pub type GHOST_TUns16 = libc::c_ushort;
pub type GHOST_TInt32 = libc::c_int;
pub type GHOST_TUns32 = libc::c_uint;
// -- skip MSVC specific shit. I'm not testing on that
pub type GHOST_TInt64 = libc::c_longlong;
pub type GHOST_TUns64 = libc::c_ulonglong;
pub type GHOST_TUserDataPtr = PVoidMut;

#[repr(C)]
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub struct GHOST_GLSettings
{
    pub flags: GHOST_GLFlags,
}

/// dumb hack for bitflags 
macro_rules! enum_flags {
    ($name:ident {
	$($const_name:ident = $value:expr,)*
    }) => {
	
	#[repr(transparent)]  //this seems dodgy to me
	#[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd, Default, Copy)] //this has to be copy for the assignments to be ergonomic :/
	pub struct $name(libc::c_int);

	impl $name {
	    $(
		#[allow(non_upper_case_globals)] pub const $const_name: $name = $name($value);
	    )*

	    
	    pub const fn from_int(int: libc::c_int) -> Self
	    {
		Self(int)
	    }
	    pub const fn as_int(self) -> libc::c_int
	    {
		self.0
	    }

	    pub const fn has(self, other: Self) -> bool
	    {
		(self.0 & other.0) == other.0
	    }

	    pub const fn add(self, other: Self) -> Self
	    {
		Self(self.0 | other.0)
	    }

	    pub const fn remove(self, other: Self) -> Self
	    {
		Self((self.0 | other.0) ^ other.0)
	    }
	}

	impl From<libc::c_int> for $name
	{
	    #[inline] fn from(from: libc::c_int) -> Self
	    {
		Self(from)
	    }
	}

	impl From<$name> for libc::c_int
	{
	    #[inline] fn from(from: $name) -> Self
	    {
		from.0
	    }
	}
	

	impl ::std::ops::BitAnd for $name
	{
	    type Output = Self;
	    #[inline] fn bitand(self, rhs: Self) -> Self {
		Self(rhs.0 & self.0)
	    }
	}
	
	impl ::std::ops::BitOr for $name
	{
	    type Output = Self;
	    #[inline] fn bitor(self, rhs: Self) -> Self {
		Self(rhs.0 | self.0)
	    }
	}
	
	impl ::std::ops::BitXor for $name
	{
	    type Output = Self;
	    #[inline] fn bitxor(self, rhs: Self) -> Self {
		Self(rhs.0 ^ self.0)
	    }
	}
	
	impl ::std::ops::Not for $name
	{
	    type Output = Self;
	    #[inline] fn not(self,) -> Self {
		Self(!self.0)
	    }
	}
	
        impl ::std::ops::BitAndAssign for $name {
            #[inline] fn bitand_assign(&mut self, rhs: Self) { self.0 &= rhs.0; }
        }
        impl ::std::ops::BitOrAssign for $name {
            #[inline] fn bitor_assign(&mut self, rhs: Self) { self.0 |= rhs.0; }
        }
        impl ::std::ops::BitXorAssign for $name{
            #[inline] fn bitxor_assign(&mut self, rhs: Self) { self.0 ^= rhs.0; }
        }
    };
}

enum_flags!(GHOST_GLFlags {
    StereoVisual = 1<<0,
    DebugContext = 1<<1,
    AlphaBackground = 1<<2,
});

enum_flags!(GHOST_DialogOptions
	    {
		DialogWarning = 1<<0,
		DialogError = 1<<1,
	    });

/// Value returned by some GHOST functions to indicate a success or failure.
///
/// For mapping this behaviour onto Rust, see ['GhostResult`](./error/type.GhostResult.html).
#[repr(C)]
#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
pub enum GHOST_TSuccess
{
    Failure = 0,
    Success,
}

#[repr(C)]
#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
pub enum GHOST_TTabletMode
{
    None = 0,
    Stylus,
    Eraser,
}

impl Default for GHOST_TTabletMode
{
    #[inline]
    fn default() -> Self
    {
	Self::None
    }
}


#[repr(C)]
#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
pub enum GHOST_TTabletAPI
{
    None = 0,
    Native,
    Wintab,
}

impl Default for GHOST_TTabletAPI
{
    #[inline]
    fn default() -> Self
    {
	Self::None
    }
}


#[repr(C)]
#[derive(Debug, Clone, PartialEq)]
pub struct GHOST_TabletData
{
    pub active: GHOST_TTabletMode,
    pub pressure: f32,
    pub xtilt: f32,
    pub ytilt: f32,
}

impl GHOST_TabletData
{
    /// We use `const fn` initialiser here instead of `GHOST_TABLET_DATA_NONE` constant.
    pub const fn none() -> Self{
	Self{active: GHOST_TTabletMode::None, pressure: 1.0, xtilt: 0.0, ytilt: 0.0}
    }
}

impl Default for GHOST_TabletData
{
    #[inline]  fn default() -> Self
    {
	Self::none()
    }
}

#[repr(C)]
#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
pub enum GHOST_TVisibility
{
    Not =0,
    Partially,
    Fully,
}

impl Default for GHOST_TVisibility
{
    #[inline]
    fn default() -> Self
    {
	Self::Not
    }
}

#[repr(C)]
#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Copy)]
pub enum GHOST_TFireTimeConstant
{
    Never = 0xFFFFFFFF,
}

impl Default for GHOST_TFireTimeConstant
{
    #[inline]
    fn default() -> Self
    {
	Self::Never
    }
}

#[repr(C)]
#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
pub enum GHOST_TModifierKeyMask {
    LeftShift = 0,
    RightShift,
    LeftAlt,
    RightAlt,
    LeftControl,
    RightControl,
    OS,
    NumMasks
}

#[repr(C)]
#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
pub enum GHOST_TWindowState {
    Normal = 0,
    Maximized,
    Minimized,
    FullScreen,
    Embedded,
    // Modified,
    // UnModified,
}

#[repr(C)]
#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
pub enum GHOST_TWindowOrder
{
    Top =0,
    Bottom,
}

#[repr(C)]
#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
pub enum GHOST_TDrawingContextType {
    None = 0,
    OpenGL,
    //D3D, //lol nope
}

#[repr(C)]
#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
pub enum GHOST_TButtonMask{
    Left = 0,
    Middle,
    Right,
    Button4,
    Button5,
    /* Trackballs and programmable buttons */
    Button6,
    Button7,
    NumMasks // Should we even keep this? I guess yeah for ABI compatability
}

#[repr(C)]
#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
pub enum GHOST_TEventType {
    Unknown = 0,

    CursorMove, 
    ButtonDown,  
    ButtonUp,    
    Wheel,       
    Trackpad,    

    //#ifdef WITH_INPUT_NDOF
    //  NDOFMotion,  /// N degree of freedom device motion event
    //  NDOFButton,  /// N degree of freedom device button event
    //#endif

    KeyDown,
    KeyUp,
    //  KeyAuto,

    QuitRequest,

    WindowClose,
    WindowActivate,
    WindowDeactivate,
    WindowUpdate,
    WindowSize,
    WindowMove,
    WindowDPIHintChanged,

    DraggingEntered,
    DraggingUpdated,
    DraggingExited,
    DraggingDropDone,

    OpenMainFile,  // Needed for Cocoa to open double-clicked .blend file at startup
    NativeResolutionChange,  // Needed for Cocoa when window moves to other display

    Timer,

    ImeCompositionStart,
    ImeComposition,
    ImeCompositionEnd,

    NumEventTypes
}

/**
 * Definition of a callback routine that receives events.
 * *  The event received.
 * *  The callback's user data, supplied to GHOST_CreateSystem.
 */
pub type GHOST_EventCallbackProcPtr = Option<fn(handle::GHOST_EventHandle, GHOST_TUserDataPtr) -> libc::c_int>;