moveable.velocity = Vec2::ZERO;

                moveable.velocity *= 0.1;

use crate::movement;

use crate::{movement, utils::lerp_mix};

/// alpha is clamped to [0.0, 1.0]
fn lerp_mix(a: Color, b: Color, alpha: f32) -> Color {
    use palette::{
        blend::{BlendWith, PreAlpha},
        LinSrgb, Srgba,
    };
    type PreRgba = PreAlpha<LinSrgb<f32>>;
    let alpha = alpha.clamp(0.0, 1.0);
    let a_rgb = Srgba::from(a.as_rgba_f32()).into_linear();
    let b_rgb = Srgba::from(b.as_rgba_f32()).into_linear();
    let mixed = a_rgb.blend_with(b_rgb, |a: PreRgba, b: PreRgba| {
        // lerp em colors togethter
        PreAlpha {
            color: LinSrgb::new(
                a.red + (b.red - a.red) * alpha,
                a.green + (b.green - a.green) * alpha,
                a.blue + (b.blue - a.blue) * alpha,
            ),
            alpha: a.alpha + (b.alpha - a.alpha) * alpha,
        }
    });
    Color::rgba(mixed.red, mixed.green, mixed.blue, mixed.alpha)
}

#[derive(Component)]

#[derive(Component, Debug)]

pub const MIN_SPEED: f32 = 0.5;

pub const MIN_SPEED: f32 = 20.0;

/// Minimum acceleration to respect
pub const MIN_ACCEL: f32 = 5.0;

    const MU: f32 = 0.75;
    const MU_STATIC: f32 = 1.0;
    const GRAVITY: f32 = 10.;

    const FAKE_MU: f32 = 30.0;
    const FAKE_MU_STATIC: f32 = 45.0;

        let speed = movable.velocity.length();
        if let Some(vnorm) = movable.velocity.try_normalize() {

        // info!(?movable);
        if movable.velocity.length() > MIN_SPEED {
            let vnorm = movable.velocity.normalize();
            // Friction = mu * N where N is the normal force
            // we assume the only normal force is gravity.
            // so friction in our system is
            // mu * mass * gravity
            let mass = movable.mass;
            let friction_magnitude = FAKE_MU * mass.max(1.0).recip();
            movable.velocity -= vnorm * friction_magnitude;
        } else {
            let vnorm = movable.velocity.normalize_or_zero();

            let friction_magnitude =
                if speed <= MIN_SPEED { MU_STATIC } else { MU } * mass.max(1.0) * GRAVITY;
            movable.acceleration += -vnorm * friction_magnitude;

            let friction_magnitude = FAKE_MU_STATIC * mass.max(1.0).recip();
            movable.velocity -= vnorm * friction_magnitude;

        if movable.velocity.length() > MIN_SPEED || acceleration.length() > MIN_ACCEL {
            movable.velocity += acceleration * time.delta_seconds();

        if movable.velocity.length() < MIN_SPEED {
            movable.velocity = Vec2::ZERO;

        // Reset accel

        movable.velocity += acceleration * time.delta_seconds();
        // Zero accel

}
pub(crate) mod utils {
    use bevy::prelude::Color;
    /// alpha is clamped to [0.0, 1.0]
    pub fn lerp_mix(a: Color, b: Color, alpha: f32) -> Color {
        use palette::{
            blend::{BlendWith, PreAlpha},
            LinSrgb, Srgba,
        };
        type PreRgba = PreAlpha<LinSrgb<f32>>;
        let alpha = alpha.clamp(0.0, 1.0);
        let a_rgb = Srgba::from(a.as_rgba_f32()).into_linear();
        let b_rgb = Srgba::from(b.as_rgba_f32()).into_linear();
        let mixed = a_rgb.blend_with(b_rgb, |a: PreRgba, b: PreRgba| {
            // lerp em colors togethter
            PreAlpha {
                color: LinSrgb::new(
                    a.red + (b.red - a.red) * alpha,
                    a.green + (b.green - a.green) * alpha,
                    a.blue + (b.blue - a.blue) * alpha,
                ),
                alpha: a.alpha + (b.alpha - a.alpha) * alpha,
            }
        });
        Color::rgba(mixed.red, mixed.green, mixed.blue, mixed.alpha)
    }

use crate::utils::lerp_mix;

const MIN_BOX_MASS: f32 = 5.0;
const MAX_BOX_MASS: f32 = 100.0;

    const LIGHT_COLOR: Color = Color::TURQUOISE;
    const HEAVY_COLOR: Color = Color::PURPLE;

                material: materials.add(Color::TURQUOISE),

                material: materials.add(lerp_mix(
                    LIGHT_COLOR,
                    HEAVY_COLOR,
                    (box_trigger.mass - MIN_BOX_MASS) / MAX_BOX_MASS,
                )),

            ui.add(egui::Slider::new(&mut *box_mass, 5.0..=100.0).text("Mass"));

            ui.add(egui::Slider::new(&mut *box_mass, MIN_BOX_MASS..=MAX_BOX_MASS).text("Mass"));

            const IMPULSE: f32 = 5_000.0;

            const IMPULSE: f32 = 2200.0;

(
    meta_format_version: "1.0",
    asset: Load(
        loader: "bevy_ecs_ldtk::assets::ldtk_project::LdtkProjectLoader",
        settings: (),
    ),
)

(
    meta_format_version: "1.0",
    asset: Load(
        loader: "bevy_render::render_resource::shader::ShaderLoader",
        settings: (),
    ),
)

(
    meta_format_version: "1.0",
    asset: Load(
        loader: "bevy_render::texture::image_loader::ImageLoader",
        settings: (
            format: FromExtension,
            is_srgb: true,
            sampler: Default,
            asset_usage: ("MAIN_WORLD | RENDER_WORLD"),
        ),
    ),
)

(
    meta_format_version: "1.0",
    asset: Ignore,
)

(
    meta_format_version: "1.0",
    asset: Load(
        loader: "bevy_render::texture::image_loader::ImageLoader",
        settings: (
            format: FromExtension,
            is_srgb: true,
            sampler: Default,
            asset_usage: ("MAIN_WORLD | RENDER_WORLD"),
        ),
    ),
)

(
    meta_format_version: "1.0",
    asset: Ignore,
)

(
    meta_format_version: "1.0",
    asset: Load(
        loader: "bevy_render::texture::image_loader::ImageLoader",
        settings: (
            format: FromExtension,
            is_srgb: true,
            sampler: Default,
            asset_usage: ("MAIN_WORLD | RENDER_WORLD"),
        ),
    ),
)

(
    meta_format_version: "1.0",
    asset: Ignore,
)