// The code below is a stub. Just enough to satisfy the compiler.
// In order to pass the tests you can add-to or change any of this code.

#[derive(PartialEq, Debug)]
pub enum Direction {
    North,
    East,
    South,
    West,
}

pub struct Robot {
    x: i32,
    y: i32,
    d: Direction,
}

impl Robot {
    pub fn new(x: i32, y: i32, d: Direction) -> Self {
        Robot { x, y, d }
    }

    pub fn turn_right(self) -> Self {
        Robot {
            d: {
                use Direction::*;
                match self.d {
                    North => East,
                    East => South,
                    South => West,
                    West => North,
                }
            },
            ..self
        }
    }

    pub fn turn_left(self) -> Self {
        Robot {
            d: {
                use Direction::*;
                match self.d {
                    North => West,
                    East => North,
                    South => East,
                    West => South,
                }
            },
            ..self
        }
    }

    pub fn advance(self) -> Self {
        Robot {
            x: match self.d {
                Direction::West => self.x - 1,
                Direction::East => self.x + 1,
                _ => self.x,
            },
            y: match self.d {
                Direction::North => self.y + 1,
                Direction::South => self.y - 1,
                _ => self.y,
            },
            ..self
        }
    }

    pub fn instructions(self, instructions: &str) -> Self {
        instructions.chars().fold(self, |acc, action| match action {
            'A' => acc.advance(),
            'R' => acc.turn_right(),
            'L' => acc.turn_left(),
            _ => acc,
        })
    }

    pub fn position(&self) -> (i32, i32) {
        (self.x, self.y)
    }

    pub fn direction(&self) -> &Direction {
        &self.d
    }
}