use crate::model::parse_obj;
use bytemuck::bytes_of;
use image::EncodableLayout;
use std::collections::BTreeMap;
use std::sync::Arc;
use tobj::LoadOptions;
use tracing::info;
use wgpu::util::DeviceExt;
use wgpu::{Backends, BufferUsages, Device, FragmentState, IndexFormat, Instance, InstanceDescriptor, PipelineCompilationOptions};
use winit::application::ApplicationHandler;
use winit::event::{ElementState, MouseButton};
use winit::event_loop::{ActiveEventLoop, EventLoop};
#[cfg(target_os = "android")]
use winit::platform::android::activity::AndroidApp;
use winit::window::{Window, WindowAttributes, WindowId};
use zlog::LogLevel;
use zlog::config::LoggerConfig;

pub mod camera;
pub mod model;
pub mod texture;
struct WindowContext<'window> {
    window: Arc<Window>,
    renderer: WgpuRenderer<'window>,
}
impl std::ops::Deref for WindowContext<'_> {
    type Target = winit::window::Window;

    fn deref(&self) -> &Self::Target {
        self.window.as_ref()
    }
}

struct WgpuRenderer<'surface> {
    device: wgpu::Device,
    queue: wgpu::Queue,
    surface: wgpu::Surface<'surface>,
    surface_config: wgpu::SurfaceConfiguration,
    render_pipeline: wgpu::RenderPipeline,
    vertex_buffer: wgpu::Buffer,
    index_buffer: wgpu::Buffer,
    diffuse_bind_group: wgpu::BindGroup,

    depth_texture: wgpu::Texture,
    depth_texture_view: wgpu::TextureView,
    camera: camera::Camera,
    camera_uniform: camera::CameraUniform,
    camera_buffer: wgpu::Buffer,
    camera_bind_group: wgpu::BindGroup,
    index_count: u32,
}

impl WgpuRenderer<'_> {
    pub fn draw(&mut self) {
        let surface_texture = self.surface.get_current_texture().unwrap();
        let view = surface_texture.texture.create_view(&Default::default());
        let mut encoder =
            self.device
                .create_command_encoder(&wgpu::wgt::CommandEncoderDescriptor {
                    label: Some("Render encoder"),
                });
        {
            let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                label: Some("Render"),
                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                    view: &view,
                    resolve_target: None,
                    ops: wgpu::Operations {
                        load: wgpu::LoadOp::Clear(wgpu::Color::WHITE),
                        store: wgpu::StoreOp::Store,
                    },
                })],
                depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
                    view: &self.depth_texture_view,
                    depth_ops: Some(wgpu::Operations {
                        load: wgpu::LoadOp::Clear(1.0),
                        store: wgpu::StoreOp::Store,
                    }),
                    stencil_ops: None,
                }),
                occlusion_query_set: None,
                timestamp_writes: None,
            });
            rpass.set_pipeline(&self.render_pipeline);
            rpass.set_bind_group(0, &self.diffuse_bind_group,   &[]);

            rpass.set_bind_group(1, &self.camera_bind_group, &[]);
            rpass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
            rpass.set_index_buffer(self.index_buffer.slice(..), IndexFormat::Uint32);
            rpass.draw_indexed(0..self.index_count, 0, 0..1);
        }
        self.queue.submit(Some(encoder.finish()));
        surface_texture.present()
    }
}

struct App<'window> {
    state: WgpuState,
    windows: BTreeMap<WindowId, WindowContext<'window>>,
}

impl App<'_> {
    fn new() -> Self {
        Self {
            state: WgpuState::new(),
            windows: BTreeMap::new(),
        }
    }

    pub fn spawn_window(&mut self, event_loop: &ActiveEventLoop) {
        let attr = WindowAttributes::default()
            .with_title("Zenyx - SubWindow")
            .with_min_inner_size(winit::dpi::LogicalSize::new(1, 1));

        let window = event_loop.create_window(attr).unwrap();
        let window = Arc::new(window);
        let renderer = self.state.create_renderer(window.clone());
        let window_ctx = WindowContext {
            renderer: smol::block_on(renderer),
            window: window.clone(),
        };
        let window_id = window.id();
        self.windows.insert(window_id, window_ctx);
    }
}

struct WgpuState {
    instance: wgpu::Instance,
}
unsafe impl bytemuck::Pod for Vertex {}
unsafe impl bytemuck::Zeroable for Vertex {}

#[derive(Copy, Clone, Debug)]
#[repr(C)]
struct Vertex {
    position: cgmath::Vector3<f32>,
    color: cgmath::Vector3<f32>,
    normal: cgmath::Vector3<f32>,
    tex_coords: cgmath::Vector2<f32>,
}

impl Vertex {
    const ATTRIBS: [wgpu::VertexAttribute; 4] = [
        wgpu::VertexAttribute {
            offset: 0,
            shader_location: 0,
            format: wgpu::VertexFormat::Float32x3,
        },
        wgpu::VertexAttribute {
            offset: std::mem::offset_of!(Vertex, color) as u64,
            shader_location: 1,
            format: wgpu::VertexFormat::Float32x3,
        },
        wgpu::VertexAttribute {
            offset: std::mem::offset_of!(Vertex, normal) as u64,
            shader_location: 2,
            format: wgpu::VertexFormat::Float32x3,
        },
        wgpu::VertexAttribute {
            offset: std::mem::offset_of!(Vertex, tex_coords) as u64,
            shader_location: 3,
            format: wgpu::VertexFormat::Float32x2,
        },
    ];

    const fn desc<'a>() -> wgpu::VertexBufferLayout<'a> {
        wgpu::VertexBufferLayout {
            array_stride: std::mem::size_of::<Vertex>() as wgpu::BufferAddress,
            step_mode: wgpu::VertexStepMode::Vertex,
            attributes: &Self::ATTRIBS,
        }
    }
}
static ICON: &[u8] = include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/assets/Badge.png"));
static PUMPKIN: &[u8] = include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/Pumpkin.obj"));

impl WgpuState {
    fn new() -> Self {
        let backends = Backends::PRIMARY;
        let instance_descriptor = InstanceDescriptor {
            backends,
            ..Default::default()
        };
        let instance = Instance::new(&instance_descriptor);
        Self { instance }
    }

    async fn create_renderer<'surface>(&self, window: Arc<Window>) -> WgpuRenderer<'surface> {
        let surface = self.instance.create_surface(window.clone()).unwrap();
        let adapter = self
            .instance
            .request_adapter(&wgpu::RequestAdapterOptions {
                power_preference: wgpu::PowerPreference::default(),
                compatible_surface: Some(&surface),
                ..Default::default()
            })
            .await
            .unwrap();
        let device_descriptor = wgpu::DeviceDescriptor::default();
        let (device, queue) = adapter.request_device(&device_descriptor).await.unwrap();

        let size = window.inner_size();
        let width = size.width.max(1);
        let height = size.height.max(1);
        let texture_bind_group_layout =
            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
                entries: &[
                    wgpu::BindGroupLayoutEntry {
                        binding: 0,
                        visibility: wgpu::ShaderStages::FRAGMENT,
                        ty: wgpu::BindingType::Texture {
                            multisampled: false,
                            view_dimension: wgpu::TextureViewDimension::D2,
                            sample_type: wgpu::TextureSampleType::Float { filterable: true },
                        },
                        count: None,
                    },
                    wgpu::BindGroupLayoutEntry {
                        binding: 1,
                        visibility: wgpu::ShaderStages::FRAGMENT,
                        // This should match the filterable field of the
                        // corresponding Texture entry above.
                        ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
                        count: None,
                    },
                ],
                label: Some("texture_bind_group_layout"),
            });
        let camera_bind_group_layout =
            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
                entries: &[wgpu::BindGroupLayoutEntry {
                    binding: 0,
                    visibility: wgpu::ShaderStages::VERTEX,
                    ty: wgpu::BindingType::Buffer {
                        ty: wgpu::BufferBindingType::Uniform,
                        has_dynamic_offset: false,
                        min_binding_size: None,
                    },
                    count: None,
                }],
                label: Some("Camera Bind group layout"),
            });
        #[repr(align(4))]
        struct ShaderCode<const N: usize>([u8; N]);
        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
            label: Some("Pipeline Layout"),
            bind_group_layouts: &[&texture_bind_group_layout, &camera_bind_group_layout],
            push_constant_ranges: &[],
        });

        let vert_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
            label: Some("Vertex Shader"),
            source: unsafe {
                static SHADER_CODE: &[u8] =
                    &ShaderCode(*include_bytes!(concat!(env!("OUT_DIR"), "/vert.spv"))).0;
                // assert!(bytes.len() % 4 == 0);
                let shader = SHADER_CODE.align_to::<u32>().1;
                wgpu::ShaderSource::SpirV(std::borrow::Cow::Borrowed(shader))
            },
        });
        let frag_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
            label: Some("Fragment Shader"),
            source: unsafe {
                static SHADER_CODE: &[u8] =
                    &ShaderCode(*include_bytes!(concat!(env!("OUT_DIR"), "/frag.spv"))).0;
                debug_assert!(SHADER_CODE.len() % 4 == 0);
                let shader = SHADER_CODE.align_to::<u32>().1;
                wgpu::ShaderSource::SpirV(std::borrow::Cow::Borrowed(shader))
            },
        });
        let var_name = [Some(wgpu::ColorTargetState {
            format: surface.get_capabilities(&adapter).formats[0],
            blend: Some(wgpu::BlendState::ALPHA_BLENDING),
            write_mask: wgpu::ColorWrites::ALL,
        })];
        let pipeline_descriptor = wgpu::RenderPipelineDescriptor {
            label: Some("Main pipeline"),
            layout: Some(&pipeline_layout),
            vertex: wgpu::VertexState {
                module: &vert_shader,
                entry_point: Some("main"),
                buffers: &[Vertex::desc()],
                compilation_options: Default::default(),
            },
            primitive: wgpu::PrimitiveState {
                topology: wgpu::PrimitiveTopology::TriangleList,
                strip_index_format: None,
                front_face: wgpu::FrontFace::Ccw,
                cull_mode: Some(wgpu::Face::Back),
                polygon_mode: wgpu::PolygonMode::Fill,
                unclipped_depth: false,
                conservative: false,
            },
            depth_stencil: Some(wgpu::DepthStencilState {
                format: wgpu::TextureFormat::Depth32Float,
                depth_write_enabled: true,
                depth_compare: wgpu::CompareFunction::Less,
                stencil: wgpu::StencilState::default(),
                bias: wgpu::DepthBiasState::default(),
            }),
            multisample: wgpu::MultisampleState {
                count: 1,
                mask: !0,
                alpha_to_coverage_enabled: false,
            },
            fragment: Some(FragmentState {
                module: &frag_shader,
                entry_point: Some("main"),
                compilation_options: PipelineCompilationOptions::default(),
                targets: &var_name,
            }),
            multiview: None,
            cache: None,
        };
        // todo!();
        let surface_caps = surface.get_capabilities(&adapter);
        let present_mode = if surface_caps
            .present_modes
            .contains(&wgpu::PresentMode::Mailbox)
        {
            wgpu::PresentMode::Mailbox
        } else {
            wgpu::PresentMode::Fifo
        };
        let surface_config = wgpu::SurfaceConfiguration {
            width,
            height,
            format: surface_caps.formats[0],
            present_mode,
            alpha_mode: wgpu::CompositeAlphaMode::Auto,
            view_formats: vec![],
            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
            desired_maximum_frame_latency: 3,
        };

        surface.configure(&device, &surface_config);
        let pumpkin = tobj::load_obj("Pumpkin.obj", &tobj::GPU_LOAD_OPTIONS).unwrap();
        let (vertices, indices) = parse_obj(&pumpkin.0);
        let (depth_texture, depth_texture_view) =
            create_depth_texture(&device, surface_config.width, surface_config.height);
        let materials = pumpkin.1.unwrap();
        
        let diffuse_texture =
            texture::Texture::from_bytes(&device, &queue, ICON, "zenyx-icon").unwrap();
        let model = tobj::load_obj_buf(
            &mut PUMPKIN.as_bytes(),
            &LoadOptions {
                triangulate: true,
                single_index: true,
                ..Default::default()
            },
            |_| Ok(Default::default()),
        )
        .unwrap();

        let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
            label: Some("Vertex buffer"),
            contents: bytemuck::cast_slice(vertices.as_ref()),
            usage: BufferUsages::VERTEX,
        });
        let index_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
            label: Some("Index buffer"),
            contents: bytemuck::cast_slice(indices.as_ref()),
            usage: BufferUsages::INDEX,
        });

        let diffuse_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
            layout: &texture_bind_group_layout,
            entries: &[
                wgpu::BindGroupEntry {
                    binding: 0,
                    resource: wgpu::BindingResource::TextureView(&diffuse_texture.view),
                },
                wgpu::BindGroupEntry {
                    binding: 1,
                    resource: wgpu::BindingResource::Sampler(&diffuse_texture.sampler),
                },
            ],
            label: Some("diffuse_bind_group"),
        });
        let camera = camera::Camera {
            // position the camera 1 unit up and 2 units back
            // +z is out of the screen
            eye: (0.0, 0.0, 2.0).into(),
            // have it look at the origin
            target: (0.0, 0.0, 0.0).into(),
            // which way is "up"
            up: cgmath::Vector3::unit_y(),
            aspect: surface_config.width as f32 / surface_config.height as f32,
            fovy: 45.0,
            znear: 0.1,
            zfar: 1000.0,
        };

        let mut camera_uniform = camera::CameraUniform::default();
        camera_uniform.update_view_proj(&camera);

        let camera_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
            label: Some("Camera Buffer"),
            contents: bytemuck::cast_slice(&[camera_uniform]),
            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
        });

        let camera_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
            layout: &camera_bind_group_layout,
            entries: &[wgpu::BindGroupEntry {
                binding: 0,
                resource: camera_buffer.as_entire_binding(),
            }],
            label: Some("Camera Bind Group"),
        });

        let render_pipeline = device.create_render_pipeline(&pipeline_descriptor);

        WgpuRenderer {
            surface,
            surface_config,
            diffuse_bind_group,
            depth_texture,
            render_pipeline,
            device,
            vertex_buffer,
            index_buffer,
            camera,
            queue,
            camera_uniform,
            camera_buffer,
            camera_bind_group,
            index_count: indices.len() as u32,
            depth_texture_view,
        }
    }

}

fn create_depth_texture(
    device: &wgpu::Device,
    width: u32,
    height: u32,
) -> (wgpu::Texture, wgpu::TextureView) {
    let size = wgpu::Extent3d {
        width,
        height,
        depth_or_array_layers: 1,
    };

    let desc = wgpu::TextureDescriptor {
        label: Some("Depth Texture"),
        size,
        mip_level_count: 1,
        sample_count: 1,
        dimension: wgpu::TextureDimension::D2,
        format: wgpu::TextureFormat::Depth32Float,
        usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
        view_formats: &[],
    };

    let texture = device.create_texture(&desc);
    let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
    (texture, view)
}

static VERTICES: [Vertex; 4] = {
    [
        Vertex {
            position: cgmath::vec3(-0.5, -0.5, 0.0),
            color: cgmath::vec3(1.0, 0.0, 0.0),
            normal: cgmath::vec3(0.0, 0.0, 0.0),
            tex_coords: cgmath::vec2(1.0, 0.0),
        },
        Vertex {
            position: cgmath::vec3(0.5, -0.5, 0.0),
            color: cgmath::vec3(0.0, 1.0, 0.0),
            normal: cgmath::vec3(0.0, 0.0, 0.0),
            tex_coords: cgmath::vec2(0.0, 0.0),
        },
        Vertex {
            position: cgmath::vec3(0.5, 0.5, 0.0),
            color: cgmath::vec3(0.0, 0.0, 1.0),
            normal: cgmath::vec3(0.0, 0.0, 0.0),
            tex_coords: cgmath::vec2(0.0, 1.0),
        },
        Vertex {
            position: cgmath::vec3(-0.5, 0.5, 0.0),
            color: cgmath::vec3(0.0, 0.0, 1.0),
            normal: cgmath::vec3(0.0, 0.0, 0.0),
            tex_coords: cgmath::vec2(1.0, 1.0),
        },
    ]
};

static INDICIES: [u32; 6] = [0, 1, 2, 2, 3, 0];

impl ApplicationHandler for App<'_> {
    fn window_event(
        &mut self,
        event_loop: &winit::event_loop::ActiveEventLoop,
        window_id: WindowId,
        event: winit::event::WindowEvent,
    ) {
        match event {
            winit::event::WindowEvent::RedrawRequested => {
                let window_ctx = self.windows.get_mut(&window_id).unwrap();
                window_ctx.renderer.draw()
            }
            winit::event::WindowEvent::CloseRequested => {
                let _ = self.windows.remove(&window_id);
                if self.windows.is_empty() {
                    event_loop.exit();
                }
            }
            winit::event::WindowEvent::MouseInput { state, button, .. } => {
                if button == MouseButton::Left && state == ElementState::Pressed {
                    self.spawn_window(event_loop);
                }
            }
            winit::event::WindowEvent::Resized(size) => {
                if let Some(window_ctx) = self.windows.get_mut(&window_id) {
                    if size.width == 0 || size.height == 0 {
                        return;
                    }
                    window_ctx
                        .renderer
                        .camera
                        .update_aspect(size.width as f32 / size.height as f32);
                    window_ctx
                        .renderer
                        .camera_uniform
                        .update_view_proj(&window_ctx.renderer.camera);
                    window_ctx.renderer.queue.write_buffer(
                        &window_ctx.renderer.camera_buffer,
                        0,
                        bytes_of(&window_ctx.renderer.camera_uniform),
                    );
                    let mut new_config = window_ctx.renderer.surface_config.clone();
                    new_config.width = size.width;
                    new_config.height = size.height;
                    let (depth_texture, depth_view) = create_depth_texture(&window_ctx.renderer.device, size.width, size.height);
                    window_ctx.renderer.depth_texture = depth_texture;
                    window_ctx.renderer.depth_texture_view = depth_view;

                    window_ctx
                        .renderer
                        .surface
                        .configure(&window_ctx.renderer.device, &new_config)
                }
            }
            _ => (),
        }
    }

    fn resumed(&mut self, event_loop: &winit::event_loop::ActiveEventLoop) {
        let attr = WindowAttributes::default()
            .with_title("Zenyx")
            .with_min_inner_size(winit::dpi::LogicalSize::new(1, 1));

        if self.windows.is_empty() {
            let window = event_loop.create_window(attr).unwrap();
            let window = Arc::new(window);
            let renderer = self.state.create_renderer(window.clone());
            let window_ctx = WindowContext {
                renderer: smol::block_on(renderer),
                window: window.clone(),
            };
            let window_id = window.id();
            self.windows.insert(window_id, window_ctx);
        }
    }
    fn suspended(&mut self, _event_loop: &ActiveEventLoop) {
        self.windows.clear();
    }
}
pub fn main() -> Result<(), terminator::Terminator> {
    let config = LoggerConfig::default()
        .colored_stdout(true)
        .log_to_stdout(true)
        .file_include_time(true)
        .log_to_file(true)
        .level(LogLevel::Info)
        .log_path("zenyx.log");
    let _logger = zlog::Logger::new(config);
    #[cfg(not(target_os = "android"))]
    {
        _main()
    }
    #[cfg(target_os = "android")]
    {
        Ok(())
    }
}
pub fn run_app(event_loop: winit::event_loop::EventLoop<()>) -> Result<(), terminator::Terminator> {
    let mut app = App::new();
    event_loop.set_control_flow(winit::event_loop::ControlFlow::Poll);
    event_loop.run_app(&mut app)?;
    Ok(())
}

#[unsafe(no_mangle)]
#[cfg(target_os = "android")]
extern "C" fn android_main(app: AndroidApp) {
    use winit::event_loop::EventLoopBuilder;
    use winit::platform::android::EventLoopBuilderExtAndroid;
    let event_loop = EventLoopBuilder::default()
        .with_android_app(app)
        .build()
        .unwrap();
    run_app(event_loop).unwrap()
}

fn _main() -> Result<(), terminator::Terminator> {
    let event_loop = EventLoop::new()?;
    run_app(event_loop)?;
    info!("Exiting...");
    Ok(())
}