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

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

impl Default for Randr {
	fn default() -> Self {
		Self {
			color: wgpu::Color::BLUE,
			clear_color: wgpu::Color::BLACK,
			render_pipeline: None,
		}
	}
}

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.as_ref().unwrap());
		rpass.draw(0..3, 0..1);

		drop(rpass);

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

	fn init(&mut self, _window: &winit::window::Window, wgpu: &Wgpu, swapchain_formats: TextureFormat) -> anyhow::Result<()> {
		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,
		});
		self.render_pipeline = Some(render_pipeline);
		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) {}

}

#[test]
fn hello_triangle() {
	tracing_subscriber::fmt().with_max_level(tracing::Level::TRACE).init();
	tokio::runtime::Builder::new_current_thread()
		.enable_all()
		.build()
		.unwrap()
		.block_on(async {
			let event_loop = EventLoopBuilder::new().with_wayland().with_any_thread(true).build().unwrap();
			App::new(Randr::default(), &event_loop, AppDI::default()).await.run(event_loop).unwrap();
		});
}