use core::convert::TryInto;
use core::ffi::c_void;
use core::slice::from_raw_parts;

use std::ffi::CString;
use std::os::raw::{c_uint, c_char};

use libretro_sys::{Message, PixelFormat, SystemAvInfo, GameGeometry};

use crate::libretro_convert::*;
use crate::libretro_loading::*;
use std::path::Path;
use num_enum::{IntoPrimitive, TryFromPrimitive};

static mut CB_SINGLETON: StaticCallbacks = StaticCallbacks {
    environment: None,
    video_refresh: None,
    audio_sample: None,
    audio_sample_batch: None,
    input_poll: None,
    input_state: None,
};

#[derive(Default)]
struct StaticCallbacks {
    environment: Option<&'static mut dyn HandlesEnvironment>,
    video_refresh: Option<&'static mut dyn HandlesVideoRefresh>,
    audio_sample: Option<&'static mut dyn HandlesAudioSample>,
    audio_sample_batch: Option<&'static mut dyn HandlesAudioSampleBatch>,
    input_poll: Option<&'static mut dyn HandlesInputPoll>,
    input_state: Option<&'static mut dyn HandlesInputState>,
}

unsafe impl Sync for StaticCallbacks {}

impl StaticCallbacks {
    // helpers for environ cb
    fn clone_into_void<T: Clone>(data: *mut c_void, source: &T) -> Option<bool> {
        unsafe { (data as *mut T).as_mut() }?.clone_from(source);
        Some(true)
    }
    fn string_into_void(data: *mut c_void, source: impl AsRef<str>) -> Option<bool> {
        *unsafe { (data as *mut *const c_char).as_mut()? } = CString::new(source.as_ref()).ok()?.into_raw();
        Some(true)
    }
    fn path_into_void(data: *mut c_void, source: impl AsRef<Path>) -> Option<bool> {
        Self::string_into_void(data, source.as_ref().to_string_lossy())
    }
    fn from_void<T>(data: *mut c_void) -> Option<&'static mut T> {
        unsafe { (data as *mut T).as_mut() }
    }
    fn enum_from_void<T>(data: *mut c_void) -> Option<T>
        where T: TryFromPrimitive, <T as TryFromPrimitive>::Primitive: 'static
    {
        let number = Self::from_void(data).cloned()?;
        T::try_from_primitive(number).ok()
    }
    fn environment_cb_inner(cmd: u32, data: *mut c_void) -> Option<bool> {
        let mut handler = unsafe { CB_SINGLETON.environment.as_mut() }?;
        match cmd.try_into().ok()? {
            EnvCmd::SetRotation => handler.set_rotation(Self::enum_from_void(data)?),
            EnvCmd::GetOverscan => Self::clone_into_void(data, &handler.get_overscan()?)?,
            EnvCmd::GetCanDupe => Self::clone_into_void(data, &handler.get_can_dupe()?)?,
            EnvCmd::SetMessage => handler.set_message(Self::from_void::<Message>(data)?.clone()),
            EnvCmd::Shutdown => handler.shutdown(),
            EnvCmd::SetPerformanceLevel => handler.set_performance_level(*Self::from_void(data)?),
            EnvCmd::GetSystemDirectory => Self::path_into_void(data, handler.get_system_directory()?)?,
            EnvCmd::SetPixelFormat => handler.set_pixel_format(PixelFormat::from_uint(*Self::from_void(data)?)?),
            // TODO EnvironmentCmdData::SetInputDescriptors => {},
            // TODO EnvironmentCmdData::SetKeyboardCallback => {},
            // TODO EnvironmentCmdData::SetDiskControlInterface => {},
            // TODO EnvironmentCmdData::SetHwRender => {},
            // TODO EnvironmentCmdData::GetVariable => {}, -- also change to mut parameter?
            // TODO EnvironmentCmdData::SetVariables => {},
            EnvCmd::GetVariableUpdate => Self::clone_into_void(data, &handler.get_variable_update()?)?,
            EnvCmd::SetSupportNoGame => handler.set_support_no_game(*Self::from_void(data)?),
            EnvCmd::GetLibretroPath => Self::path_into_void(data, handler.get_libretro_path()?)?,
            // TODO EnvironmentCmdData::SetFrameTimeCallback => {},
            // TODO EnvironmentCmdData::SetAudioCallback => {},
            // TODO EnvironmentCmdData::GetRumbleInterface => {},
            EnvCmd::GetInputDeviceCapabilities => Self::clone_into_void(data, &handler.get_input_device_capabilities()?)?,
            // TODO EnvironmentCmdData::GetSensorInterface => {},
            // TODO EnvironmentCmdData::GetCameraInterface => {},
            // TODO EnvironmentCmdData::GetLogInterface => {},
            // TODO EnvironmentCmdData::GetPerfInterface => {},
            // TODO EnvironmentCmdData::GetLocationInterface => {},
            EnvCmd::GetCoreAssetsDirectory => Self::path_into_void(data, handler.get_core_assets_directory()?)?,
            EnvCmd::GetSaveDirectory => Self::path_into_void(data, handler.get_save_directory()?)?,
            EnvCmd::SetSystemAvInfo => handler.set_system_av_info(Self::from_void::<SystemAvInfo>(data)?.clone()),
            // TODO EnvironmentCmdData::SetProcAddressCallback => {},
            // TODO EnvironmentCmdData::SetSubsystemInfo => {},
            // TODO EnvironmentCmdData::SetControllerInfo => {},
            // TODO EnvironmentCmdData::SetMemoryMaps => {},
            EnvCmd::SetGeometry => handler.set_geometry(Self::from_void::<GameGeometry>(data)?.clone()),
            EnvCmd::GetUsername => Self::string_into_void(data, handler.get_username()?)?,
            EnvCmd::GetLanguage => Self::clone_into_void(data, &handler.get_language()?)?,
            // EnvironmentCmdData::SetSerializationQuirks => handler.set_serialization_quirks(Self::from_void(data)?),
            _ => false,
        }.into()
    }
    extern "C" fn environment_cb(cmd: u32, data: *mut c_void) -> bool {
        Self::environment_cb_inner(cmd, data).unwrap_or(false)
    }

    extern "C" fn video_refresh_cb(
        data: *const c_void,
        width: c_uint,
        height: c_uint,
        pitch: usize,
    ) {
        if !data.is_null() {
            if let Some(cb) = unsafe { CB_SINGLETON.video_refresh.as_mut() } {
                let data = data as *const u8;
                let len = pitch * (height as usize);
                let slice = unsafe { from_raw_parts(data, len) };
                cb.video_refresh(slice, width, height, pitch as u32);
            }
        }
    }
    extern "C" fn audio_sample_cb(left: i16, right: i16) {
        if let Some(cb) = unsafe { CB_SINGLETON.audio_sample.as_mut() } {
            cb.audio_sample(left, right);
        }
    }
    extern "C" fn audio_sample_batch_cb(data: *const i16, frames: usize) -> usize {
        unsafe {
            match CB_SINGLETON.audio_sample_batch.as_mut() {
                Some(cb) => match data.is_null() {
                    true => 0,
                    false => cb.audio_sample_batch(from_raw_parts(data, frames)),
                },
                None => 0,
            }
        }
    }
    extern "C" fn input_poll_cb() {
        unsafe { CB_SINGLETON.input_poll.as_mut().map(|cb| cb.input_poll()) };
    }
    extern "C" fn input_state_cb(port: c_uint, device: c_uint, index: c_uint, id: c_uint) -> i16 {
        match unsafe { CB_SINGLETON.input_state.as_mut() } {
            Some(cb) => match ((device, id).try_into(), index.try_into()) {
                (Ok(input), Ok(index)) => cb.input_state(port, input, index),
                _ => 0,
            },
            None => 0,
        }
    }
    pub(crate) fn set_environment(cb: &'static mut dyn HandlesEnvironment) {
        unsafe {
            CB_SINGLETON.environment.replace(cb);
        }
    }
    pub(crate) fn set_video_refresh(cb: &'static mut dyn HandlesVideoRefresh) {
        unsafe {
            CB_SINGLETON.video_refresh.replace(cb);
        }
    }
    pub(crate) fn set_audio_sample(cb: &'static mut dyn HandlesAudioSample) {
        unsafe {
            CB_SINGLETON.audio_sample.replace(cb);
        }
    }
    pub(crate) fn set_audio_sample_batch(cb: &'static mut dyn HandlesAudioSampleBatch) {
        unsafe {
            CB_SINGLETON.audio_sample_batch.replace(cb);
        }
    }
    pub(crate) fn set_input_poll(cb: &'static mut dyn HandlesInputPoll) {
        unsafe {
            CB_SINGLETON.input_poll.replace(cb);
        }
    }
    pub(crate) fn set_input_state(cb: &'static mut dyn HandlesInputState) {
        unsafe {
            CB_SINGLETON.input_state.replace(cb);
        }
    }
    pub(crate) fn reset() {
        unsafe {
            CB_SINGLETON.environment.take();
            CB_SINGLETON.video_refresh.take();
            CB_SINGLETON.audio_sample.take();
            CB_SINGLETON.audio_sample_batch.take();
            CB_SINGLETON.input_poll.take();
            CB_SINGLETON.input_state.take();
        }
    }
}

pub struct LibretroWrapper<'a> {
    api: LibretroApi<'a>,
}

impl<'a> From<LibretroApi<'a>> for LibretroWrapper<'a> {
    fn from(api: LibretroApi<'a>) -> Self {
        api.set_environment(StaticCallbacks::environment_cb);
        api.set_video_refresh(StaticCallbacks::video_refresh_cb);
        api.set_audio_sample(StaticCallbacks::audio_sample_cb);
        api.set_audio_sample_batch(StaticCallbacks::audio_sample_batch_cb);
        api.set_input_poll(StaticCallbacks::input_poll_cb);
        api.set_input_state(StaticCallbacks::input_state_cb);
        LibretroWrapper { api }
    }
}

impl<'a> AsRef<LibretroApi<'a>> for LibretroWrapper<'a> {
    fn as_ref(&self) -> &LibretroApi<'a> {
        &self.api
    }
}

impl<'a> Drop for LibretroWrapper<'a> {
    fn drop(&mut self) {
        StaticCallbacks::reset();
    }
}

// a note on lifetimes: we explicitly lie about them here because as long as they live as long as
//  the library wrapper itself we're good (we wipe our 'static references on drop() too)
impl<'a> LibretroWrapper<'a> {
    pub fn register_environment_handler(&self, handler: &'a mut dyn HandlesEnvironment) {
        let ptr: *mut dyn HandlesEnvironment = handler;
        StaticCallbacks::set_environment(unsafe { ptr.as_mut() }.unwrap());
    }
    pub fn register_video_refresh_handler(&self, handler: &'a mut dyn HandlesVideoRefresh) {
        let ptr: *mut dyn HandlesVideoRefresh = handler;
        StaticCallbacks::set_video_refresh(unsafe { ptr.as_mut() }.unwrap());
    }
    pub fn register_audio_sample_handler(&self, handler: &'a mut dyn HandlesAudioSample) {
        let ptr: *mut dyn HandlesAudioSample = handler;
        StaticCallbacks::set_audio_sample(unsafe { ptr.as_mut() }.unwrap());
    }
    pub fn register_audio_sample_batch_handler(
        &self,
        handler: &'a mut dyn HandlesAudioSampleBatch,
    ) {
        let ptr: *mut dyn HandlesAudioSampleBatch = handler;
        StaticCallbacks::set_audio_sample_batch(unsafe { ptr.as_mut() }.unwrap());
    }
    pub fn register_input_poll_handler(&self, handler: &'a mut dyn HandlesInputPoll) {
        let ptr: *mut dyn HandlesInputPoll = handler;
        StaticCallbacks::set_input_poll(unsafe { ptr.as_mut() }.unwrap());
    }
    pub fn register_input_state_handler(&self, handler: &'a mut dyn HandlesInputState) {
        let ptr: *mut dyn HandlesInputState = handler;
        StaticCallbacks::set_input_state(unsafe { ptr.as_mut() }.unwrap());
    }
    pub fn register_for_all<T>(&self, handler: &'a mut T)
    where
        T: HandlesEnvironment
            + HandlesVideoRefresh
            + HandlesAudioSample
            + HandlesAudioSampleBatch
            + HandlesInputPoll
            + HandlesInputState,
    {
        self.register_environment_handler(handler);
        self.register_video_refresh_handler(handler);
        self.register_audio_sample_handler(handler);
        self.register_audio_sample_batch_handler(handler);
        self.register_input_poll_handler(handler);
        self.register_input_state_handler(handler);
    }
}