use bevy::{prelude::*, utils::Duration};

pub struct Particle {
    pub lifetime: f32,
}

pub struct ParticleLinearSizeOverTime {
    pub change: f32,
}

#[derive(Bundle)]
pub struct ParticleBundle {
    p: Particle,
    t: Transform,
    #[bundle]
    s: SpriteBundle,
}

#[derive(Default)]
pub struct ParticleMaterial(pub Handle<ColorMaterial>);

struct Emitter {
    frequency: f32,
    creation_function: FnOnce() -> ParticleBundle,
}

struct WorkingEmitter {
    time_of_start: f32,
    particle_counter: u32,
}

fn particle_lifetime_update(
    mut commands: Commands,
    mut particles: Query<(Entity, &mut Particle)>,
    time: Res<Time>,
) {
    for (entity, mut particle) in particles.iter_mut() {
        particle.lifetime -= time.delta_seconds();
        if particle.lifetime < 0.0 {
            commands.entity(entity).despawn();
        }
    }
}

fn particle_linear_size_over_time_update(
    mut particles: Query<(&mut ParticleLinearSizeOverTime, &mut Transform)>,
    time: Res<Time>,
) {
    for (mut particle, mut transform) in particles.iter_mut() {
        if transform.scale.x > 0.0 {
            transform.scale.x -= particle.change * time.delta_seconds();
        }
        if transform.scale.y > 0.0 {
            transform.scale.y -= particle.change * time.delta_seconds();
        }
    }
}

fn emit(mut commands: Commands, emitters: Query<(&Emitter, &WorkingEmitter)>, time: Res<Time>) {}

fn particle_startup(
    mut materials: ResMut<Assets<ColorMaterial>>,
    server: Res<AssetServer>,
    mut particle_mat: ResMut<ParticleMaterial>,
) {
    let texture = server.load("particle2.png");

    let particle_material = bevy::prelude::ColorMaterial {
        texture: Some(texture),
        ..Default::default()
    };

    particle_mat.0 = materials.add(particle_material);
}

pub struct ParticlePlugin;

impl Plugin for ParticlePlugin {
    fn build(&self, app: &mut AppBuilder) {
        app.init_resource::<ParticleMaterial>()
            .add_startup_system(particle_startup.system())
            .add_system(particle_lifetime_update.system())
            .add_system(particle_linear_size_over_time_update.system());
    }
}