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::{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::{Data as ModelData, Model};
use engine::renderer::opengl::Extension as OpenglRendererExtension;
use engine::transform::WorldPosition;
use engine::vector::Vec3;
use engine::window::{
    Builder as WindowBuilder,
    CursorMode,
    Extension as WindowExtension,
    Window,
};
use engine::Engine;
use tracing::level_filters::LevelFilter;
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::util::SubscriberInitExt;
use tracing_subscriber::EnvFilter;

const WINDOW_SIZE: Dimens<u32> = Dimens { width: 1920, height: 1080 };

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(
            EnvFilter::builder()
                .with_default_directive(LevelFilter::DEBUG.into())
                .from_env()?,
        )
        .init();

    let mut engine = Engine::new();

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

    engine.add_sole(GlobalLight::default())?;

    engine.register_system(*START_PHASE, init);

    engine.add_extension(OpenglRendererExtension::default());

    engine.add_extension(
        WindowExtension::new(WindowBuilder::default().multisampling_sample_count(8))
            .window_title("Game")
            .window_size(WINDOW_SIZE),
    );

    engine.add_extension(FlyCameraExtension(FlyCameraOptions {
        mouse_sensitivity: 0.2,
    }));

    engine.add_extension(InputExtension::default());

    engine.start();

    Ok(())
}

fn init(window: Single<Window>, mut assets: Single<Assets>, mut actions: Actions)
{
    window.set_cursor_mode(CursorMode::Disabled).unwrap();

    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(
                "light_cube",
                ModelData::builder()
                    .mesh(cube_mesh_create(
                        CubeMeshCreationSpec::builder()
                            .dimens(Dimens3::from(2.0))
                            .build(),
                        |face_verts, _, _| face_verts,
                    ))
                    .material(
                        "surface",
                        Material::builder().ambient(YELLOW * 5.0).build(),
                    )
                    .build(),
            ),
        ),
        MaterialFlags::builder().use_ambient_color(true).build(),
    ));

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