use bevy::{
    app::ScheduleRunnerPlugin,
    asset::{LoadState, UnapprovedPathMode},
    camera::primitives::MeshAabb,
    color::palettes::css::WHITE,
    image::BevyDefault,
    light::light_consts::lux::OVERCAST_DAY,
    prelude::*,
    render::{
        render_resource::TextureFormat,
        view::screenshot::{Screenshot, save_to_disk},
    },
    window::ExitCondition,
    winit::WinitPlugin,
};
use bevy_stl::StlPlugin;
use std::path::Path;

fn main() {
    let mut app = App::new();
    app.add_plugins(
        DefaultPlugins
            .set(ImagePlugin::default_nearest())
            .set(WindowPlugin {
                primary_window: None,
                exit_condition: ExitCondition::DontExit,
                ..Default::default()
            })
            .set(AssetPlugin {
                unapproved_path_mode: UnapprovedPathMode::Allow,
                ..Default::default()
            })
            .disable::<WinitPlugin>(),
    )
    .add_plugins((ScheduleRunnerPlugin::default(), StlPlugin))
    .add_systems(Startup, setup)
    .add_systems(Update, update)
    .run();
}
fn setup(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    mut images: ResMut<Assets<Image>>,
) {
    let image = Image::new_target_texture(512, 512, TextureFormat::bevy_default());
    let image_handle = images.add(image);
    commands.spawn((
        Mesh3d(asset_server.load(Path::new(
            "/home/dis-da-mor/Documents/code/tag_studio_render/cube.stl",
        ))),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: WHITE.into(),
            emissive: LinearRgba::new(1.0, 1.0, 1.0, 1.0),
            ..Default::default()
        })),
        Model,
    ));
    commands.insert_resource(AmbientLight {
        color: WHITE.into(),
        brightness: OVERCAST_DAY,
        ..Default::default()
    });
    commands.spawn((
        Camera3d::default(),
        Camera {
            target: image_handle.into(),
            ..Default::default()
        },
        Transform::default(),
        CameraMain,
    ));
}
#[derive(Component)]
struct Model;
fn update(
    asset_server: Res<AssetServer>,
    model: Query<&Mesh3d, With<Model>>,
    meshes: Res<Assets<Mesh>>,
    mut camera: Query<(&mut Transform, &Camera), With<CameraMain>>,
    mut commands: Commands,
    mut captured: Local<bool>,
) {
    if *captured {
        return;
    }
    let model_handle = &model.single().unwrap().0;
    match asset_server.get_load_state(model_handle).unwrap() {
        LoadState::Loaded => {}
        LoadState::Failed(asset_load_error) => panic!("{}", asset_load_error),
        _ => {
            return;
        }
    }
    let mesh = meshes.get(model_handle).unwrap();
    let aabb = mesh.compute_aabb().expect("no AABB for the model");
    let trans = Vec3::splat(aabb.half_extents.max_element() * 4.);
    let (mut camera_trans, camera) = camera.single_mut().unwrap();
    camera_trans.translation = trans;
    camera_trans.look_at(aabb.center.into(), Dir3::Y);
    commands
        .spawn(Screenshot(camera.target.clone()))
        .observe(save_to_disk("out.png"));
    *captured = true;
}
#[derive(Debug, Component)]
struct CameraMain;