use gl::types::*;
use std::marker::PhantomData;
use std::cell::RefCell;
use std::rc::Rc;
use ::Result;
use super::traits::*;
use super::storage::BufferStorage;
use super::map::*;
use super::range::Range;
use std::ops::Range as StdRange;
use std::mem;
use std::marker;
use std::slice;

/// Wrapper around a BufferStorage with internal reference counting
///
/// Useful for example when the same buffer or ranges of the same buffer are to be used in
/// different VAOs
#[cfg(all(not(feature = "gles"), not(feature="webgl")))]
#[derive(Debug, Eq, PartialEq)]
pub struct SharedBufferStorage<T>{
    buffer: Rc<RefCell<BufferStorage<u8>>>,
    marker: marker::PhantomData<T>,
}

impl<T> Clone for SharedBufferStorage<T>{
    fn clone(&self) -> SharedBufferStorage<T>{
        SharedBufferStorage{
            buffer: self.buffer.clone(),
            marker: marker::PhantomData,
        }
    }
}

#[cfg(all(not(feature = "gles"), not(feature="webgl")))]
impl<T: 'static> SharedBufferStorage<T>{
    // pub fn bind(&self, target: GLenum){
	// 	self.buffer.borrow().bind(target)
    // }

    // pub fn unbind(&self, target: GLenum){
	// 	self.buffer.borrow().unbind(target)
    // }

    // pub fn bind_base(&self, target: GLenum, index: GLuint){
	// 	self.buffer.borrow().bind_base(target, index)
    // }

    // pub fn unbind_base(&self, target: GLenum, index: GLuint){
	// 	self.buffer.borrow().unbind_base(target, index)
    // }

    fn to_u8(data: &[T]) -> &[u8]{
        let bytes = data.len() * mem::size_of::<T>();
        unsafe{ slice::from_raw_parts(data.as_ptr() as *const u8, bytes) }
    }

    // fn to_u8_mut(data: &mut [T]) -> &mut [u8]{
    //     let bytes = data.len() * mem::size_of::<T>();
    //     unsafe{ slice::from_raw_parts_mut(data.as_mut_ptr() as *mut u8, bytes) }
    // }

    fn to_t(data: &[u8]) -> &[T]{
        let len = data.len() / mem::size_of::<T>();
        unsafe{ slice::from_raw_parts(data.as_ptr() as *const T, len) }
    }

    fn to_t_mut(data: &mut [u8]) -> &mut [T]{
        let len = data.len() / mem::size_of::<T>();
        unsafe{ slice::from_raw_parts_mut(data.as_mut_ptr() as *mut T, len) }
    }

    pub fn update(&mut self, data: &[T]){
        (*self.buffer).borrow_mut().update(Self::to_u8(data));
    }

    #[cfg(all(not(feature = "gles"), not(feature="webgl")))]
    pub fn with_map_read<F: FnMut(&[T])>(&self, flags: MapReadFlags, mut f: F) -> Result<()>{
        (*self.buffer).borrow_mut().with_map_read(flags, |u8_data| f(Self::to_t(u8_data)))
    }

    #[cfg(all(not(feature = "gles"), not(feature="webgl")))]
    pub unsafe fn map_write<F: FnMut(&mut [T])>(&mut self, flags: MapWriteFlags, mut f: F) -> Result<()>{
        (*self.buffer).borrow_mut()
            .map_write(flags)
            .map(|mut m| f(Self::to_t_mut(m.data_mut())))
    }

    #[cfg(all(not(feature = "gles"), not(feature="webgl")))]
    pub fn map_read_write<F: FnMut(&mut [T])>(&mut self, flags: MapReadWriteFlags, mut f: F) -> Result<()>{
        (*self.buffer).borrow_mut()
            .map_read_write(flags)
            .map(|mut m| f(Self::to_t_mut(m.data_mut())))
    }

    pub fn copy_to<U,B:BufferRange<U> + WithBackendMut>(&self, dst: &mut B){
        (*self.buffer).borrow().copy_to(dst);
    }

    pub fn len(&self) -> usize{
        (*self.buffer).borrow().bytes() / self.stride()
    }

    pub fn is_empty(&self) -> bool{
        (*self.buffer).borrow().is_empty()
    }

    pub fn capacity(&self) -> usize{
        (*self.buffer).borrow().capacity_bytes() / self.stride()
    }

    pub fn bytes(&self) -> usize{
        (*self.buffer).borrow().bytes()
    }

    pub fn capacity_bytes(&self) -> usize{
        (*self.buffer).borrow().capacity_bytes()
    }

    pub fn id(&self) -> GLuint{
        (*self.buffer).borrow().id()
    }

    pub fn stride(&self) -> usize{
        mem::size_of::<T>()
    }

    pub fn range<R: InputRange>(&self, range: R) -> Range<T, SharedBufferStorage<T>, SharedBufferStorage<T>>{
        Range{
            buffer: self.clone(),
            range: range.to_range(self),
            marker_type: PhantomData,
            marker_buffer: PhantomData,
        }
    }

    /// Get a mutable range from the buffer
    ///
    /// Useful to do operations on portions of the buffer
    ///
    /// Panics if the range is out of bounds
    pub fn range_mut<R: InputRange>(&mut self, range: R) -> Range<T, SharedBufferStorage<T>, SharedBufferStorage<T>>{
        Range{
            buffer: self.clone(),
            range: range.to_range(self),
            marker_type: PhantomData,
            marker_buffer: PhantomData,
        }
    }

    /// On creation the storage was passed the GL_MAP_PERSISTENT_BIT
    ///
    /// The client may request that the server read from or write to the buffer
    /// while it is mapped. The client's pointer to the data store remains valid
    /// so long as the data store is mapped, even during execution of drawing or
    /// dispatch commands.
    ///
    /// If the storage is not persistent, calls to persistent_map_* will fail
    pub fn is_persistant(&self) -> bool {
        (*self.buffer).borrow().is_persistant()
    }

    /// On creation the storage was passed the GL_MAP_READ_BIT
    ///
    /// The data store may be mapped by the client for read access and a pointer
    /// in the client's address space obtained that may be read from.
    ///
    /// If the storage is not read map, calls to any read map will fail
    pub fn is_read_map(&self) -> bool {
        (*self.buffer).borrow().is_read_map()
    }

    /// On creation the storage was passed the GL_MAP_WRITE_BIT
    ///
    /// The data store may be mapped by the client for write access and a pointer
    /// in the client's address space obtained that may be written through.
    ///
    /// If the storage is not read write, calls to any write map will fail
    pub fn is_write_map(&self) -> bool {
        (*self.buffer).borrow().is_write_map()
    }

    /// On creation the storage was passed the GL_DYNAMIC_STORAGE_BIT
    ///
    /// The contents of the data store may be updated after creation through calls to
    /// update (glSubBufferData). If this bit is not set, the buffer content may not be
    /// directly updated by the client. The data argument may be used to specify the initial
    /// content of the buffer's data store regardless of the presence of the GL_DYNAMIC_STORAGE_BIT.
    /// Regardless of the presence of this bit, buffers may always be updated with
    /// server-side calls such as copy (glCopyBufferSubData) and clear (glClearBufferSubData).
    pub fn is_dynamic_storage(&self) -> bool {
        (*self.buffer).borrow().is_dynamic_storage()
    }

    /// On creation the storage was passed the gL_MAP_COHERENT_BIT
    ///
    /// Shared access to buffers that are simultaneously mapped for client access
    /// and are used by the server will be coherent, so long as that mapping is performed using
    /// glMapBufferRange. That is, data written to the store by either the client or server
    /// will be immediately visible to the other with no further action taken by the application.
    /// In particular,
    ///
    /// - If GL_MAP_COHERENT_BIT is not set and the client performs a write followed by a call
    /// to the glMemoryBarrier command with the GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT set, then
    /// in subsequent commands the server will see the writes.
    ///
    /// - If GL_MAP_COHERENT_BIT is set and the client performs a write, then in subsequent
    /// commands the server will see the writes.
    ///
    /// - If GL_MAP_COHERENT_BIT is not set and the server performs a write, the application
    /// must call glMemoryBarrier with the GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT set and then
    /// call glFenceSync with GL_SYNC_GPU_COMMANDS_COMPLETE (or glFinish). Then the CPU will
    /// see the writes after the sync is complete.
    ///
    /// - If GL_MAP_COHERENT_BIT is set and the server does a write, the app must call FenceSync
    /// with GL_SYNC_GPU_COMMANDS_COMPLETE (or glFinish). Then the CPU will see the writes
    /// after the sync is complete.
    pub fn is_coherent(&self) -> bool {
        (*self.buffer).borrow().is_coherent()
    }

    /// Persistently maps a buffer object's data store
    ///
    /// If the storage wasn't created as pesistent this call will fail
    ///
    /// Persistent maps can be send and shared with other threads but need to be dropped from
    /// the same thread they were created from. The destructor will panic otherwise.
    ///
    /// A common pattern to do this is to return the map as the return value of a thread and
    /// receive it by explicitly joining the thread using it's join handle from the original thread.
    ///
    /// see glMapBuffer with GL_MAP_PERSISTENT_BIT
    pub fn map_persistent_read(&self, flags: MapReadFlags) -> Result<MapPersistentRead<T, &Self>>{
        unsafe{
            (*self.buffer).borrow().unsafe_map_range_persistent_read(None, flags)
                .map(|map| MapPersistentRead::new(
                    Self::to_t(map),
                    self
                ))
        }
    }

    pub fn into_map_persistent_read(self, flags: MapReadFlags) -> Result<MapPersistentRead<T, Self>>{
        unsafe{
            (*self.buffer).borrow().unsafe_map_range_persistent_read(None, flags)
                .map(|map| MapPersistentRead::new(
                    Self::to_t(map),
                    self.clone()
                ))
        }
    }

    /// Persistently maps a buffer object's data store
    ///
    /// If the storage wasn't created as pesistent this call will fail
    ///
    /// Persistent maps can be send and shared with other threads but need to be dropped from
    /// the same thread they were created from. The destructor will panic otherwise.
    ///
    /// A common pattern to do this is to return the map as the return value of a thread and
    /// receive it by explicitly joining the thread using it's join handle from the original thread.
    ///
    /// see glMapBuffer with GL_MAP_PERSISTENT_BIT
    pub fn map_persistent_write(&self, flags: MapWriteFlags) -> Result<MapPersistentWrite<T, &Self>>{
        unsafe{
            (*self.buffer).borrow_mut().unsafe_map_range_persistent_write(None, flags)
                .map(|map| MapPersistentWrite::new(
                    Self::to_t_mut(map),
                    self))
        }
    }

    pub fn into_map_persistent_write(self, flags: MapWriteFlags) -> Result<MapPersistentWrite<T, Self>>{
        unsafe{
            (*self.buffer).borrow_mut().unsafe_map_range_persistent_write(None, flags)
                .map(|map| MapPersistentWrite::new(
                    Self::to_t_mut(map),
                    self.clone()))
        }
    }

    /// Persistently maps a buffer object's data store
    ///
    /// If the storage wasn't created as pesistent this call will fail
    ///
    /// Persistent maps can be send and shared with other threads but need to be dropped from
    /// the same thread they were created from. The destructor will panic otherwise.
    ///
    /// A common pattern to do this is to return the map as the return value of a thread and
    /// receive it by explicitly joining the thread using it's join handle from the original thread.
    ///
    /// see glMapBuffer with GL_MAP_PERSISTENT_BIT
    pub fn map_persistent_read_write(&self, flags: MapReadWriteFlags) -> Result<MapPersistentReadWrite<T, &Self>>{
        unsafe{
            (*self.buffer).borrow_mut().unsafe_map_range_persistent_read_write(None, flags)
                .map(|map| MapPersistentReadWrite::new(
                    Self::to_t_mut(map),
                    self
                ))
        }
    }

    pub fn into_map_persistent_read_write(self, flags: MapReadWriteFlags) -> Result<MapPersistentReadWrite<T, Self>>{
        unsafe{
            (*self.buffer).borrow_mut().unsafe_map_range_persistent_read_write(None, flags)
                .map(|map| MapPersistentReadWrite::new(
                    Self::to_t_mut(map),
                    self.clone()
                ))
        }
    }
}

impl SharedBufferStorage<u8>{
    pub fn cast<T>(self) -> SharedBufferStorage<T>{
        SharedBufferStorage{
            buffer: self.buffer,
            marker: marker::PhantomData,
        }
    }
}

impl<T: 'static> Cast<T> for SharedBufferStorage<u8>{
    type CastTo = SharedBufferStorage<T>;
    fn cast(self) -> SharedBufferStorage<T>{
        SharedBufferStorage{
            buffer: self.buffer,
            marker: marker::PhantomData,
        }
    }
}

#[cfg(all(not(feature = "gles"), not(feature="webgl")))]
impl<T: 'static> TypedBuffer<T> for SharedBufferStorage<T>{
    fn id(&self) -> GLuint{
        (*self).id()
    }

    fn len(&self) -> usize{
        (*self).len()
    }

    fn capacity(&self) -> usize{
        (*self).capacity()
    }

    fn with_map_read<F: FnMut(&[T])>(&self, flags: MapReadFlags, f: F) -> Result<()>{
        (*self).with_map_read(flags, f)
    }

    fn copy_to<U,B:BufferRange<U> + WithBackendMut>(&self, dst: &mut B){
        (*self).copy_to(dst)
    }

    #[cfg(not(feature="webgl"))]
    unsafe fn unmap(&self){
        self.buffer.borrow().unmap()
    }
}


#[cfg(all(not(feature = "gles"), not(feature="webgl")))]
impl<T: 'static> TypedBuffer<T> for &SharedBufferStorage<T>{
    fn id(&self) -> GLuint{
        (*self).id()
    }

    fn len(&self) -> usize{
        (*self).len()
    }

    fn capacity(&self) -> usize{
        (*self).capacity()
    }

    fn with_map_read<F: FnMut(&[T])>(&self, flags: MapReadFlags, f: F) -> Result<()>{
        (*self).with_map_read(flags, f)
    }

    fn copy_to<U,B:BufferRange<U> + WithBackendMut>(&self, dst: &mut B){
        (*self).copy_to(dst)
    }

    #[cfg(not(feature="webgl"))]
    unsafe fn unmap(&self){
        self.buffer.borrow().unmap()
    }
}

#[cfg(all(not(feature = "gles"), not(feature="webgl")))]
impl<'a, T: 'static> TypedBufferMut<T> for SharedBufferStorage<T> {
    #[cfg(all(not(feature = "gles"), not(feature="webgl")))]
    unsafe fn with_map_write<F: FnMut(&mut [T])>(&mut self, flags: MapWriteFlags, f: F) -> Result<()>{
        (*self).map_write(flags, f)
    }

    #[cfg(all(not(feature = "gles"), not(feature="webgl")))]
    fn with_map_read_write<F: FnMut(&mut [T])>(&mut self, flags: MapReadWriteFlags, f: F) -> Result<()>{
        (*self).map_read_write(flags, f)
    }
}

#[cfg(all(not(feature = "gles"), not(feature="webgl")))]
impl<T: 'static> BufferRange<T> for SharedBufferStorage<T>{
    fn start(&self) -> usize{
        0
    }

    fn end(&self) -> usize{
        self.len()
    }

    fn into_range<R: InputRange>(self, range: R) -> super::Range<T, Self, Self> where Self: Sized{
        Range{
            range: range.to_range(&self),
            buffer: self,
            marker_type: PhantomData,
            marker_buffer: PhantomData,
        }
    }
}

#[cfg(all(not(feature = "gles"), not(feature="webgl")))]
impl<T: 'static> BufferRange<T> for &SharedBufferStorage<T>{
    fn start(&self) -> usize{
        0
    }

    fn end(&self) -> usize{
        (*self).len()
    }

    fn into_range<R: InputRange>(self, range: R) -> super::Range<T, Self, Self> where Self: Sized{
        Range{
            range: range.to_range(&self),
            buffer: self,
            marker_type: PhantomData,
            marker_buffer: PhantomData,
        }
    }
}

#[cfg(all(not(feature = "gles"), not(feature="webgl")))]
impl<T:'static> BufferRangeMut<T> for SharedBufferStorage<T>{
    fn update(&mut self, data: &[T]){
        self.update(data);
    }
}

#[cfg(all(not(feature = "gles"), not(feature="webgl")))]
impl<T> WithBackend for SharedBufferStorage<T>{
    fn with_backend<F:FnMut(&dyn Backend)->R, R>(&self, f:F) -> R{
        (*self.buffer).borrow().with_backend(f)
    }
}

#[cfg(all(not(feature = "gles"), not(feature="webgl")))]
impl<T> WithBackendMut for SharedBufferStorage<T>{
    fn with_backend_mut<F:FnMut(&mut dyn Backend)->R, R>(&mut self, f:F) -> R{
        (*self.buffer).borrow_mut().with_backend_mut(f)
    }
}


#[cfg(all(not(feature = "gles"), not(feature="webgl")))]
impl<T: 'static> WithMapRange<T> for SharedBufferStorage<T>{
    fn with_map_range_read<F: FnMut(&[T])>(&self, offset: usize, length: usize, flags: MapReadFlags, mut f: F) -> Result<()>{
        (*self.buffer)
            .borrow()
            .with_map_range_read(offset, length, flags, |u8_data| f(Self::to_t(u8_data)))
    }
}


#[cfg(all(not(feature = "gles"), not(feature="webgl")))]
impl<T: 'static> WithMapRangeMut<T> for SharedBufferStorage<T>{
    unsafe fn with_map_range_write<F: FnMut(&mut [T])>(&mut self, offset: usize, length: usize, flags: MapWriteFlags, mut f: F) -> Result<()>{
        (*self.buffer)
            .borrow_mut()
            .with_map_range_write(offset, length, flags, |u8_data| f(Self::to_t_mut(u8_data)))
    }

    fn with_map_range_read_write<F: FnMut(&mut [T])>(&mut self, offset: usize, length: usize, flags: MapReadWriteFlags, mut f: F) -> Result<()>{
        (*self.buffer)
            .borrow_mut()
            .with_map_range_read_write(offset, length, flags, |u8_data| f(Self::to_t_mut(u8_data)))
    }
}

impl<T: 'static> From<BufferStorage<T>> for SharedBufferStorage<T>{
    fn from(buffer: BufferStorage<T>) -> SharedBufferStorage<T>{
        let buffer = BufferStorage{
            len: buffer.bytes(),
            reserved: buffer.capacity_bytes(),
            backend: buffer.backend,
            marker: marker::PhantomData,
            creation_flags: buffer.creation_flags,
            persistent_map_token: buffer.persistent_map_token,
        };
        SharedBufferStorage{
            buffer: Rc::new(RefCell::new(buffer)),
            marker: marker::PhantomData,
        }
    }
}

#[cfg(all(not(feature = "gles"), not(feature="webgl")))]
impl<T: 'static> MapPersistentRange<T> for SharedBufferStorage<T>{
    unsafe fn unsafe_map_range_persistent_read(&self, range: Option<StdRange<usize>>, flags: MapReadFlags) -> Result<&'static [T]>{
        (*self.buffer).borrow()
            .unsafe_map_range_persistent_read(range, flags)
            .map(|data| Self::to_t(data))
    }

    fn map_range_persistent_read(&self, offset: usize, length: usize, flags: MapReadFlags) -> Result<MapPersistentRead<T,&Self>>{
        unsafe{
            (*self.buffer).borrow()
                .unsafe_map_range_persistent_read(Some(offset .. offset + length), flags)
                .map(|map| MapPersistentRead::new(
                    Self::to_t(map),
                    self
                ))
        }
    }

    fn into_map_range_persistent_read(self, offset: usize, length: usize, flags: MapReadFlags) -> Result<MapPersistentRead<T,Self>>
    where Self: Sized
    {
        unsafe{
            (*self.buffer).borrow()
                .unsafe_map_range_persistent_read(Some(offset .. offset + length), flags)
                .map(|map| MapPersistentRead::new(
                    Self::to_t(map),
                    self.clone()
                ))
        }
    }
}

#[cfg(all(not(feature = "gles"), not(feature="webgl")))]
impl<T: 'static> MapPersistentRangeMut<T> for SharedBufferStorage<T>{
    unsafe fn unsafe_map_range_persistent_write(&self, range: Option<StdRange<usize>>, flags: MapWriteFlags) -> Result<&'static mut [T]>{
        (*self.buffer).borrow()
            .unsafe_map_range_persistent_write(range, flags)
            .map(|data| Self::to_t_mut(data))
    }

    unsafe fn unsafe_map_range_persistent_read_write(&self, range: Option<StdRange<usize>>, flags: MapReadWriteFlags) -> Result<&'static mut [T]>{
        (*self.buffer).borrow()
            .unsafe_map_range_persistent_read_write(range, flags)
            .map(|data| Self::to_t_mut(data))
    }

    fn map_range_persistent_write(&self, offset: usize, length: usize, flags: MapWriteFlags) -> Result<MapPersistentWrite<T,&Self>>{
        unsafe{
            let buffer = &*self;
            (*self.buffer).borrow_mut()
                .unsafe_map_range_persistent_write(Some(offset .. offset + length), flags)
                .map(move |map| MapPersistentWrite::new(Self::to_t_mut(map), buffer))
        }
    }

    fn map_range_persistent_read_write(&self, offset: usize, length: usize, flags: MapReadWriteFlags) -> Result<MapPersistentReadWrite<T,&Self>>{
        unsafe{
            let buffer = &*self;
            (*self.buffer).borrow_mut()
                .unsafe_map_range_persistent_read_write(Some(offset .. offset + length), flags)
                .map(move |map| MapPersistentReadWrite::new(
                    Self::to_t_mut(map),
                    buffer,
                ))
        }
    }

    fn into_map_range_persistent_write(self, offset: usize, length: usize, flags: MapWriteFlags) -> Result<MapPersistentWrite<T,Self>>{
        unsafe{
            (*self.buffer).borrow_mut()
                .unsafe_map_range_persistent_write(Some(offset .. offset + length), flags)
                .map(|map| MapPersistentWrite::new(Self::to_t_mut(map), self.clone()))
        }
    }

    fn into_map_range_persistent_read_write(self, offset: usize, length: usize, flags: MapReadWriteFlags) -> Result<MapPersistentReadWrite<T,Self>>{
        unsafe{
            (*self.buffer).borrow_mut()
                .unsafe_map_range_persistent_read_write(Some(offset .. offset + length), flags)
                .map(|map| MapPersistentReadWrite::new(
                    Self::to_t_mut(map),
                    self.clone()
                ))
        }
    }
}

#[cfg(all(not(feature = "gles"), not(feature="webgl")))]
impl<T: 'static> MapPersistent<T> for SharedBufferStorage<T>{
    fn map_persistent_read(&self, flags: MapReadFlags) -> Result<MapPersistentRead<T,&Self>>{
        (*self).map_persistent_read(flags)
    }

    fn into_map_persistent_read(self, flags: MapReadFlags) -> Result<MapPersistentRead<T,Self>>
    where Self: Sized
    {
        self.into_map_persistent_read(flags)
    }
}

#[cfg(all(not(feature = "gles"), not(feature="webgl")))]
impl<T: 'static> MapPersistentMut<T> for SharedBufferStorage<T>{
    fn map_persistent_write(&self, flags: MapWriteFlags) -> Result<MapPersistentWrite<T,&Self>>{
        (*self).map_persistent_write(flags)
    }

    fn map_persistent_read_write(&self, flags: MapReadWriteFlags) -> Result<MapPersistentReadWrite<T,&Self>>{
        (*self).map_persistent_read_write(flags)
    }

    fn into_map_persistent_write(self, flags: MapWriteFlags) -> Result<MapPersistentWrite<T,Self>>{
        self.into_map_persistent_write(flags)
    }

    fn into_map_persistent_read_write(self, flags: MapReadWriteFlags) -> Result<MapPersistentReadWrite<T,Self>>{
        self.into_map_persistent_read_write(flags)
    }
}