use bevy::core_pipeline::tonemapping::Tonemapping;
use bevy::ecs::component::ComponentId;
use bevy::ecs::world::DeferredWorld;
use bevy::math::*;
use bevy::prelude::*;
use bevy::render::view::ColorGrading;
use bevy_flycam::prelude::*;
use bevy_trenchbroom::prelude::*;

#[derive(SolidClass, Component, Reflect)]
#[reflect(Component)]
#[geometry(GeometryProvider::new().smooth_by_default_angle().render())]
pub struct Worldspawn;

#[derive(SolidClass, Component, Reflect, Default)]
#[reflect(Component)]
#[geometry(GeometryProvider::new().smooth_by_default_angle().render())]
pub struct MyBaseClass {
    /// MY AWESOME VALUE!!
    pub my_value: u32,
}

#[derive(Resource, Reflect, Debug)]
#[reflect(Resource)]
struct DebugVisuals {
    pub unlit: bool,
    pub tonemapping: Tonemapping,
    pub exposure: f32,
    pub shadows: bool,
}

#[derive(PointClass, Component, Reflect, Default)]
#[reflect(Component)]
#[require(Transform)]
#[component(on_add = Self::on_add)]
#[model({ "path": "models/spawn.glb", "scale": scale })]
pub struct SpawnPoint {
    scale: f32,
}

impl SpawnPoint {
    fn on_add(mut world: DeferredWorld, entity: Entity, _id: ComponentId) {
        let Some(asset_server) = world.get_resource::<AssetServer>() else {
            return;
        };

        // let scale = world.entity(entity).get::<Self>().unwrap().scale;

        let mut t = world.entity(entity).get::<Transform>().unwrap().clone();
        t.scale = Vec3::splat(1.0);

        let mesh = asset_server.load(GltfAssetLabel::Scene(0).from_asset("models/spawn.glb"));

        world
            .commands()
            .entity(entity)
            .insert((Name::new("spawn"), SceneRoot(mesh), t));
    }
}

fn main() {
    let mut app = App::new();

    app.register_type::<DebugVisuals>();
    app.insert_resource(DebugVisuals {
        unlit: true,
        tonemapping: Tonemapping::None,
        exposure: 0.,
        shadows: false,
    });

    app.add_plugins(DefaultPlugins.set(ImagePlugin {
        default_sampler: repeating_image_sampler(false),
    }));

    // bevy_flycam setup so we can get a closer look at the scene, mainly for debugging
    app.add_plugins(PlayerPlugin);

    app.insert_resource(MovementSettings {
        sensitivity: 0.00005,
        speed: 12.,
    });
    app.insert_resource(AmbientLight {
        color: Color::WHITE,
        brightness: 500.,
    });
    app.add_plugins(bevy_inspector_egui::quick::WorldInspectorPlugin::default());

    app.add_plugins(TrenchBroomPlugin(TrenchBroomConfig::new("hedz")));

    app.add_systems(Startup, write_trenchbroom_config);
    app.add_systems(PostStartup, setup_scene);
    app.add_systems(Update, (set_materials_unlit, set_tonemapping, set_shadows));

    app.run();
}

fn setup_scene(mut commands: Commands, asset_server: Res<AssetServer>) {
    commands.spawn(SceneRoot(asset_server.load("maps/map1.map#Scene")));

    commands.spawn((
        DirectionalLight {
            illuminance: light_consts::lux::OVERCAST_DAY,
            shadows_enabled: true,
            ..default()
        },
        Transform {
            translation: Vec3::new(0.0, 2.0, 0.0),
            rotation: Quat::from_rotation_x(-1.7),
            ..default()
        },
    ));

    commands.spawn((SceneRoot(
        asset_server.load(GltfAssetLabel::Scene(0).from_asset("models/mig.glb")),
    ),));
}

fn write_trenchbroom_config(server: Res<TrenchBroomServer>) {
    server.config.write_folder("trenchbroom/hedz").unwrap()
}

fn set_tonemapping(
    mut cams: Query<(&mut Tonemapping, &mut ColorGrading), With<Camera>>,
    visuals: Res<DebugVisuals>,
) {
    for (mut tm, mut color) in cams.iter_mut() {
        *tm = visuals.tonemapping;
        color.global.exposure = visuals.exposure;
    }
}

fn set_materials_unlit(
    mut materials: ResMut<Assets<StandardMaterial>>,
    visuals: Res<DebugVisuals>,
) {
    if !materials.is_changed() {
        return;
    }

    for (_, material) in materials.iter_mut() {
        material.unlit = visuals.unlit;
    }
}

fn set_shadows(mut lights: Query<&mut DirectionalLight>, visuals: Res<DebugVisuals>) {
    for mut l in lights.iter_mut() {
        l.shadows_enabled = visuals.shadows;
    }
}