use bevy::pbr::OpaqueRendererMethod;
use bevy::prelude::*;
use bevy::pbr::ExtendedMaterial;
use bevy::pbr::MaterialExtension;
use bevy::pbr::MaterialMeshBundle;
use bevy::render::render_resource::*;

type MyMat = ExtendedMaterial<StandardMaterial, MatExt>;

fn main() {
	App::new()
		.add_plugins((
			DefaultPlugins.set(ImagePlugin::default_nearest()),
			MaterialPlugin::<MyMat>::default(),
		))
		.add_systems(Startup, setup)
		.add_systems(Update, rotate)
		.add_systems(Update, setup_material)
		.run();
}

fn setup(
	mut commands: Commands,
	assets: Res<AssetServer>,
) {
	commands.spawn(SceneBundle {
		scene: assets.load("models/Martian Chess.glb#Scene0"),
		..default()
	});

	commands.spawn(PointLightBundle { 
		point_light: PointLight {
			intensity: 10.0,
			..default()
		},
		transform: Transform::from_xyz(-1.0, 4.5, 4.0).looking_at(Vec3::ZERO, Vec3::Y),
		..default()
	});

	commands.spawn(Camera3dBundle {
		transform: Transform::from_xyz(-1.0, 1.5, 4.0).looking_at(Vec3::ZERO, Vec3::Y),
		..default()
	});
}

#[derive(Asset, AsBindGroup, Reflect, Debug, Clone)]
struct MatExt {
	#[uniform(100)]
	cutoff: f32,
}

impl MaterialExtension for MatExt {
	fn fragment_shader() -> ShaderRef {
		"examples/shaders/dissolve.wgsl".into()
	}
}

fn setup_material(
	events: Query<(Entity, &Handle<StandardMaterial>), Added<Handle<StandardMaterial>>>,
	standard_materials: Res<Assets<StandardMaterial>>,
	mut materials: ResMut<Assets<MyMat>>,
	mut commands: Commands,
) {
	events.iter().for_each(|(entity, handle)| {
		// Extension we will add to existing gltf-sourced materials
		let extension = MatExt { cutoff: 1.0 };
		// Base material we will extend for the duration of the dissolve effect
		let mut base = standard_materials.get(handle).expect("Resolve material data").clone();

		base.opaque_render_method = OpaqueRendererMethod::Auto;
		base.alpha_mode = AlphaMode::Mask(0.5);

		commands.entity(entity).insert(
			materials.add(ExtendedMaterial {
				base,
				extension,
			})
		).remove::<Handle<StandardMaterial>>();
	})
}

fn rotate(
	mut query: Query<&mut Transform, With<Handle<Mesh>>>,
	time: Res<Time>,
	mut materials: ResMut<Assets<MyMat>>,
) {
	query.iter_mut().for_each(|mut t| {
		t.rotate_local_y(time.delta_seconds() / 2.0);
		// t.rotate_local_z(time.delta_seconds() / 2.0);
		// t.rotate_local_x(time.delta_seconds() / 2.0);
	});
	materials.iter_mut().for_each(|(_id, m)| {
		m.extension.cutoff = time.elapsed_seconds().sin().abs();
	})
}