use std::error::Error;

use glam::uvec2;
use winit::{
	event::{Event, WindowEvent},
	event_loop::EventLoop,
	window::{Window, WindowAttributes},
};

struct GameState {
	last: wgpu::TextureView,
	next: wgpu::TextureView,
}

fn main() {
	let event_loop = EventLoop::new().unwrap();

	#[allow(deprecated)]
	let window = &event_loop
		.create_window(WindowAttributes::new().with_title("GPU life game test"))
		.unwrap();

	let (device, queue, surface) = pollster::block_on(init_gpu(window)).unwrap();
	let format = wgpu::TextureFormat::Bgra8UnormSrgb;

	let fill_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
		label: Some("fill"),
		source: wgpu::ShaderSource::Wgsl(include_str!("fill.wgsl").into()),
	});
	let fill_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
		label: None,
		layout: None,
		vertex: wgpu::VertexState {
			module: &fill_shader,
			entry_point: None,
			compilation_options: wgpu::PipelineCompilationOptions::default(),
			buffers: &[],
		},
		primitive: wgpu::PrimitiveState {
			topology: wgpu::PrimitiveTopology::TriangleStrip,
			..Default::default()
		},
		depth_stencil: None,
		multisample: wgpu::MultisampleState::default(),
		fragment: Some(wgpu::FragmentState {
			module: &fill_shader,
			entry_point: None,
			compilation_options: wgpu::PipelineCompilationOptions::default(),
			targets: &[Some(wgpu::ColorTargetState {
				format: wgpu::TextureFormat::Rgba8Uint,
				blend: None,
				write_mask: wgpu::ColorWrites::ALL,
			})],
		}),
		multiview: None,
		cache: None,
	});

	let step_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
		label: Some("step"),
		source: wgpu::ShaderSource::Wgsl(include_str!("step.wgsl").into()),
	});
	let step_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
		label: None,
		layout: None,
		vertex: wgpu::VertexState {
			module: &step_shader,
			entry_point: None,
			compilation_options: wgpu::PipelineCompilationOptions::default(),
			buffers: &[],
		},
		primitive: wgpu::PrimitiveState {
			topology: wgpu::PrimitiveTopology::TriangleStrip,
			..Default::default()
		},
		depth_stencil: None,
		multisample: wgpu::MultisampleState::default(),
		fragment: Some(wgpu::FragmentState {
			module: &step_shader,
			entry_point: None,
			compilation_options: wgpu::PipelineCompilationOptions::default(),
			targets: &[Some(wgpu::ColorTargetState {
				format: wgpu::TextureFormat::Rgba8Uint,
				blend: None,
				write_mask: wgpu::ColorWrites::ALL,
			})],
		}),
		multiview: None,
		cache: None,
	});

	let present_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
		label: Some("present"),
		source: wgpu::ShaderSource::Wgsl(include_str!("present.wgsl").into()),
	});
	let present_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
		label: None,
		layout: None,
		vertex: wgpu::VertexState {
			module: &present_shader,
			entry_point: None,
			compilation_options: wgpu::PipelineCompilationOptions::default(),
			buffers: &[],
		},
		primitive: wgpu::PrimitiveState {
			topology: wgpu::PrimitiveTopology::TriangleStrip,
			..Default::default()
		},
		depth_stencil: None,
		multisample: wgpu::MultisampleState::default(),
		fragment: Some(wgpu::FragmentState {
			module: &present_shader,
			entry_point: None,
			compilation_options: wgpu::PipelineCompilationOptions::default(),
			targets: &[Some(wgpu::ColorTargetState {
				format,
				blend: None,
				write_mask: wgpu::ColorWrites::ALL,
			})],
		}),
		multiview: None,
		cache: None,
	});

	let mut state = None;
	#[allow(deprecated)]
	event_loop
		.run(move |event, control_flow| match event {
			Event::WindowEvent { ref event, window_id } if window_id == window.id() => match event {
				WindowEvent::CloseRequested => control_flow.exit(),
				WindowEvent::Resized(physical_size) => {
					let size = uvec2(physical_size.width, physical_size.height);
					surface.configure(
						&device,
						&wgpu::SurfaceConfiguration {
							usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_DST,
							format,
							width: size.x,
							height: size.y,
							present_mode: wgpu::PresentMode::Fifo,
							alpha_mode: wgpu::CompositeAlphaMode::Auto,
							view_formats: vec![],
							desired_maximum_frame_latency: 2,
						},
					);
					let [last, next] = [(), ()].map(|_| {
						device
							.create_texture(&wgpu::TextureDescriptor {
								label: None,
								size: wgpu::Extent3d {
									width: size.x,
									height: size.y,
									depth_or_array_layers: 1,
								},
								mip_level_count: 1,
								sample_count: 1,
								dimension: wgpu::TextureDimension::D2,
								format: wgpu::TextureFormat::Rgba8Uint,
								usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
								view_formats: &[],
							})
							.create_view(&Default::default())
					});

					let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
					let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
						label: None,
						color_attachments: &[Some(wgpu::RenderPassColorAttachment {
							view: &last,
							resolve_target: None,
							ops: wgpu::Operations {
								load: wgpu::LoadOp::Clear(wgpu::Color::BLUE),
								store: wgpu::StoreOp::Store,
							},
						})],
						depth_stencil_attachment: None,
						occlusion_query_set: None,
						timestamp_writes: None,
					});
					render_pass.set_pipeline(&fill_pipeline);
					render_pass.draw(0..4, 0..1);
					drop(render_pass);
					queue.submit(std::iter::once(encoder.finish()));

					state = Some(GameState { last, next });
				}
				WindowEvent::RedrawRequested => {
					let Some(state) = &mut state else {
						return;
					};
					let output = surface.get_current_texture().unwrap();
					let view = output.texture.create_view(&wgpu::TextureViewDescriptor::default());
					let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });

					let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
						label: None,
						color_attachments: &[Some(wgpu::RenderPassColorAttachment {
							view: &view,
							resolve_target: None,
							ops: wgpu::Operations {
								load: wgpu::LoadOp::Clear(wgpu::Color::BLUE),
								store: wgpu::StoreOp::Store,
							},
						})],
						depth_stencil_attachment: None,
						occlusion_query_set: None,
						timestamp_writes: None,
					});
					render_pass.set_pipeline(&present_pipeline);
					render_pass.set_bind_group(
						0,
						&device.create_bind_group(&wgpu::BindGroupDescriptor {
							label: None,
							layout: &present_pipeline.get_bind_group_layout(0),
							entries: &[wgpu::BindGroupEntry {
								binding: 0,
								resource: wgpu::BindingResource::TextureView(&state.last),
							}],
						}),
						&[],
					);
					render_pass.draw(0..4, 0..1);
					drop(render_pass);

					let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
						label: None,
						color_attachments: &[Some(wgpu::RenderPassColorAttachment {
							view: &state.next,
							resolve_target: None,
							ops: wgpu::Operations {
								load: wgpu::LoadOp::Clear(wgpu::Color::BLUE),
								store: wgpu::StoreOp::Store,
							},
						})],
						depth_stencil_attachment: None,
						occlusion_query_set: None,
						timestamp_writes: None,
					});
					render_pass.set_pipeline(&step_pipeline);
					render_pass.set_bind_group(
						0,
						&device.create_bind_group(&wgpu::BindGroupDescriptor {
							label: None,
							layout: &step_pipeline.get_bind_group_layout(0),
							entries: &[wgpu::BindGroupEntry {
								binding: 0,
								resource: wgpu::BindingResource::TextureView(&state.last),
							}],
						}),
						&[],
					);
					render_pass.draw(0..4, 0..1);
					drop(render_pass);

					queue.submit(std::iter::once(encoder.finish()));
					output.present();

					std::mem::swap(&mut state.last, &mut state.next);
					window.request_redraw();
				}
				_ => {}
			},
			_ => {}
		})
		.unwrap();
}

async fn init_gpu(wnd: &Window) -> Result<(wgpu::Device, wgpu::Queue, wgpu::Surface), Box<dyn Error>> {
	let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
		backends: wgpu::Backends::PRIMARY,
		..Default::default()
	});
	let surface = instance.create_surface(wnd)?;
	let adapter = instance
		.request_adapter(&wgpu::RequestAdapterOptions {
			power_preference: wgpu::PowerPreference::default(),
			compatible_surface: Some(&surface),
			force_fallback_adapter: false,
		})
		.await
		.unwrap();
	let (device, queue) = adapter
		.request_device(
			&wgpu::DeviceDescriptor {
				label: None,
				required_features: wgpu::Features::empty(),
				required_limits: wgpu::Limits::default(),
				memory_hints: Default::default(),
			},
			None,
		)
		.await
		.unwrap();
	Ok((device, queue, surface))
}