use crate::prelude::{Transformable, Transformation};

#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
pub enum QuaterDirection {
    N,
    NNE,
    NE,
    ENE,
    E,
    ESE,
    SE,
    SSE,
    S,
    SSW,
    SW,
    WSW,
    W,
    WNW,
    NW,
    NNW,
}

impl QuaterDirection {
    pub fn to_int_direction(&self) -> u8 {
        match self {
            QuaterDirection::N => 0,
            QuaterDirection::NNE => 1,
            QuaterDirection::NE => 2,
            QuaterDirection::ENE => 3,
            QuaterDirection::E => 4,
            QuaterDirection::ESE => 5,
            QuaterDirection::SE => 6,
            QuaterDirection::SSE => 7,
            QuaterDirection::S => 8,
            QuaterDirection::SSW => 9,
            QuaterDirection::SW => 10,
            QuaterDirection::WSW => 11,
            QuaterDirection::W => 12,
            QuaterDirection::WNW => 13,
            QuaterDirection::NW => 14,
            QuaterDirection::NNW => 15,
        }
    }

    pub fn from_int_direction(x: u8) -> Self {
        match x {
            0 => QuaterDirection::N,
            1 => QuaterDirection::NNE,
            2 => QuaterDirection::NE,
            3 => QuaterDirection::ENE,
            4 => QuaterDirection::E,
            5 => QuaterDirection::ESE,
            6 => QuaterDirection::SE,
            7 => QuaterDirection::SSE,
            8 => QuaterDirection::S,
            9 => QuaterDirection::SSW,
            10 => QuaterDirection::SW,
            11 => QuaterDirection::WSW,
            12 => QuaterDirection::W,
            13 => QuaterDirection::WNW,
            14 => QuaterDirection::NW,
            15 => QuaterDirection::NNW,
            _ => unreachable!(),
        }
    }
}

impl Transformable for QuaterDirection {
    fn transform(&self, t: Transformation) -> Self {
        Self::from_int_direction((self.to_int_direction() + 4 * t.rot().get_index()) % 16)
    }
}

impl From<u8> for QuaterDirection {
    fn from(value: u8) -> Self {
        Self::from_int_direction(value)
    }
}