#![allow(dead_code)]
#![allow(unused_variables)]
#![allow(unused_mut)]


extern crate cgmath;
extern crate hprof;
extern crate image;
extern crate nalgebra as na;
extern crate rand;
extern crate specs;
extern crate time;

use std::path::Path;
use std::sync::Arc;

use gilrs::{Button, Event as GilEvent, Gamepad, GamepadId, Gilrs};
use specs::prelude::*;
use vulkano::instance::debug::DebugCallback;
use vulkano::instance::Instance;
use vulkano::swapchain::Surface;
use vulkano::sync;
use vulkano::sync::GpuFuture;
use vulkano_win::VkSurfaceBuild;
use winit::dpi::LogicalSize;
use winit::event::{DeviceEvent, ElementState, Event, MouseButton, StartCause, VirtualKeyCode, WindowEvent};
use winit::event_loop::{ControlFlow, EventLoop, EventLoopProxy};
use winit::platform::unix::WindowBuilderExtUnix;
use winit::window::{Window, WindowBuilder};

use canvas::compu_frame::CompuFrame;

use crate::canvas::canvas_frame::{CanvasFrame, Drawable};
use crate::canvas::canvas_state::CanvasState;
use crate::canvas::managed::handles::{CanvasFontHandle, CanvasTextureHandle, Handle};
use crate::canvas::managed::handles::{CompuBufferHandle, CompuKernelHandle};
use crate::drawables::compu_sprite::CompuSprite;
use crate::drawables::rect::Rect;
use crate::drawables::slider::Slider;
use crate::drawables::sprite::Sprite;
use crate::drawables::text::Text;
use crate::render_system::{Geometry, Images, Position, RenderSystem, Textures};
use crate::util::load_raw;
use crate::util::timer::Timer;
use crate::util::tr_event::{TrEvent, TrEventExtension};
use crate::util::vertex::{TextureVertex3D, VertexTypeContainer};
use crate::vkprocessor::VkProcessor;
use crate::compu_system::{CompuSystem, Compu};
use crate::event_system::{EventSystem, Evented};
use petgraph::Graph;
use petgraph::graph::NodeIndex;

pub mod util;
pub mod vkprocessor;
pub mod drawables;
pub mod canvas;
pub mod render_system;
pub mod compu_system;
pub mod event_system;

#[derive(Default)]
pub struct PersistentState {
    surface: Option<Arc<Surface<Window>>>,
    window_size: (u32, u32),
    delta_time: f32,
    canvas_frame: CanvasFrame,
    compu_frame: CompuFrame,
}

struct TrSprite {
    entity: Entity,
}




pub fn main() {
















    //hprof::start_frame();
    //let g = hprof::enter("vulkan preload");

    let instance = {
        let extensions = vulkano_win::required_extensions();
        Instance::new(None, &extensions, None).unwrap()
    };

    let _callback = DebugCallback::errors_and_warnings(&instance, |msg| {
        println!("Debug callback: {:?}", msg.description);
    }).ok();

    let mut events_loop = EventLoop::<TrEventExtension>::with_user_event();

    let mut surface = WindowBuilder::new()
        .with_inner_size(LogicalSize::new(800, 800))
        .build_vk_surface(&events_loop, instance.clone()).unwrap();

    let mut processor = VkProcessor::new(instance.clone(), surface.clone());
    processor.create_swapchain(instance.clone(), surface.clone());
    processor.preload_kernels();
    processor.preload_shaders();
    processor.preload_textures();
    processor.preload_fonts();


    let mut timer = Timer::new();
    let mut frame_future: Box<dyn GpuFuture> =
        Box::new(sync::now(processor.device.clone().unwrap())) as Box<dyn GpuFuture>;

    let step_size: f32 = 0.005;
    let mut elapsed_time: f32 = timer.elap_time();

    let mut delta_time: f32 = 0.0;
    let mut accumulator_time: f32 = 0.0;
    let mut current_time: f32 = timer.elap_time();

    let image_data = load_raw(String::from("ford2.jpg"));
    let image_dimensions_f: (f32, f32) = ((image_data.1).clone().0 as f32, (image_data.1).clone().1 as f32);
    let image_dimensions_u: (u32, u32) = image_data.1;

    let compute_buffer: Arc<CompuBufferHandle> =
        processor.new_compute_buffer(image_data.0.clone(), image_data.1, 4);

    let first_output_buffer: Arc<CompuBufferHandle> =
        processor.new_compute_buffer(image_data.0.clone(), image_data.1.clone(), 4);

    let compute_kernel: Arc<CompuKernelHandle> =
        processor.get_kernel_handle(String::from("simple-edge.compute"))
            .expect("Can't find that kernel");

    let compu_image = processor.new_swap_image(image_dimensions_u);

    // Get the handles for the assets
    let funky_handle: Arc<CanvasTextureHandle> =
        processor.get_texture_handle(String::from("funky-bird.jpg")).unwrap();
    let sfml_handle: Arc<CanvasTextureHandle> =
        processor.get_texture_handle(String::from("sfml.png")).unwrap();

    let mut world = World::new();
    world.register::<Evented>();
    world.register::<Compu>();
    world.register::<Position>();
    world.register::<Geometry>();
    world.register::<Textures>();
    world.register::<Images>();
    world.insert::<VkProcessor>(processor);
    world.insert::<Vec<TrEvent<TrEventExtension>>>(Vec::new());
    world.insert::<PersistentState>(PersistentState {
        surface: Some(surface.clone()),
        window_size: (0, 0),
        delta_time,
        canvas_frame: CanvasFrame::new((0, 0)),
        compu_frame: CompuFrame::new((0, 0)),
    });

    /*
    let mut g = Graph::new();
    let mut matrix : Vec<Vec<NodeIndex<u32>>> = vec![vec![NodeIndex::new(1); 20]; 20];

    for x in 0..20 {
        for y in 0..20 {
            matrix[x][y] = g.add_node(((x, y), 0.));
        }
    }


    for x in 0..20 {
        for y in 0..20 {


            matrix[x][y] = g.add_node(((x, y), 0.));
        }
    }


    g.extend_with_edges(&[
        (a, b, 1),
        (a, d, 1),
        (b, c, 1),
        (b, f, 1),
        (c, e, 1),
        (e, f, 1),
        (d, e, 1),
    ]);*/

    // and the thing that renders it
    world.create_entity()
        .with(Compu { kernels: vec![compute_kernel], buffers: vec![compute_buffer] })// just a drawable
        .with(Position { x: 900.0, y: 900.0, z: 0 })
        .with(Geometry { size_x: 600.0, size_y: 600.0, rotation: 0.0 })
        .with(Images { images: vec![compu_image], image_resolutions: vec![image_dimensions_u] })
        .build();

    let sprite = world.create_entity()
        .with(Evented { subscribed: |event| {true} })
        .with(Position { x: 0.0, y: 0.0, z: 0 })
        .with(Geometry { size_x: 300.0, size_y: 300.0, rotation: 0.0 })
        .with(Textures { textures: vec![funky_handle] })
        .build();


    // call the run method for the following systems & deps
    let mut dispatcher = DispatcherBuilder::new()
        //  .with(SysA, "sys_a", &[])
        .with(EventSystem, "event_s", &[])
        .with(CompuSystem, "compu_s", &["event_s"])
        .with(RenderSystem, "render_s", &["event_s", "compu_s"]).build();

    let event_loop_proxy = events_loop.create_proxy();

    std::thread::spawn(move || {
        let mut gilrs = Gilrs::new().unwrap();
        // Iterate over all connected gamepads
        let mut gamepad: Option<Gamepad> = None;
        for (_id, gamepad_) in gilrs.gamepads() {
            if gamepad_.name() == "PS4" {
                gamepad = Some(gamepad_);
            }
            println!("{} is {:?} {:?}", gamepad_.name(), gamepad_.power_info(), gamepad_.id());
        }
        let mut active_gamepad = None;

        loop {
            while let Some(GilEvent { id, event, time }) = gilrs.next_event() {
                println!("{:?} New event from {}: {:?}", time, id, event);
                active_gamepad = Some(id);
                event_loop_proxy.send_event(TrEventExtension::GamepadEvent {
                    gil_event: GilEvent { id, event, time }
                }).ok();
            }

            // // You can also use cached gamepad state
            // if let Some(gamepad) = active_gamepad.map(|id| gilrs.gamepad(id)) {
            //     if gamepad.is_pressed(Button::South) {
            //         println!("Button South is pressed (XBox - A, PS - X)");
            //     }
            // }

            std::thread::sleep(std::time::Duration::from_millis(50));
        }
    });

    // Events loop is borrowed from the surface
    events_loop.run(move |event, _, control_flow| {
        *control_flow = ControlFlow::Poll;

        // The incoming event type will indicate what section of the event loop we are in
        match event {
            Event::NewEvents(cause) => {
                if cause == StartCause::Init {
                    world.write_resource::<PersistentState>()
                        .window_size = surface.window().inner_size().into();
                } else {
                    // println!("{}", world.write_resource::<Vec<TrEvent<TrEventExtension>>>().len());
                    world.write_resource::<Vec<TrEvent<TrEventExtension>>>().clear();
                }
            }
            Event::WindowEvent { event: WindowEvent::CloseRequested, .. } => {
                *control_flow = ControlFlow::Exit
            }
            Event::WindowEvent { event: WindowEvent::MouseInput { device_id, state, button, modifiers }, .. } => {
                match button {
                    MouseButton::Left => {
                        if state == ElementState::Pressed {}
                    }
                    _ => {}
                }
            }
            Event::WindowEvent { event: WindowEvent::Resized(new_size), .. } => {
                world.write_resource::<VkProcessor>()
                    .swapchain_recreate_needed = true;
                world.write_resource::<PersistentState>()
                    .window_size = (new_size.width, new_size.height);
            }
            Event::MainEventsCleared => {
                elapsed_time = timer.elap_time();
                delta_time = elapsed_time - current_time;
                current_time = elapsed_time;
                if delta_time > 0.02 {
                    delta_time = 0.02;
                }
                accumulator_time += delta_time;


                // This dispatches all the systems in parallel (but blocking).
                world.write_resource::<PersistentState>()
                    .delta_time = delta_time;
                dispatcher.dispatch(&mut world);
                //     while (accumulator_time - step_size) >= step_size {
                //         accumulator_time -= step_size;
                //     }
            }
            _ => {}
        }

        // Each NewEvents event will clear this event stack
        world.write_resource::<Vec<TrEvent<TrEventExtension>>>().push(event.into());

        /*
                match event {

                    Event::UserEvent(TrEventExtension::KeyHeldEvent {}) => {}
                    Event::UserEvent(TrEventExtension::MouseHeldEvent {}) => {}
                    Event::UserEvent(TrEventExtension::GamepadEvent { gil_event }) => {}
                    Event::DeviceEvent { device_id, event } => {
                        match event {
                            DeviceEvent::Key(keyboard_input) => {
                                match keyboard_input.virtual_keycode.unwrap() {
                                    VirtualKeyCode::A => {
                                        if keyboard_input.state == ElementState::Pressed {}
                                    }
                                    VirtualKeyCode::S => {
                                        if keyboard_input.state == ElementState::Pressed {}
                                    }
                                    VirtualKeyCode::P => {
                                        if keyboard_input.state == ElementState::Pressed {
                                            let data = world.write_resource::<VkProcessor>().read_compute_buffer(compute_buffer.clone());
                                            image::save_buffer(&Path::new("image.png"), data.as_slice(), (image_data.1).0, (image_data.1).1, image::RGBA(8));
                                        }
                                    }
                                    _ => ()
                                }
                            }
                            _ => {}
                        }
                    }


                    _ => ()
                }

                bucket the events out, but not really
                match
                event {
                    Event::NewEvents(_) => {}
                    Event::WindowEvent { window_id, event } => {}
                    Event::DeviceEvent { device_id, event } => {}
                    Event::UserEvent(tr_event) => {}
                    Event::Suspended => {}
                    Event::Resumed => {}
                    Event::MainEventsCleared => {}
                    Event::RedrawRequested(_) => {}
                    Event::RedrawEventsCleared => {}
                    Event::LoopDestroyed => {}
                }*/
    });


    // hprof::end_frame();
    // hprof::profiler().print_timing();
}