use std::error::Error;
use std::path::Path;

use engine::asset::Assets;
use engine::camera::fly::{
    Extension as FlyCameraExtension,
    Fly as FlyCamera,
    Options as FlyCameraOptions,
};
use engine::camera::{Active as ActiveCamera, Camera};
use engine::color::Color;
use engine::data_types::dimens::Dimens3;
use engine::ecs::actions::Actions;
use engine::ecs::phase::START as START_PHASE;
use engine::ecs::sole::Single;
use engine::input::Extension as InputExtension;
use engine::lighting::{AttenuationParams, GlobalLight, PointLight};
use engine::material::{Flags as MaterialFlags, Material};
use engine::mesh::cube::{
    create as cube_mesh_create,
    CreationSpec as CubeMeshCreationSpec,
};
use engine::model::{Materials as ModelMaterials, Model, Spec as ModelSpec};
use engine::rendering::{
    Extension as RenderingExtension,
    GraphicsProperties,
    TargetWindow as RenderingTargetWindow,
};
use engine::transform::WorldPosition;
use engine::vector::Vec3;
use engine::windowing::window::{
    CreationAttributes as WindowCreationAttributes,
    CursorGrabMode as WindowCursorGrabMode,
};
use engine::Engine;
use tracing::level_filters::LevelFilter;
use tracing_subscriber::fmt::time::ChronoLocal;
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::util::SubscriberInitExt;
use tracing_subscriber::EnvFilter;

const YELLOW: Color<f32> = Color {
    red: 0.988235294118,
    green: 0.941176470588,
    blue: 0.0274509803922,
};

const RESOURCE_DIR: &str = "res";

fn main() -> Result<(), Box<dyn Error>>
{
    tracing_subscriber::registry()
        .with(
            tracing_subscriber::fmt::layer()
                .with_timer(ChronoLocal::new("%T%.6f".to_string())),
        )
        .with(
            EnvFilter::builder()
                .with_default_directive(LevelFilter::DEBUG.into())
                .from_env()?,
        )
        .init();

    Engine::new()
        .with_extension(engine::windowing::Extension::default())
        .with_extension(
            RenderingExtension::builder()
                .graphics_props(
                    GraphicsProperties::builder()
                        .debug(cfg!(debug_assertions))
                        .build(),
                )
                .build(),
        )
        .with_extension(InputExtension::default())
        .with_extension(FlyCameraExtension(FlyCameraOptions {
            mouse_sensitivity: 0.2,
        }))
        .with_extension(Application)
        .start();

    Ok(())
}

struct Application;

impl engine::ecs::extension::Extension for Application
{
    fn collect(self, mut collector: engine::ecs::extension::Collector<'_>)
    {
        let _ = collector.add_sole(GlobalLight::default());

        collector.add_system(*START_PHASE, init);
    }
}

fn init(mut assets: Single<Assets>, mut actions: Actions)
{
    actions.spawn((
        WindowCreationAttributes::default()
            .with_title("Game")
            .with_cursor_visible(false)
            .with_cursor_grab_mode(WindowCursorGrabMode::Locked),
        RenderingTargetWindow,
    ));

    actions.spawn((
        Camera::default(),
        WorldPosition {
            position: Vec3 { x: 0.0, y: 0.0, z: 3.0 },
        },
        ActiveCamera,
        FlyCamera::default(),
    ));

    actions.spawn((
        PointLight::builder()
            .diffuse(YELLOW)
            .attenuation_params(AttenuationParams {
                linear: 0.045,
                quadratic: 0.0075,
                ..Default::default()
            })
            .build(),
        WorldPosition::from(Vec3 { x: -6.0, y: 3.0, z: 3.0 }),
        Model::new(assets.store_with_name_with("light_cube", |assets| {
            ModelSpec::builder()
                .mesh(
                    assets.store_with_name(
                        "light_cube_mesh",
                        cube_mesh_create(
                            CubeMeshCreationSpec::builder()
                                .dimens(Dimens3::from(2.0))
                                .build(),
                        ),
                    ),
                )
                .materials(ModelMaterials::direct([(
                    "surface",
                    assets.store_with_name(
                        "light_cube_surface_mat",
                        Material::builder().ambient(YELLOW * 5.0).build(),
                    ),
                )]))
                .material_name("surface")
                .build()
        })),
        MaterialFlags::builder().use_ambient_color(true).build(),
    ));

    actions.spawn((
        Model::new(assets.load::<ModelSpec>(Path::new(RESOURCE_DIR).join("teapot.obj"))),
        WorldPosition::from(Vec3 { x: 1.6, y: 0.0, z: 0.0 }),
    ));
}