use randr::{Renderer, App, Wgpu, AppDI};
use wgpu::{include_wgsl, TextureFormat};
use winit::{event_loop::{EventLoop, EventLoopBuilder}, platform::wayland::EventLoopBuilderExtWayland, window};

struct Randr {
	color: wgpu::Color,
	clear_color: wgpu::Color,
	render_pipeline: wgpu::RenderPipeline,
}

impl Randr {
	pub fn new(render_pipeline: wgpu::RenderPipeline) -> Self {
		Self {
			color: wgpu::Color::BLUE,
			clear_color: wgpu::Color::BLACK,
			render_pipeline,
		}
	}
}

impl Renderer for Randr {
	fn render(&mut self, wgpu: &Wgpu) -> Result<(), wgpu::SurfaceError> {
		let frame = wgpu.surface.get_current_texture()?;
		let view = frame.texture.create_view(&wgpu::TextureViewDescriptor::default());
		let mut encoder = wgpu.device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
		let mut rpass = 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(self.clear_color),
					store: wgpu::StoreOp::Store,
				},
			})],
			depth_stencil_attachment: None,
			timestamp_writes: None,
			occlusion_query_set: None,
		});

		rpass.set_pipeline(&self.render_pipeline);
		rpass.draw(0..3, 0..1);

		drop(rpass);

		wgpu.queue.submit(Some(encoder.finish()));
		frame.present();
		Ok(())
	}


	fn resize(&mut self, _size: winit::dpi::PhysicalSize<u32>) {}

	fn input(&mut self, _input: &winit_input_helper::WinitInputHelper) {}

	fn update(&mut self, _wgpu: &Wgpu) {}

}

#[tokio::test]
async fn hello_triangle() {
	let renderer = |window: &window::Window, wgpu: &Wgpu, swapchain_formats: TextureFormat| {
		let shader = wgpu.device.create_shader_module(include_wgsl!("shader.wgsl"));

		let pipeline_layout  = wgpu.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
			label: None,
			bind_group_layouts: &[],
			push_constant_ranges: &[],
		});

		let render_pipeline = wgpu.device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
			label: None,
			layout: Some(&pipeline_layout),
			vertex: wgpu::VertexState {
				module: &shader,
				entry_point: "vs_main",
				buffers: &[],
			},
			fragment: Some(wgpu::FragmentState {
				module: &shader,
				entry_point: "fs_main",
				targets: &[Some(swapchain_formats.into())],
			}),
			primitive: wgpu::PrimitiveState::default(),
			depth_stencil: None,
			multisample: wgpu::MultisampleState::default(),
			multiview: None,
		});
		Randr::new(render_pipeline)
	};

	let event_loop = EventLoopBuilder::new().with_wayland().with_any_thread(true).build().unwrap();
	App::new(renderer, &event_loop, AppDI::default()).await.run(event_loop).unwrap();
}