use crate::map::*;
use crate::map_parse::PhysicsLayer;

use ndarray::Array2;

use std::error;
use std::fmt;

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        use Error::*;
        match self {
            Map(err) => err.fmt(f),
            DatafileParsing(err) => err.fmt(f),
            DatafileSaving(err) => err.fmt(f),
            DatafileLoading(err) => err.fmt(f),
            Io(err) => err.fmt(f),
            Dir(err) => err.fmt(f),
        }
    }
}

impl error::Error for Error {}

impl TwMap {
    pub fn physics_group(&self) -> &Group {
        self.groups.iter()
            .find(|group| group.is_physics_group())
            .unwrap()
    }
}

impl Group {
    pub fn is_physics_group(&self) -> bool {
        self.layers.iter()
            .any(|layer| layer.is_physics_layer())
    }
}

impl Layer {
    pub fn is_physics_layer(&self) -> bool {
        use Layer::*;
        match self {
            Game(_) | Front(_) | Tele(_) | Speedup(_) | Switch(_) | Tune(_) => true,
            Tiles(_) | Quads(_) | Sounds(_) | Invalid(_) => false,
        }
    }

    pub fn kind(&self) -> LayerKind {
        use Layer::*;
        match self {
            Game(_) => LayerKind::Game,
            Tiles(_) => LayerKind::Tiles,
            Quads(_) => LayerKind::Quads,
            Front(_) => LayerKind::Front,
            Tele(_) => LayerKind::Tele,
            Speedup(_) => LayerKind::Speedup,
            Switch(_) => LayerKind::Switch,
            Tune(_) => LayerKind::Tune,
            Sounds(_) => LayerKind::Sounds,
            Invalid(variant) => *variant,
        }
    }

    // returns (height, width) of the 2-dimensional array, if the contained layer is a tile map layer
    pub fn shape(&self) -> Option<(usize, usize)> {
        use Layer::*;
        match self {
            Game(l) => Some((l.tiles.unwrap_ref().nrows(), l.tiles.unwrap_ref().ncols())),
            Tiles(l) => Some((l.tiles.unwrap_ref().nrows(), l.tiles.unwrap_ref().ncols())),
            Quads(_) => None,
            Front(l) => Some((l.tiles.unwrap_ref().nrows(), l.tiles.unwrap_ref().ncols())),
            Tele(l) => Some((l.tiles.unwrap_ref().nrows(), l.tiles.unwrap_ref().ncols())),
            Speedup(l) => Some((l.tiles.unwrap_ref().nrows(), l.tiles.unwrap_ref().ncols())),
            Switch(l) => Some((l.tiles.unwrap_ref().nrows(), l.tiles.unwrap_ref().ncols())),
            Tune(l) => Some((l.tiles.unwrap_ref().nrows(), l.tiles.unwrap_ref().ncols())),
            Sounds(_) => None,
            Invalid(_) => None,
        }
    }
}

impl<T, U> From<T> for CompressedData<T, U> {
    fn from(data: T) -> Self {
        CompressedData::Loaded(data)
    }
}

impl<T, U> CompressedData<T, U> {
    pub fn unwrap_ref(&self) -> &T {
        match self {
            CompressedData::Compressed(_, _, _) => panic!(),
            CompressedData::Loaded(data) => data,
        }
    }

    pub fn unwrap_mut(&mut self) -> &mut T {
        match self {
            CompressedData::Compressed(_, _, _) => panic!(),
            CompressedData::Loaded(data) => data,
        }
    }

    pub fn unwrap(self) -> T {
        match self {
            CompressedData::Compressed(_, _, _) => panic!(),
            CompressedData::Loaded(data) => data,
        }
    }
}

impl Envelope {
    pub fn name(&self) -> &String {
        use Envelope::*;
        match self {
            Position(env) => &env.name,
            Color(env) => &env.name,
            Sound(env) => &env.name,
        }
    }

    pub fn name_mut (&mut self) -> &mut String {
        use Envelope::*;
        match self {
            Position(env) => &mut env.name,
            Color(env) => &mut env.name,
            Sound(env) => &mut env.name,
        }
    }
}

impl Default for Group {
    fn default() -> Self {
        Group {
            offset_x: 0,
            offset_y: 0,
            parallax_x: 100,
            parallax_y: 100,
            layers: vec![],
            clipping: false,
            clip_x: 0,
            clip_y: 0,
            clip_width: 0,
            clip_height: 0,
            name: String::new(),
        }
    }
}

impl Group {
    // constructor for game group
    pub fn game() -> Self {
        let mut group = Group::default();
        group.name = String::from("Game");
        group
    }
}

impl TilesLayer {
    pub fn new(shape: (usize, usize)) -> Self {
        TilesLayer {
            detail: false,
            color: Color::default(),
            color_env: None,
            color_env_offset: 0,
            image: None,
            tiles: Array2::default(shape).into(),
            name: "".to_string(),
            auto_mapper: AutoMapper::default()
        }
    }
}

impl Layer {
    pub fn name(&self) -> &str {
        use Layer::*;
        match self {
            Game(_) => GameLayer::name(),
            Tiles(l) => &l.name,
            Quads(l) => &l.name,
            Front(_) => FrontLayer::name(),
            Tele(_) => TeleLayer::name(),
            Speedup(_) => SpeedupLayer::name(),
            Switch(_) => SwitchLayer::name(),
            Tune(_) => TuneLayer::name(),
            Sounds(l) => &l.name,
            Invalid(_) => panic!(),
        }
    }

    pub fn name_mut(&mut self) -> Option<&mut String> {
        use Layer::*;
        match self {
            Game(_) => None,
            Tiles(l) => Some(&mut l.name),
            Quads(l) => Some(&mut l.name),
            Front(_) => None,
            Tele(_) => None,
            Speedup(_) => None,
            Switch(_) => None,
            Tune(_) => None,
            Sounds(l) => Some(&mut l.name),
            Invalid(_) => panic!(),
        }
    }
}

impl Tile {
    pub fn new(id: u8, flags: TileFlags) -> Self {
        Tile {
            id,
            flags,
            skip: 0,
            unused: 0,
        }
    }
}

impl Speedup {
    pub fn new(id: u8, force: u8, max_speed: u8, angle: i16) -> Self {
        Speedup {
            force,
            max_speed,
            id,
            unused_padding: 0,
            angle: angle.into(),
        }
    }
}

impl From<i16> for I16 {
    fn from(x: i16) -> Self {
        I16 {
            bytes: x.to_le_bytes(),
        }
    }
}

impl From<I16> for i16 {
    fn from(x: I16) -> Self {
        i16::from_le_bytes(x.bytes)
    }
}

impl Default for Color {
    fn default() -> Self {
        Color {
            r: 255,
            g: 255,
            b: 255,
            a: 255,
        }
    }
}

impl TileMapLayer for TilesLayer {
    type TileType = Tile;

    fn tiles(&self) -> &CompressedData<Array2<Self::TileType>, TilesLoadInfo> {
        &self.tiles
    }

    fn tiles_mut(&mut self) -> &mut CompressedData<Array2<Self::TileType>, TilesLoadInfo> {
        &mut self.tiles
    }
}

impl TileMapLayer for GameLayer {
    type TileType = Tile;

    fn tiles(&self) -> &CompressedData<Array2<Self::TileType>, TilesLoadInfo> {
        &self.tiles
    }

    fn tiles_mut(&mut self) -> &mut CompressedData<Array2<Self::TileType>, TilesLoadInfo> {
        &mut self.tiles
    }
}

impl TileMapLayer for FrontLayer {
    type TileType = Tile;

    fn tiles(&self) -> &CompressedData<Array2<Self::TileType>, TilesLoadInfo> {
        &self.tiles
    }

    fn tiles_mut(&mut self) -> &mut CompressedData<Array2<Self::TileType>, TilesLoadInfo> {
        &mut self.tiles
    }
}

impl TileMapLayer for TeleLayer {
    type TileType = Tele;

    fn tiles(&self) -> &CompressedData<Array2<Self::TileType>, TilesLoadInfo> {
        &self.tiles
    }

    fn tiles_mut(&mut self) -> &mut CompressedData<Array2<Self::TileType>, TilesLoadInfo> {
        &mut self.tiles
    }
}

impl TileMapLayer for SpeedupLayer {
    type TileType = Speedup;

    fn tiles(&self) -> &CompressedData<Array2<Self::TileType>, TilesLoadInfo> {
        &self.tiles
    }

    fn tiles_mut(&mut self) -> &mut CompressedData<Array2<Self::TileType>, TilesLoadInfo> {
        &mut self.tiles
    }
}

impl TileMapLayer for SwitchLayer {
    type TileType = Switch;

    fn tiles(&self) -> &CompressedData<Array2<Self::TileType>, TilesLoadInfo> {
        &self.tiles
    }

    fn tiles_mut(&mut self) -> &mut CompressedData<Array2<Self::TileType>, TilesLoadInfo> {
        &mut self.tiles
    }
}

impl TileMapLayer for TuneLayer {
    type TileType = Tune;

    fn tiles(&self) -> &CompressedData<Array2<Self::TileType>, TilesLoadInfo> {
        &self.tiles
    }

    fn tiles_mut(&mut self) -> &mut CompressedData<Array2<Self::TileType>, TilesLoadInfo> {
        &mut self.tiles
    }
}

impl AnyTile for Tile {}

impl AnyTile for Switch {}

impl AnyTile for Tele {}

impl AnyTile for Speedup {}

impl AnyTile for Tune {}

impl AnyLayer for GameLayer {
    fn kind() -> LayerKind {
        LayerKind::Game
    }
}

impl AnyLayer for TilesLayer {
    fn kind() -> LayerKind {
        LayerKind::Tiles
    }
}

impl AnyLayer for QuadsLayer {
    fn kind() -> LayerKind {
        LayerKind::Quads
    }
}

impl AnyLayer for FrontLayer {
    fn kind() -> LayerKind {
        LayerKind::Front
    }
}

impl AnyLayer for TeleLayer {
    fn kind() -> LayerKind {
        LayerKind::Tele
    }
}

impl AnyLayer for SpeedupLayer {
    fn kind() -> LayerKind {
        LayerKind::Speedup
    }
}

impl AnyLayer for SwitchLayer {
    fn kind() -> LayerKind {
        LayerKind::Switch
    }
}

impl AnyLayer for TuneLayer {
    fn kind() -> LayerKind {
        LayerKind::Tune
    }
}

impl AnyLayer for SoundsLayer {
    fn kind() -> LayerKind {
        LayerKind::Sounds
    }
}