use crate::geometry::Direction;
use crate::geometry::Point2d;
use std::fmt;

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct Command {
    pub worm: Option<i32>,
    pub action: Action,
}

impl fmt::Display for Command {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self.worm {
            Some(worm) => write!(f, "select {};{}", worm, self.action),
            None => write!(f, "{}", self.action),
        }
    }
}

impl Command {
    pub fn with_select(worm: i32, action: Action) -> Command {
        Command {
            worm: Some(worm),
            action,
        }
    }

    pub fn new(action: Action) -> Command {
        Command { worm: None, action }
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Action {
    Move(Point2d),
    Dig(Point2d),
    Shoot(Direction),
    Bomb(Point2d),
    Snowball(Point2d),
    DoNothing,
}

impl fmt::Display for Action {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        use Action::*;
        match self {
            Move(p) => write!(f, "move {} {}", p.x, p.y),
            Dig(p) => write!(f, "dig {} {}", p.x, p.y),
            Shoot(dir) => write!(f, "shoot {}", dir),
            Bomb(p) => write!(f, "banana {} {}", p.x, p.y),
            Snowball(p) => write!(f, "snowball {} {}", p.x, p.y),
            DoNothing => write!(f, "nothing"),
        }
    }
}

impl Action {
    pub fn is_attack(&self) -> bool {
        use Action::*;
        match self {
            Shoot(_) | Bomb(_) => true,
            _ => false,
        }
    }

    pub fn is_snowball(&self) -> bool {
        use Action::*;
        match self {
            Snowball(_) => true,
            _ => false,
        }
    }
}