#[macro_use] extern crate specs_derive;

use ggez::{Context, GameError, event::EventHandler};
use specs::prelude::*;

#[derive(Component)]
struct Pos {
    x: usize,
    y: usize,
}

#[derive(Component)]
struct Renderable {
    glyph: u8,
}

struct Draw;

impl<'a> System<'a> for Draw {
    type SystemData = (
        ReadStorage<'a, Pos>,
        ReadStorage<'a, Renderable>,
        WriteExpect<'a, carpet::Board>,
    );

    fn run(&mut self, (pos, renderable, mut board): Self::SystemData) {
        board.clear();
        for (p, r) in (&pos, &renderable).join() {
            board.set([p.x, p.y], r.glyph);
        }
    }
}

#[derive(Component)]
struct MoveLeft;

impl<'a> System<'a> for MoveLeft {
    type SystemData = (
        ReadStorage<'a, MoveLeft>,
        WriteStorage<'a, Pos>,
    );

    fn run(&mut self, (left, mut pos): Self::SystemData) {
        for (_, p) in (&left, &mut pos).join() {
            if p.x == 0 {
                p.x = 79;
            } else {
                p.x -= 1;
            }
        }
    }
}

struct State {
    world: World,
}

impl EventHandler for State {
    fn draw(&mut self, ctx: &mut Context) -> Result<(), GameError> {
        ggez::graphics::clear(ctx, ggez::graphics::BLACK);
        self.world.fetch::<carpet::Board>().draw(ctx)?;
        ggez::graphics::present(ctx)
    }

    fn update(&mut self, _ctx: &mut Context) -> Result<(), GameError> {
        Draw.run_now(&mut self.world);
        MoveLeft.run_now(&mut self.world);
        Ok(())
    }
}

fn main() -> Result<(), GameError> {
    let (mut ctx, mut evloop) = ggez::ContextBuilder::new("game", "me")
        .add_resource_path({
            let base = std::env::var("CARGO_MANIFEST_DIR").unwrap();
            let mut path = std::path::PathBuf::from(base);
            path.push("resources");
            path
        })
        .window_mode(ggez::conf::WindowMode {
            width: 80.0 * 8.0,
            height: 50.0 * 8.0,
            ..ggez::conf::WindowMode::default()
        })
        .build()?;
    let mut world = World::new();
    world.register::<Pos>();
    world.register::<Renderable>();
    world.register::<MoveLeft>();
    let tileset = carpet::Tileset::from_file(&mut ctx, [8,8], "/terminal8x8.jpg")?;
    let mut board = carpet::Board::new([80,50], tileset);
    board.print([1, 1], "Hello, world!");

    world
        .create_entity()
        .with(Pos { x: 40, y: 25 })
        .with(Renderable {
            glyph: 'A' as u8,
        })
        .build();

    for i in 0..10 {
        world
            .create_entity()
            .with(Pos { x: i * 7, y: 20 })
            .with(Renderable {
                glyph: 'X' as u8,
            })
            .with(MoveLeft)
            .build();
    }

    world.insert(board);

    let mut state = State { world };
    ggez::event::run(&mut ctx, &mut evloop, &mut state)
}