#[allow(unused_imports)]
use log::{debug, error, info, trace, warn};

use std::time::Duration;

use raw_window_handle::HasRawWindowHandle;

use crate::utils::Rect;

pub mod winit_window;
pub use self::winit_window::WinitWindow;


//--Output trait------------------------------------------------------------------------------------
/// A trait for the ability of a type to be used as an output by the engine. 
///
/// The `Output` trait  defines functions to be used by different components of the engine. This
/// allows to display with any window manager as long as the trait is defined for it.
///
/// Types that implement the `Output` trait should manage the underlying window and settings.
///
/// Implementation : the ID and size stored by the type implementing this trait don't need to be
/// initialized to anything specific as the engine will take care of it.
pub trait Output<W> 
where 
    W: HasRawWindowHandle,
{
    /// Return the ID stored internally. Used to select the right swapchain by the render engine. 
    /// For internal use only.
    fn get_id(&self) -> usize;

    /// Store the given ID internally. For internal use only.
    fn set_id(&mut self, id: usize);

    //TODO clean that
    /// Give mutable acces to the size of the output. The size is a simple rectangle containing the
    /// width and height of the `Output`.
    fn size(&mut self) -> &mut Rect<i32>;

    /// Give reference acces to the underlying window. This is used by the engine during setup to
    /// create the revelant ressources.
    fn window(&self) -> &W;
}

//--Input trait-------------------------------------------------------------------------------------
/// A trait for the ability of a type to be used as an input by the engine
///
/// The `Input` trait defines functions used by different components of the engine. The allow to
/// read inputs from any window manzger as long as the is defined for it.
///
/// Types that implement the `Input` trait should manage the EventLoop. This can be done in any way
/// (polling, interrupt, synchronous, asynchronous, ...) depending on how the input should be 
/// handled.
pub trait Input {
    /// Return the next input available or a ReadError if an error occured of the timeout duration 
    /// was reached. How inputs are handled depends on the implementation.
    //TODO change timeout
    fn read(&self, timeout: Duration) -> Result<Key, ReadError>;

    fn write(&self, signal: Signal);
}

//--Key enum----------------------------------------------------------------------------------------
#[derive(Debug)]
pub enum Key {
    Close,
    Closed,
    Test,
    MouseMove { x: f64, y: f64 },
}

//--Signal enum-------------------------------------------------------------------------------------
#[derive(Debug)]
pub enum Signal {
    Exit,
    Test,
}

//--ReadError enum----------------------------------------------------------------------------------
#[derive(Debug)]
pub enum ReadError {
    Timeout,
}