use std::time::Duration;

use futures::executor::block_on;

use glutin::{

    dpi, ContextTrait, DeviceEvent, ElementState, Event, EventsLoop, GlProfile, GlRequest,

    MouseButton, MouseScrollDelta, Window, WindowBuilder, WindowEvent, WindowedContext,

};

use hedgewars_engine::instance::EngineInstance;

use integral_geometry::Point;

use std::error::Error;

use wgpu::{

    Adapter, BackendBit, Color, CommandEncoderDescriptor, Device, DeviceDescriptor, Features,

    LoadOp, Operations, PowerPreference, PresentMode, Queue, RenderPassColorAttachmentDescriptor,

    RenderPassDescriptor, RequestAdapterOptions, Surface, SwapChain, SwapChainDescriptor,

    TextureFormat, TextureUsage,

};

type HwGlRendererContext = WindowedContext;

struct HwWgpuRenderingContext {

    window: Window,

    surface: Surface,

    adapter: Adapter,

    device: Device,

    queue: Queue,

    swap_chain: SwapChain,

}

enum HwRendererContext {

    Gl(HwGlRendererContext),

    Wgpu(HwWgpuRenderingContext),

}

struct ErrorStub;

impl<T: Error> From<T> for ErrorStub {

    fn from(_: T) -> Self {

        ErrorStub

    }

}

impl HwRendererContext {

    pub fn window(&self) -> &Window {

        match self {

            HwRendererContext::Gl(gl) => &gl.window(),

            HwRendererContext::Wgpu(wgpu) => &wgpu.window,

        }

    }

        match self {

            HwRendererContext::Gl(context) => unsafe {

            },

            HwRendererContext::Wgpu(context) => {

                    &context.surface,

                );

            }

        }

    }

    pub fn present(&mut self) -> Result<(), ErrorStub> {

        match self {

            HwRendererContext::Gl(context) => context.swap_buffers()?,

            HwRendererContext::Wgpu(context) => {

                let frame_view = &context.swap_chain.get_current_frame()?.output.view;

                let mut encoder =

                    context

                        .device

                        .create_command_encoder(&CommandEncoderDescriptor {

                            label: Some("Main encoder"),

                        });

                encoder.begin_render_pass(&RenderPassDescriptor {

                    color_attachments: &[RenderPassColorAttachmentDescriptor {

                        attachment: &frame_view,

                        resolve_target: None,

                        ops: Operations {

                            store: false,

                        },

                    }],

                    depth_stencil_attachment: None,

                });

                let buffer = encoder.finish();

                context.queue.submit(std::iter::once(buffer));

            }

        }

        Ok(())

    }

}

fn main() {

    let mut event_loop = EventsLoop::new();

    let (w, h) = (1024.0, 768.0);

    let mut engine = EngineInstance::new();

    if !use_wgpu {

        engine.world.create_renderer(w as u16, h as u16);

    }

    let mut dragging = false;

    use std::time::Instant;

    let mut now = Instant::now();

    let mut update_time = Instant::now();

    let mut render_time = Instant::now();

    let mut is_running = true;

    while is_running {

        let current_time = Instant::now();

        let delta = current_time - now;

        now = current_time;

        let ms = delta.as_secs() as f64 * 1000.0 + delta.subsec_millis() as f64;

        context.window().set_title(&format!("hwengine {:.3}ms", ms));

        if update_time.elapsed() > Duration::from_millis(10) {

            update_time = current_time;

            engine.world.step()

        }

        event_loop.poll_events(|event| match event {

            Event::WindowEvent { event, .. } => match event {

                WindowEvent::CloseRequested => {

                    is_running = false;

                }

                WindowEvent::MouseInput { button, state, .. } => {

                    if let MouseButton::Right = button {

                        dragging = state == ElementState::Pressed;

                    }

                }

                WindowEvent::MouseWheel { delta, .. } => {

                    let zoom_change = match delta {

                        MouseScrollDelta::LineDelta(x, y) => y as f32 * 0.1f32,

                        MouseScrollDelta::PixelDelta(delta) => {

                            let physical = delta.to_physical(context.window().get_hidpi_factor());

                            physical.y as f32 * 0.1f32

                        }

                    };

                    engine.world.move_camera(Point::ZERO, zoom_change);

                }

                _ => (),

            },

            Event::DeviceEvent { event, .. } => match event {

                DeviceEvent::MouseMotion { delta } => {

                    if dragging {

                        engine

                            .world

                            .move_camera(Point::new(delta.0 as i32, delta.1 as i32), 0.0)

                    }

                }

                _ => {}

            },

            _ => (),

        });

        if render_time.elapsed() > Duration::from_millis(16) {

            render_time = current_time;

            if !use_wgpu {

                engine.render();

            }

        }

    }

}