extern crate amethyst;
use amethyst::assets::Loader;
use amethyst::core::cgmath::Vector3;
use amethyst::core::transform::{GlobalTransform, Transform, TransformBundle};
use amethyst::prelude::*;
use amethyst::renderer::*;

struct Scene;

impl<'a, 'b> State<GameData<'a, 'b>> for Scene {
    fn on_start(&mut self, state: StateData<GameData>) {
        // CAM

        state
            .world
            .create_entity()
            .with(Camera::standard_3d(5., 4.))
            .with(GlobalTransform::default())
            .with(Transform {
                translation: Vector3::new(0., 0., 3.),
                ..Default::default()
            })
            .build();

        // LIGHT

        let light: Light = PointLight {
            intensity: 12.0,
            color: [1., 1., 1.].into(),
            ..PointLight::default()
        }.into();

        state
            .world
            .create_entity()
            .with(light)
            .with(GlobalTransform::default())
            .with(Transform {
                translation: Vector3::new(0., 1., 3.),
                ..Default::default()
            })
            .build();

        // SHADED CUBE

        let material = {
            let loader = state.world.read_resource::<Loader>();
            let mat_defs = state.world.read_resource::<MaterialDefaults>();
            let albedo =
                loader.load_from_data([0.6, 0.4, 0.2, 1.].into(), (), &state.world.read_resource());
            Material {
                albedo,
                ..mat_defs.0.clone()
            }
        };

        let mesh: MeshHandle = {
            let loader = state.world.read_resource::<Loader>();
            let verts = Shape::Cube.generate::<Vec<PosTex>>(Some((0.3, 0.3, 0.3)));
            loader.load_from_data(verts, (), &state.world.read_resource())
        };

        state
            .world
            .create_entity()
            .with(mesh)
            .with(material.clone())
            .with(GlobalTransform::default())
            .with(Transform {
                translation: Vector3::new(-1., -0.5, 0.),
                ..Default::default()
            })
            .build();

        // FLAT CUBE

        let mesh: MeshHandle = {
            let loader = state.world.read_resource::<Loader>();
            let verts = Shape::Cube.generate::<Vec<PosNormTex>>(Some((0.3, 0.3, 0.3)));
            loader.load_from_data(verts, (), &state.world.read_resource())
        };

        state
            .world
            .create_entity()
            .with(mesh)
            .with(material)
            .with(GlobalTransform::default())
            .with(Transform {
                translation: Vector3::new(1., -0.5, 0.),
                ..Default::default()
            })
            .build();
    }
    fn update(&mut self, state: StateData<GameData>) -> Trans<GameData<'a, 'b>> {
        state.data.update(&state.world);
        Trans::None
    }
}

fn main() -> amethyst::Result<()> {
    amethyst::start_logger(Default::default());

    let pipe = Pipeline::build().with_stage(
        Stage::with_backbuffer()
            .clear_target([0.01, 0.02, 0.03, 1.0], 1.0)
            .with_pass(DrawShaded::<PosNormTex>::new())
            .with_pass(DrawFlat::<PosTex>::new()),
    );

    let state = GameDataBuilder::default()
        .with_bundle(TransformBundle::new())?
        .with_bundle(RenderBundle::new(pipe, Some(Default::default())))?;

    Application::build("./", Scene)?.build(state)?.run();
    Ok(())
}