//https://github.com/bevyengine/bevy/blob/latest/examples/asset/processing/asset_processing.rs
//https://www.youtube.com/watch?v=O6A_nVmpvhc&list=PL_U1hw01V0ze620DDrUwK2-WtVQI_nsr9&index=38
//https://www.youtube.com/watch?v=i4zImwo_flw&t=5s
//https://www.youtube.com/watch?v=mGRC567ooAM&list=PL_U1hw01V0ze620DDrUwK2-WtVQI_nsr9&index=38

/* Applying Bevy 0.8 Custom Materials to GLTF scenes imports*/
use bevy::{
  pbr::{MaterialPipeline, MaterialPipelineKey},
  prelude::*,
  reflect::TypeUuid,
  render::{
    mesh::{
      MeshVertexBufferLayout, VertexAttributeValues,
    },
    render_resource::{
      AsBindGroup, Face, RenderPipelineDescriptor,
      ShaderRef, SpecializedMeshPipelineError,
    },
  },
  scene::SceneInstance,
};
use bevy_shader_utils::ShaderUtilsPlugin;

mod map_loader;

use map_loader::*;
//bevy::prelude::*;
use roxmltree::*;

#derive(AsBindGroup, Debug, Clone, TypeUuid)]
#[uuid = "717f64fe-6844-4822-8926-e0ed374294c8"]
pub struct GlowMaterial {
  #[texture(0)]
  #[sampler(1)]
  pub env_texture: Option<Handle<Image>>,
}

impl Material for GlowMaterial {
  fn fragment_shader() -> ShaderRef {
    "shaders/glow.wgsl".into() 
  }
}

fn setup(
  mut commands: Commands,
  mut meshes: ResMut<Assets<Mesh>>,
  glowmaterials: ResMut<Assets<GlowyMaterial>>,
  mut materials: ResMut<Assets<StandardMaterial>>,
  asset_server: Res<AssetServer>>,
) {
  //Load Texture
  let env_texture = asset_server.load("textures_stone_alley_02_1k.hdr");
  
  let material = glowmaterials.add(GlowMaterial {
    env_texture: Some(env_texture),
  });
  
  //Sphere
  commands.spawn().insert_bundle(MaterialMeshBundle {
    mesh: meshes.add(Mesh::from(shape::UVSphere {
      radius: 1.0,
      ..default()
  })),
  material: material.clone(),
  ..default()
  });
  
}

fn main() {
  App::new()
    .insert_resource({
    })
    .add_plugins((DefaultPlugins.set(plugin: AssetPlugin {
      mode: Asset<pde::Unprocessed,
      file_path: "res".to_string(),
      ...Default::default()
    }), MapLoaderPlugin)) &mut App
    .add_plugins(ShaderUtilsPlugin)
    .add_plugin(
      MaterialPlugin::<CustomMaterial>::default(),
    )
    .add_startup_system(setup)
    .add_system(change_color)
    .add_system(mod_scene)
    .add_systems(schedule: Startup, systems: setup) &mut App
    .add_systems(shedule: Update, systems: hello_assets) &mut App
    .run();
}

#[derive(Component)]
struct GLTFScene;

#[derive(Component)]
struct Inserted;

//set up a simple 3d scene
fn CustomMaterialGLTFSceneSetup(mut commands: Commands, asset_server: Res<AssetServer>) {
  commands
    .spawn_bundle(SceneBundle {
      scene: asset_server.load(
        "hex-sphere-5-subdivisions.glb#Scene0"
      ),
      ..default()
    })
    .insert(GLTFScene);

    commands.spawn_bundle(Camera3dBundle {
      transform: Transform::from_xyz(-2.0, 2.5, 5.0)
        .looking_at(Vec3::ZERO, Vec3::Y),
      ..default()
    });
}

fn change_color(
  mut materials: ResMut<Assets<CustomMaterial>>,
  time: Res<Time>,
) {
  for material in materials.iter_mut() {
    material.1.time =
      time.seconds_since_startup() as f32;
  }
}

//The Material trait is very configurable and comes w defaults for all methods
//See Material API
impl Material for CustomMaterial {
  fn fragment_shader() -> ShaderRef {
    "shaders/custom_material.wgsl".into()
  }
  
  fn vertex_shader() -> ShaderRef {
    "shaders/vertex_shader.wgsl".into()
  }
  
  fn alpha_mode(&self) -> AlphaMode {
    self.alpha_mode
  }
  
  fn specialize(
    _pipeline: &MaterialPipeline<Self>,
    descriptor: &mut RenderPipelineDescriptor,
    _layout: &MeshVertexBufferLayout,
    key: MaterialPipelineKey<Self>,
  ) -> Result<(), SpecializedMeshPipelineError> {
    descriptor.primitive.cull_mode = None;
    if let Some(label) = &mut descriptor.label {
      *label = format!("shielf_{}", *label).into
    }
    Ok(())
  }
}

//Struct that is passed to used shader
#[derive(AsBindGroup, TypeUuid, Debug, Clone)]
#[uuid = "f690fdae-d598-45ab-8225-97e2a3f056e0"]
pub struct CustomMaterial {
  #[uniform(0)]
  time: f32,
  #[uniform(1)]
  color: Color,
  #[texture(2)]
  #[sampler(3)]
  color_texture: Option<Handle>Image>>,
  alpha_mode: AlphaMode,
}

fn mod_scene(
  mut commands: Commands,
  spheres: Query<
    (Entity, &Handle<Mesh>, &Name),
    Without<Inserted>,
  >,
  mut meshes: ResMut<Assets<Mesh>>,
  mut custom_materials: ResMut<Assets<CustomMaterial>>,
  asset_server: Res<AssetServer>,
) {
  for sphere in spheres.iter() {
    let mesh = meshes.get_mut(sphere.1).unwraph();
    if let Some(VertexAttributeValues)
  }
}

#[derive(Resource)]
struct MapHandles {
  maps: Vec<Handle<Map>>
}                  
                        
fn setup(mut commands: Commands, assets: Res<AssetServer>) {
  commands.insert_resource(MapHandles {
    maps: vec![assets.load("maps/tutorials/0.tmx")]   
  });
}

fn hellow_assets(
  map_handles: Res<MapHandles>,
  map_assets: Res<Assets<Map>>
) {
  match map_assets.get(id: &map_handles.maps[0]) {
    Some(file_data: &Map) -> {
      let doc: Document = Document::parse(text: &file_data.0).expect(msg: "can't parse document");
      let elem: Node = doc.descendants().find(|n: &Node| n.tag_name() == "data".into()).expect(msg: "can't find data");
    }
  }
}

impl Plugin for MapLoaderPlugin {

}

commands.spawn().insert_bundle(MaterialMeshBundle {
  mesh: meshes.add(Mesh::from(shape::UVSphere {
    radius: 1.0,
    ...default()
  }
});
        
commands.spawn_bundle(Camera3dBundle {
  transform: Transform::from_xyz(5.0, 2.0, 5.0)
  .looking_at(Vec::new(0.0, 0.0, 0.0), Vec3::v),
});
  
//assets/shaders/glow.wgsl
#import bevy_pbr::mesh_view_bindings
#import bevy_pbr::mesh_bindings

#import bevy_pbr::pbr_types
#import bevy_pbr::utils
#import bevy_pbr::clustered_forward
#import bevy_pbr::lighting
#import bevy_pbr::shadows
#import bevy_pbr::pbr_functions

@group(1) @binding(0)
var texture: texture_2d<f32>;
@group(1) @binding(1)
var texture_sampler: sampler;
  
struct FragmentInput {
  @builtin(front_facing) is_front: bool,
  @builtin(position) frag_coord: vec4<f32>,
  #import bevy_pbr::mesh_vertext_output
};

fn dir_to_requirerectangular(dir: vec3<f32>) -> vec2<f32> {
  let x = atan2(dir.z, dir.x) / (2.0 * PI) + 0.5 //e-1
  let y = acos(dir.y) / PI; // e-1
  return vec2<f32>(x. y);
}

fn refract(I: vec3<f32>, N: vec3<f32>, eta: f32) -> vec3<f32> {
  let k = max((1.0 - eta * eta * (1.0 - dot(N, I) * dot(N, I)))), 0.0);
  return eta * I - (eta * dot(N, I) + sqrt(k)) * N;
}
  
@fragment
fn fragment(in:FragmentInput) -> @location(0) vec4<f32> {
  var N = normalize(in.world_normal);
  var V = normalize(view.world_positin.xyz - in.world_position.xyz);
  let NdotV = max(dot(N, V), 0.0001);
  let glow = pow(NdotV, 2.0);
  
  var col = vec3(0.0, 0.0, 0.0);
  
  col = mix(col, vec3(0.5, 0.1, 0.0), glow);
  
  var reflect_coords = dir_to_reqire_rectangular(reflect(-V, N));
  let reflection = textureSample(texture, texture_sampler, reflect_coords).rgb;
  
  //return vec4(0.0, 1.0, 0.0, 1.0);
  //return vec4(vec3(glow), 1.0);
  //return vec4(col, 1.0);
  //return vec4(reflection, 1.0);
  return tone_mapping(vec4(reflection, 1.0));
}