use std::fmt::{Display, Formatter};
use std::str::FromStr;

use serde::{Deserialize, Serialize};

pub mod db_metadata;
pub mod item;
pub mod link;
pub mod locations;
pub mod parameters;
pub mod player;
pub mod response;
pub mod settings;
pub mod token;

#[derive(Serialize, Deserialize, Debug, Copy, Clone)]
pub enum Dimension {
    Overworld,
    Nether,
    TheEnd,
}

impl Default for Dimension {
    fn default() -> Self {
        Self::Overworld
    }
}

impl Display for Dimension {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        let display_name = match self {
            Dimension::Overworld => "Overworld",
            Dimension::Nether => "Nether",
            Dimension::TheEnd => "The End",
        };
        write!(f, "{}", display_name)
    }
}

impl FromStr for Dimension {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let s = s.to_lowercase();
        Ok(match s.as_str() {
            "o" | "overworld" => Dimension::Overworld,
            "n" | "nether" => Dimension::Nether,
            "e" | "end" | "the end" => Dimension::TheEnd,
            _ => return Err(format!("Unable to parse {} as dimension", s)),
        })
    }
}

#[derive(Serialize, Deserialize, Debug, Copy, Clone)]
pub enum Direction {
    North,
    East,
    South,
    West,
}

impl Display for Direction {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        let display_name = match self {
            Direction::North => "North",
            Direction::East => "East",
            Direction::South => "South",
            Direction::West => "West",
        };

        write!(f, "{}", display_name)
    }
}

#[derive(Default, Serialize, Deserialize, Debug, Copy, Clone)]
pub struct Position {
    pub x: i32,
    pub y: i32,
    pub z: i32,
    pub dimension: Dimension,
}

impl Position {
    pub fn new(x: i32, y: i32, z: i32, dimension: Dimension) -> Self {
        Self { x, y, z, dimension }
    }
}

impl Display for Position {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "({} x={}, y={}, z={}) ",
            self.dimension, self.x, self.y, self.z
        )
    }
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Portal {
    pub x: i32,
    pub z: i32,
}

impl Portal {
    pub fn new(x: i32, z: i32) -> Self {
        Self { x, z }
    }

    pub fn direction(&self) -> Direction {
        if self.x.abs() > self.z.abs() {
            if self.x < 0 {
                Direction::West
            } else {
                Direction::East
            }
        } else if self.z < 0 {
            Direction::North
        } else {
            Direction::South
        }
    }

    pub fn tunnel_addr(&self) -> i32 {
        match self.direction() {
            Direction::North | Direction::South => self.z.abs(),
            Direction::East | Direction::West => self.x.abs(),
        }
    }
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Ord, PartialOrd, Eq, Hash)]
pub enum CommandLevel {
    ALL = 0,
    REGISTERED = 1,
    MOD = 2,
    ADMIN = 3,
}