use glc::vector::Vector2f;
use rand::random;
use specs::{saveload::MarkedBuilder, Builder, Entity, World, WorldExt};

use crate::{
    components::{FleetOwned, PlayerOwned, Position, Ship, ShipType},
    misc::{Persistence, WorldPersistence},
};

use super::Error;

#[derive(Clone)]
pub struct ShipBuilder {
    player: Option<Entity>,
    fleet: Option<Entity>,
    position: Option<Vector2f>,
    type_: Option<ShipType>,
    direction: Vector2f,
}

impl ShipBuilder {
    pub fn build(&self, world: &mut World) -> Result<Entity, Error> {
        let player = self.player.ok_or(Error::MissingValue("player"))?;
        let fleet = self.fleet.ok_or(Error::MissingValue("fleet"))?;
        let position = self.position.ok_or(Error::MissingValue("position"))?;
        let type_ = self.type_.ok_or(Error::MissingValue("type"))?;
        let direction = self.direction;

        let player_owned = PlayerOwned::new(player);
        let fleet_owned = FleetOwned::new(fleet);
        let position = Position::new(position);
        let ship = Ship::new(type_, direction);

        let entity = world
            .create_entity()
            .marked::<<WorldPersistence as Persistence>::Marker>()
            .with(player_owned)
            .with(fleet_owned)
            .with(position)
            .with(ship)
            .build();

        Ok(entity)
    }

    pub fn player(mut self, value: Entity) -> Self {
        self.player = Some(value);

        self
    }

    pub fn fleet(mut self, value: Entity) -> Self {
        self.fleet = Some(value);

        self
    }

    pub fn position<V: Into<Vector2f>>(mut self, value: V) -> Self {
        self.position = Some(value.into());

        self
    }

    pub fn direction<V: Into<Vector2f>>(mut self, value: V) -> Self {
        self.position = Some(value.into());

        self
    }

    pub fn type_(mut self, value: ShipType) -> Self {
        self.type_ = Some(value);

        self
    }
}

impl Default for ShipBuilder {
    fn default() -> Self {
        Self {
            player: None,
            fleet: None,
            position: None,
            type_: None,
            direction: Vector2f::new(random::<f32>() - 0.5, random::<f32>() - 0.5).normalize(),
        }
    }
}