use glc::{matrix::Angle, vector::Vector2f};
use serde::{Deserialize, Serialize};
use specs::{
    error::NoError,
    saveload::{ConvertSaveload, Marker},
    Component, Entity, VecStorage,
};

#[derive(Clone, Debug)]
pub struct Ship {
    pub type_: Type,
    pub fleet: Entity,
    pub agility: Angle<f32>,
    pub target_pos: Vector2f,
    pub target_dir: Vector2f,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub enum Type {
    Fighter,
    Bomber,
    Transporter,
}

#[derive(Serialize, Deserialize)]
pub struct ShipData<M> {
    pub type_: Type,
    pub fleet: M,
    pub agility: Angle<f32>,
    pub target_pos: Vector2f,
    pub target_dir: Vector2f,
}

impl Component for Ship {
    type Storage = VecStorage<Self>;
}

impl<M> ConvertSaveload<M> for Ship
where
    for<'de> M: Marker + Serialize + Deserialize<'de>,
{
    type Data = ShipData<M>;
    type Error = NoError;

    fn convert_into<F>(&self, mut ids: F) -> Result<Self::Data, Self::Error>
    where
        F: FnMut(Entity) -> Option<M>,
    {
        let Ship {
            type_,
            fleet,
            agility,
            target_pos,
            target_dir,
        } = self.clone();
        let fleet = ids(fleet).unwrap();

        Ok(ShipData {
            type_,
            fleet,
            agility,
            target_pos,
            target_dir,
        })
    }

    fn convert_from<F>(data: Self::Data, mut ids: F) -> Result<Self, Self::Error>
    where
        F: FnMut(M) -> Option<Entity>,
    {
        let ShipData {
            type_,
            fleet,
            agility,
            target_pos,
            target_dir,
        } = data;
        let fleet = ids(fleet).unwrap();

        Ok(Ship {
            type_,
            fleet,
            agility,
            target_pos,
            target_dir,
        })
    }
}