use anyhow::Result;
use glyphon::Resolution;
use std::iter;

use super::RenderScene;
use crate::vertexbuffer::consts::SPRITE_INDICES;

pub struct LandedScene {}

impl RenderScene for LandedScene {
	fn render(g: &mut crate::GPUState, input: &crate::RenderInput) -> Result<()> {
		let output = g.surface.get_current_texture()?;
		let view = output.texture.create_view(&Default::default());

		let mut encoder = g
			.device
			.create_command_encoder(&wgpu::CommandEncoderDescriptor {
				label: Some("render encoder"),
			});

		let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
			label: Some("render pass"),

			color_attachments: &[Some(wgpu::RenderPassColorAttachment {
				view: &view,
				resolve_target: None,
				ops: wgpu::Operations {
					load: wgpu::LoadOp::Clear(wgpu::Color {
						r: 0.0,
						g: 0.0,
						b: 0.0,
						a: 1.0,
					}),
					store: wgpu::StoreOp::Store,
				},
			})],
			depth_stencil_attachment: None,
			occlusion_query_set: None,
			timestamp_writes: None,
		});

		// Create sprite instances
		g.ui.draw(&input, &mut g.state)?;

		// These should match the indices in each shader,
		// and should each have a corresponding bind group layout.
		render_pass.set_bind_group(0, &g.texture_array.bind_group, &[]);
		render_pass.set_bind_group(1, &g.state.global_uniform.bind_group, &[]);

		// Starfield pipeline
		g.state
			.vertex_buffers
			.get_starfield()
			.set_in_pass(&mut render_pass);
		render_pass.set_pipeline(&g.starfield_pipeline);
		render_pass.draw_indexed(
			0..SPRITE_INDICES.len() as u32,
			0,
			0..g.state.get_starfield_counter(),
		);

		// Ui pipeline
		g.state
			.vertex_buffers
			.get_ui()
			.set_in_pass(&mut render_pass);
		render_pass.set_pipeline(&g.ui_pipeline);
		render_pass.draw_indexed(
			0..SPRITE_INDICES.len() as u32,
			0,
			0..g.state.get_ui_counter(),
		);

		// Radial progress bars
		g.state
			.vertex_buffers
			.get_radialbar()
			.set_in_pass(&mut render_pass);
		render_pass.set_pipeline(&g.radialbar_pipeline);
		render_pass.draw_indexed(
			0..SPRITE_INDICES.len() as u32,
			0,
			0..g.state.get_radialbar_counter(),
		);

		let textareas = g.ui.get_textareas(input, &g.state);
		g.state
			.text_renderer
			.prepare(
				&g.device,
				&g.state.queue,
				&mut g.state.text_font_system,
				&mut g.state.text_atlas,
				Resolution {
					width: g.state.window_size.width,
					height: g.state.window_size.height,
				},
				textareas,
				&mut g.state.text_cache,
			)
			.unwrap();

		g.state
			.text_renderer
			.render(&g.state.text_atlas, &mut render_pass)
			.unwrap();

		// begin_render_pass borrows encoder mutably,
		// so we need to drop it before calling finish.
		drop(render_pass);

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

		return Ok(());
	}
}