#[macro_use] extern crate specs_derive;
#[macro_use] extern crate specs_system_macro;

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

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

#[derive(Component)]
pub struct Renderable {
    glyph: u8,
    color: carpet::Color,
}

system_impl! {
    Draw(
        resource mut board: carpet::Board,
        renderable: Renderable,
        pos: Pos,
    ) {
        board.clear();
        for (p, r) in (&pos, &renderable).join() {
            board.set_with_color([p.x, p.y], r.glyph, r.color);
        }
    }
}

#[derive(Component)]
pub struct MoveLeft;

system! {
    Leftward (
        _left: MoveLeft,
        mut pos: Pos,
    ) {
        if pos.x == 0 {
            pos.x = 79;
        } else {
            pos.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);
        Leftward.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,
            color: carpet::Color::Blue,
        })
        .build();

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

    world.insert(board);

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