use std::collections::HashMap;
use std::num::NonZeroU32;
use std::sync::Arc;

use assets::Assets;
use bevy_ecs::entity::Entity;
use bevy_ecs::event::Events;
use bevy_ecs::world::World;
use egui_glow::EguiGlow;
use glow::{HasContext, PixelUnpackData};
#[cfg(not(target_arch = "wasm32"))]
use glutin::surface::{Surface, WindowSurface, GlSurface, SwapInterval};
#[cfg(not(target_arch = "wasm32"))]
use glutin::{config::{ConfigTemplateBuilder, GlConfig}, context::{ContextApi, ContextAttributesBuilder, PossiblyCurrentContext}, display::GetGlDisplay, prelude::{GlDisplay, NotCurrentGlContext}};
#[cfg(not(target_arch = "wasm32"))]
use glutin_winit::{DisplayBuilder, GlWindow};
use starkingdoms_common::PlanetType;
#[cfg(target_arch = "wasm32")]
use wasm_bindgen::{prelude::Closure, JsCast};
#[cfg(target_arch = "wasm32")]
use web_sys::{Event, HtmlCanvasElement};
use winit::event::MouseScrollDelta;
use winit::event_loop::ControlFlow;
#[cfg(target_arch = "wasm32")]
use winit::platform::web::{WindowAttributesExtWebSys, WindowExtWebSys};
use winit::{application::ApplicationHandler, dpi::LogicalSize, event::WindowEvent, event_loop::ActiveEventLoop, raw_window_handle::HasWindowHandle, window::{Window, WindowAttributes}};

use crate::components::{Camera, RecvPacket, SendPacket, Texture, Transform};
use crate::networking::process_packets;
use crate::networking::ws::Ws;
#[cfg(not(target_arch="wasm32"))]
#[path = "assets_native.rs"]
pub mod assets;
#[cfg(target_arch="wasm32")]
#[path = "assets_wasm.rs"]
pub mod assets;

#[derive(Default)]
pub struct App {
    window: Option<Window>,
    world: World,

    program: Option<glow::Program>,
    vertex_array: Option<glow::VertexArray>,
    vertex_buffer: Option<glow::Buffer>,
    element_buffer: Option<glow::Buffer>,
    #[cfg(not(target_arch = "wasm32"))]
    gl_surface: Option<Surface<WindowSurface>>,
    #[cfg(not(target_arch = "wasm32"))]
    gl_context: Option<PossiblyCurrentContext>,
    egui_glow: Option<EguiGlow>,
    gl: Option<Arc<glow::Context>>,
    textures: HashMap<String, glow::Texture>,

    send_packet_events: Events<SendPacket>,
    recv_packet_events: Events<RecvPacket>,
    planet_types: HashMap<PlanetType, (Entity, u32)>, // (world entity, server id)
}

const VERTICES: [f32; 16] = [
    -1.0, -1.0,     0.0, 1.0,
    1.0, -1.0,      1.0, 1.0,
    1.0, 1.0,       1.0, 0.0,
    -1.0, 1.0,      0.0, 0.0,
];
const INDICES: [u32; 6] = [
    0, 1, 2,
    2, 3, 0,
];

impl App {
    pub fn new(
        world: World,
        send_packet_events: Events<SendPacket>,
        recv_packet_events: Events<RecvPacket>
    ) -> Self {
        Self {
            world,
            send_packet_events,
            recv_packet_events,
            ..Default::default()
        }
    }
}

impl ApplicationHandler for App {
    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
        #[cfg(target_arch = "wasm32")]
        let attributes = {
            let document = web_sys::window().unwrap().document().unwrap();
            let canvas = document.get_element_by_id("canvas").unwrap();
            let canvas = canvas.dyn_into::<web_sys::HtmlCanvasElement>()
                .map_err(|_| ()).unwrap();
            canvas.set_width(web_sys::window().unwrap().inner_width().unwrap().as_f64().unwrap() as u32);
            canvas.set_height(web_sys::window().unwrap().inner_height().unwrap().as_f64().unwrap() as u32);
            Window::default_attributes()
                .with_title("StarKingdoms.TK")
                .with_canvas(Some(canvas))
        };
        #[cfg(not(target_arch = "wasm32"))]
        let attributes = {
            Window::default_attributes().with_transparent(true).with_title("StarKingdoms.TK")
                .with_inner_size(LogicalSize::new(400, 300))
        };
        self.window = Some(event_loop.create_window(attributes.clone()).unwrap());
        let window = self.window.as_ref().unwrap();
        #[cfg(target_arch = "wasm32")]
        let context = window.canvas().unwrap().get_context("webgl2")
            .unwrap().unwrap()
            .dyn_into::<web_sys::WebGl2RenderingContext>()
            .unwrap();
        #[cfg(target_arch = "wasm32")]
        let (gl, shader_version) = (Arc::new(glow::Context::from_webgl2_context(context)), "#version 300 es");

        #[cfg(not(target_arch = "wasm32"))]
        let (gl, shader_version) = unsafe {
            let template = ConfigTemplateBuilder::new().with_transparency(true);

            let display_builder = DisplayBuilder::new().with_window_attributes(Some(attributes));

            let (window, gl_config) = display_builder.build(event_loop, template, |configs| {
                configs.reduce(|accum, config| {
                    let supports_transparency = config.supports_transparency().unwrap_or(false)
                        && !accum.supports_transparency().unwrap_or(false);
                    if supports_transparency || config.num_samples() > accum.num_samples() {
                        config
                    } else {
                        accum
                    }
                }).unwrap()
            }).unwrap();
            let raw_handle = window.as_ref().map(|window| window.window_handle().unwrap().window_handle().unwrap().as_raw());
            let gl_display = gl_config.display();
            let context_attributes = ContextAttributesBuilder::new()
                .with_context_api(ContextApi::OpenGl(Some(glutin::context::Version {
                    major: 3,
                    minor: 0,
                }))).build(raw_handle);

            let not_current_gl_context = gl_display.create_context(&gl_config, &context_attributes).unwrap();

            let window = window.unwrap();
            let surface_attributes = window.build_surface_attributes(Default::default()).unwrap();
            let gl_surface = gl_display.create_window_surface(&gl_config, &surface_attributes).unwrap();

            let gl_context = not_current_gl_context.make_current(&gl_surface).unwrap();

            let gl = glow::Context::from_loader_function_cstr(|s| gl_display.get_proc_address(s));

            gl_surface.set_swap_interval(&gl_context, SwapInterval::Wait(NonZeroU32::new(1).unwrap())).unwrap();

            self.gl_surface = Some(gl_surface);
            self.gl_context = Some(gl_context);

            (Arc::new(gl), "#version 300 es")
        };
        unsafe {
            let shaders = [
                ("vertex", include_str!("../shaders/vertex.glsl"), glow::VERTEX_SHADER),
                ("fragment", include_str!("../shaders/fragment.glsl"), glow::FRAGMENT_SHADER),
            ];
            let program = gl.create_program().expect("Failed to create program");

            for (name, source, shader_type) in shaders {
                let shader = gl.create_shader(shader_type).expect("Failed to create vertex shader");
                gl.shader_source(shader, &format!("{}\n{}", shader_version, source));
                gl.compile_shader(shader);
                if !gl.get_shader_compile_status(shader) {
                    tracing::error!("error in {} shader: {}", name, gl.get_shader_info_log(shader));
                }
                gl.attach_shader(program, shader);
                gl.delete_shader(shader);
            }
            gl.link_program(program);

            gl.use_program(Some(program));

            let vertex_array = gl.create_vertex_array().expect("Failed to create vertex array");
            gl.bind_vertex_array(Some(vertex_array));
            let vertex_buffer = gl.create_buffer().expect("Failed to create vertex buffer");
            gl.bind_buffer(glow::ARRAY_BUFFER, Some(vertex_buffer));
            let element_buffer = gl.create_buffer().expect("Failed to create element buffer");
            gl.bind_buffer(glow::ELEMENT_ARRAY_BUFFER, Some(element_buffer));
            gl.buffer_data_u8_slice(glow::ARRAY_BUFFER,
                std::slice::from_raw_parts(VERTICES.as_ptr() as *const u8, size_of_val(&VERTICES)),
                glow::STATIC_DRAW);
            gl.buffer_data_u8_slice(glow::ELEMENT_ARRAY_BUFFER,
                std::slice::from_raw_parts(INDICES.as_ptr() as *const u8, size_of_val(&INDICES)),
                glow::STATIC_DRAW);

            gl.vertex_attrib_pointer_f32(0, 2, glow::FLOAT, false, 4*size_of::<f32>() as i32, 0);
            gl.enable_vertex_attrib_array(0);
            gl.vertex_attrib_pointer_f32(1, 2, glow::FLOAT, false, 4*size_of::<f32>() as i32, 2*size_of::<f32>() as i32);
            gl.enable_vertex_attrib_array(1);


            gl.clear_color(0.7, 0.7, 0.7, 1.0);
            gl.viewport(0, 0, window.inner_size().width as i32, window.inner_size().height as i32);
            gl.enable(glow::BLEND);
            gl.blend_func(glow::SRC_ALPHA, glow::ONE_MINUS_SRC_ALPHA);

            self.program = Some(program);
            self.vertex_array = Some(vertex_array);
            self.vertex_buffer = Some(vertex_buffer);
            self.element_buffer = Some(element_buffer);
        }
        #[cfg(target_arch = "wasm32")]
        web_sys::window().unwrap().set_onresize(Some(Closure::<dyn Fn(Event)>::new(move |_| {
            let document = web_sys::window().unwrap().document().unwrap();
            let canvas = document.get_element_by_id("canvas").unwrap();
            let canvas = canvas.dyn_into::<web_sys::HtmlCanvasElement>()
                .map_err(|_| ()).unwrap();
            canvas.set_width(web_sys::window().unwrap().inner_width().unwrap().as_f64().unwrap() as u32);
            canvas.set_height(web_sys::window().unwrap().inner_height().unwrap().as_f64().unwrap() as u32);
        }).into_js_value().as_ref().unchecked_ref()));

        let egui_glow = egui_glow::EguiGlow::new(event_loop, gl.clone(), None, None, true);
        self.egui_glow = Some(egui_glow);
        self.gl = Some(gl);
    }
    fn window_event(
        &mut self,
        event_loop: &ActiveEventLoop,
        window_id: winit::window::WindowId,
        event: winit::event::WindowEvent,
    ) {
        match event {
            WindowEvent::CloseRequested => {
                event_loop.exit();
            }
            WindowEvent::Resized(size) => {
                #[cfg(not(target_arch = "wasm32"))]
                self.gl_surface.as_ref().unwrap().resize(self.gl_context.as_ref().unwrap(),
                    NonZeroU32::new(size.width).unwrap(), NonZeroU32::new(size.height).unwrap());

                let mut camera = self.world.get_resource_mut::<Camera>().unwrap();
                camera.width = size.width;
                camera.height = size.height;

                unsafe {
                    self.gl.as_ref().unwrap().viewport(0, 0, size.width as i32, size.height as i32);
                }
            }
            WindowEvent::MouseWheel { delta, .. } => {
                let mut camera = self.world.get_resource_mut::<Camera>().unwrap();
                let raw_delta = match delta {
                    MouseScrollDelta::PixelDelta(pos) => {
                        pos.y as f32
                    }
                    MouseScrollDelta::LineDelta(y, .. ) => {
                        y
                    }
                };
                let delta = 1.1;
                if raw_delta < 0.0 {
                    camera.zoom *= 1.0 / delta;
                } else {

                    camera.zoom *= delta;
                }
            }
            _ => {}
        }
        let event_response = self.egui_glow.as_mut().unwrap()
            .on_window_event(self.window.as_ref().unwrap(), &event);
    }
    fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
        let mut ws = self.world.get_resource_mut::<Ws>().expect("Failed to get Ws resource");
        #[cfg(target_arch = "wasm32")]
        while let Ok(Some(packet)) = ws.receiver.try_next() {
            self.recv_packet_events.send(RecvPacket(packet));
        }
        #[cfg(not(target_arch = "wasm32"))]
        for packet in ws.receiver.iter() {
            self.recv_packet_events.send(RecvPacket(packet));
        }
        self.send_packet_events.update();
        self.recv_packet_events.update();

        process_packets(&mut self.world, &mut self.send_packet_events, &mut self.recv_packet_events, &mut self.planet_types);

        let window = self.window.as_ref().unwrap();
        let gl = self.gl.as_ref().unwrap();

        self.egui_glow.as_mut().unwrap().run(
            self.window.as_ref().unwrap(),
            |ctx| {
                egui::Window::new("Main Menu").resizable(false).show(ctx, |ui| {
                    ui.heading("Starkingdoms.tk");
                });
            },
        );

        let camera = self.world.get_resource::<Camera>().unwrap();
        let x_scale = camera.zoom / camera.width as f32 * 2.0;
        let y_scale = camera.zoom / camera.height as f32 * 2.0;
        let view = &[
            x_scale,    0.0,    0.0,    camera.x*x_scale,
            0.0,        y_scale,0.0,    camera.y*y_scale,
            0.0,        0.0,    1.0,    0.0,
            0.0,        0.0,    0.0,    1.0,
        ];

        let mut sprite_query = self.world.query::<(&Transform, &mut Texture)>();

        let mut sprites = Vec::new();
        for (transform, texture) in sprite_query.iter(&self.world) {
            sprites.push((transform, texture));
        }

        unsafe {
            gl.clear(glow::COLOR_BUFFER_BIT);
            gl.use_program(self.program);
            gl.bind_vertex_array(self.vertex_array);
            gl.bind_buffer(glow::ARRAY_BUFFER, self.vertex_buffer);
            gl.bind_buffer(glow::ELEMENT_ARRAY_BUFFER, self.element_buffer);
            gl.active_texture(glow::TEXTURE0);
            
            let view_loc = gl.get_uniform_location(self.program.unwrap(), "view");
            gl.uniform_matrix_4_f32_slice(view_loc.as_ref(), true, view);
            let model_loc = gl.get_uniform_location(self.program.unwrap(), "model");

            for (transform, texture) in sprites {
                if !self.textures.contains_key(&texture.name) {
                    let assets = self.world.resource::<Assets>();
                    let image = match assets.get(texture.name.clone()) {
                        Some(t) => t,
                        None => continue
                    };

                    let texture_object = gl.create_texture().expect("Failed to create texture object");
                    gl.bind_texture(glow::TEXTURE_2D, Some(texture_object));
                    gl.tex_image_2d(glow::TEXTURE_2D, 0, glow::RGBA as i32,
                        image.width as i32, image.height as i32, 0, glow::RGBA,
                        glow::UNSIGNED_BYTE, PixelUnpackData::Slice(Some(&image.bytes)));
                    gl.generate_mipmap(glow::TEXTURE_2D);

                    tracing::info!("{}", texture.name);
                    self.textures.insert(texture.name.clone(), texture_object);
                }
                // now the texture must exist

                let model = transform.to_matrix();
                let model = model.as_slice();
                gl.uniform_matrix_4_f32_slice(model_loc.as_ref(), false, model);

                gl.bind_texture(glow::TEXTURE_2D, self.textures.get(&texture.name).copied());
                gl.draw_elements(glow::TRIANGLES, 6, glow::UNSIGNED_INT, 0);
            }
        }

        self.egui_glow.as_mut().unwrap().paint(self.window.as_ref().unwrap());

        #[cfg(not(target_arch = "wasm32"))]
        self.gl_surface.as_ref().unwrap().swap_buffers(self.gl_context.as_ref().unwrap()).unwrap();

        let mut ws = self.world.get_resource_mut::<Ws>().expect("Failed to get Ws resource");
        let mut send_event_cursor = self.send_packet_events.get_cursor();
        for event in send_event_cursor.read(&self.send_packet_events) {
            ws.send_packet(event.0.clone());
        }

        event_loop.set_control_flow(ControlFlow::WaitUntil(web_time::Instant::now().checked_add(web_time::Duration::from_millis(16)).unwrap()));
    }
}