use std::collections::VecDeque;
use std::ffi::CString;
use std::sync::{Arc, Mutex};

use libc;

use {ContextError, CreationError, CursorState, Event, GlAttributes, GlContext,
     MouseCursor, PixelFormat, PixelFormatRequirements, WindowAttributes};
use api::dlopen;
use api::egl;
use api::egl::Context as EglContext;

use wayland_client::egl as wegl;
use super::wayland_window::{DecoratedSurface, add_borders, substract_borders};
use super::context::{WaylandContext, WAYLAND_CONTEXT};

#[derive(Clone)]
pub struct WindowProxy;

impl WindowProxy {
    #[inline]
    pub fn wakeup_event_loop(&self) {
        unimplemented!()
    }
}

pub struct Window {
    wayland_context: &'static WaylandContext,
    egl_surface: wegl::WlEglSurface,
    decorated_surface: Mutex<DecoratedSurface>,
    evt_queue: Arc<Mutex<VecDeque<Event>>>,
    inner_size: Mutex<(i32, i32)>,
    resize_callback: Option<fn(u32, u32)>,
    pub context: EglContext,
}

impl Window {
    fn next_event(&self) -> Option<Event> {
        let mut newsize = None;
        for (_, w, h) in &mut *self.decorated_surface.lock().unwrap() {
            newsize = Some((w, h));
        }
        if let Some((w, h)) = newsize {
            let (w, h) = substract_borders(w, h);
            *self.inner_size.lock().unwrap() = (w, h);
            self.decorated_surface.lock().unwrap().resize(w, h);
            self.egl_surface.resize(w, h, 0, 0);
            if let Some(f) = self.resize_callback {
                f(w as u32, h as u32);
            }
            Some(Event::Resized(w as u32, h as u32))
        } else {
            self.evt_queue.lock().unwrap().pop_front()
        }
    }
}

pub struct PollEventsIterator<'a> {
    window: &'a Window,
}

impl<'a> Iterator for PollEventsIterator<'a> {
    type Item = Event;

    fn next(&mut self) -> Option<Event> {
        match self.window.next_event() {
            Some(evt) => return Some(evt),
            None => {}
        }
        // the queue was empty, try a dispatch and see the result
        self.window.wayland_context.dispatch_events();
        return self.window.next_event();
    }
}

pub struct WaitEventsIterator<'a> {
    window: &'a Window,
}

impl<'a> Iterator for WaitEventsIterator<'a> {
    type Item = Event;

    fn next(&mut self) -> Option<Event> {
        loop {
            match self.window.next_event() {
                Some(evt) => return Some(evt),
                None => {}
            }
            // the queue was empty, try a dispatch & read and see the result
            self.window.wayland_context.flush_events().expect("Connexion with the wayland compositor lost.");
            match self.window.wayland_context.read_events() {
                Ok(_) => {
                    // events were read or dispatch is needed, in both cases, we dispatch
                    self.window.wayland_context.dispatch_events()
                }
                Err(_) => panic!("Connexion with the wayland compositor lost.")
            }
        }
    }
}

impl Window {
    pub fn new(window: &WindowAttributes, pf_reqs: &PixelFormatRequirements,
               opengl: &GlAttributes<&Window>) -> Result<Window, CreationError>
    {
        // not implemented
        assert!(window.min_dimensions.is_none());
        assert!(window.max_dimensions.is_none());

        let wayland_context = match *WAYLAND_CONTEXT {
            Some(ref c) => c,
            None => return Err(CreationError::NotSupported),
        };

        if !wegl::is_available() {
            return Err(CreationError::NotSupported)
        }

        let (w, h) = window.dimensions.unwrap_or((800, 600));

        let (surface, evt_queue) = match wayland_context.new_surface() {
            Some(t) => t,
            None => return Err(CreationError::NotSupported)
        };

        let egl_surface = wegl::WlEglSurface::new(surface, w as i32, h as i32);

        let context = {
            let libegl = unsafe { dlopen::dlopen(b"libEGL.so\0".as_ptr() as *const _, dlopen::RTLD_NOW) };
            if libegl.is_null() {
                return Err(CreationError::NotSupported);
            }
            let egl = ::api::egl::ffi::egl::Egl::load_with(|sym| {
                let sym = CString::new(sym).unwrap();
                unsafe { dlopen::dlsym(libegl, sym.as_ptr()) }
            });
            try!(EglContext::new(
                egl,
                pf_reqs, &opengl.clone().map_sharing(|_| unimplemented!()),        // TODO: 
                egl::NativeDisplay::Wayland(Some(wayland_context.display_ptr() as *const _)))
                .and_then(|p| p.finish(unsafe { egl_surface.egl_surfaceptr() } as *const _))
            )
        };

        let decorated_surface = match wayland_context.decorated_from(&egl_surface, w as i32, h as i32) {
            Some(s) => s,
            None => return Err(CreationError::NotSupported)
        };

        Ok(Window {
            wayland_context: wayland_context,
            egl_surface: egl_surface,
            decorated_surface: Mutex::new(decorated_surface),
            evt_queue: evt_queue,
            inner_size: Mutex::new((w as i32, h as i32)),
            resize_callback: None,
            context: context
        })
    }

    pub fn set_title(&self, title: &str) {
        self.decorated_surface.lock().unwrap().set_title(title.into())
    }

    #[inline]
    pub fn show(&self) {
        // TODO
    }

    #[inline]
    pub fn hide(&self) {
        // TODO
    }

    #[inline]
    pub fn get_position(&self) -> Option<(i32, i32)> {
        // Not possible with wayland
        None
    }

    #[inline]
    pub fn set_position(&self, _x: i32, _y: i32) {
        // Not possible with wayland
    }

    pub fn get_inner_size(&self) -> Option<(u32, u32)> {
        let (w, h) = *self.inner_size.lock().unwrap();
        Some((w as u32, h as u32))
    }

    #[inline]
    pub fn get_outer_size(&self) -> Option<(u32, u32)> {
        let (w, h) = *self.inner_size.lock().unwrap();
        let (w, h) = add_borders(w, h);
        Some((w as u32, h as u32))
    }

    #[inline]
    pub fn set_inner_size(&self, x: u32, y: u32) {
        self.decorated_surface.lock().unwrap().resize(x as i32, y as i32)
    }

    #[inline]
    pub fn create_window_proxy(&self) -> WindowProxy {
        WindowProxy
    }

    #[inline]
    pub fn poll_events(&self) -> PollEventsIterator {
        PollEventsIterator {
            window: self
        }
    }

    #[inline]
    pub fn wait_events(&self) -> WaitEventsIterator {
        WaitEventsIterator {
            window: self
        }
    }

    #[inline]
    pub fn set_window_resize_callback(&mut self, callback: Option<fn(u32, u32)>) {
        self.resize_callback = callback;
    }

    #[inline]
    pub fn set_cursor(&self, cursor: MouseCursor) {
        // TODO
    }

    #[inline]
    pub fn set_cursor_state(&self, state: CursorState) -> Result<(), String> {
        // TODO
        Ok(())
    }

    #[inline]
    pub fn hidpi_factor(&self) -> f32 {
        1.0
    }

    #[inline]
    pub fn set_cursor_position(&self, _x: i32, _y: i32) -> Result<(), ()> {
        // TODO: not yet possible on wayland
        Ok(())
    }

    #[inline]
    pub fn platform_display(&self) -> *mut libc::c_void {
        unimplemented!()
    }

    #[inline]
    pub fn platform_window(&self) -> *mut libc::c_void {
        unimplemented!()
    }
}

impl GlContext for Window {
    #[inline]
    unsafe fn make_current(&self) -> Result<(), ContextError> {
        self.context.make_current()
    }

    #[inline]
    fn is_current(&self) -> bool {
        self.context.is_current()
    }

    #[inline]
    fn get_proc_address(&self, addr: &str) -> *const () {
        self.context.get_proc_address(addr)
    }

    #[inline]
    fn swap_buffers(&self) -> Result<(), ContextError> {
        self.context.swap_buffers()
    }

    #[inline]
    fn get_api(&self) -> ::Api {
        self.context.get_api()
    }

    #[inline]
    fn get_pixel_format(&self) -> PixelFormat {
        self.context.get_pixel_format().clone()
    }
}

impl Drop for Window {
    fn drop(&mut self) {
        use wayland_client::Proxy;
        self.wayland_context.dropped_surface((*self.egl_surface).id())
    }
}