use super::StaticItem;
use once_cell::sync::OnceCell;
use std::collections::BTreeMap;
use ansi::ansi;
use crate::models::item::Item;

pub struct Zone {
    pub code: &'static str,
    pub display: &'static str,
    pub outdoors: bool,
}

static STATIC_ZONE_DETAILS: OnceCell<BTreeMap<&'static str, Zone>> = OnceCell::new();
pub fn zone_details() -> &'static BTreeMap<&'static str, Zone> {
    STATIC_ZONE_DETAILS.get_or_init(
        || vec!(
            Zone { code: "melbs",
                   display: "Melbs",
                   outdoors: true },
            Zone { code: "repro_xv",
                   display: "Reprolabs XV",
                   outdoors: true },
        ).into_iter().map(|x|(x.code, x)).collect())
}

#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Debug)]
pub struct GridCoords {
    pub x: i64,
    pub y: i64,
    pub z: i64
}

pub enum ExitType {
    Free, // Anyone can just walk it.
    // Future ideas: Doors with locks, etc...
}

pub enum Direction {
    NORTH,
    SOUTH,
    EAST,
    WEST,
    NORTHEAST,
    SOUTEAST,
    NORTHWEST,
    SOUTHWEST,
    UP,
    DOWN,
    IN(&'static str)
}

pub enum ExitTarget {
    UseGPS,
    Custom(&'static str)
}

pub struct Exit {
    direction: Direction,
    target: ExitTarget,
    exit_type: ExitType
}

pub struct Room {
    pub zone: &'static str,
    pub code: &'static str,
    pub name: &'static str,
    pub short: &'static str,
    pub grid_coords: GridCoords,
    pub description: &'static str,
    pub description_less_explicit: Option<&'static str>,
    pub exits: Vec<Exit>
}

static STATIC_ROOM_LIST: OnceCell<Vec<Room>> = OnceCell::new();
pub fn room_list() -> &'static Vec<Room> {
    STATIC_ROOM_LIST.get_or_init(
        || vec!(
            Room {
                zone: "repro_xv",
                code: "repro_xv_chargen",
                name: ansi!("<yellow>Choice Room<reset>"),
                short: ansi!("<green>CR<reset>"),
                description: ansi!(
                    "A room brightly lit in unnaturally white light, covered in sparkling\n\
                    white tiles from floor to ceiling. A loudspeaker plays a message on\n\
                    loop:\r\n\
                    \t<blue>\"Citizen, you are here because your memory has been wiped and\n\
                    you are ready to start a fresh life. As a being enhanced by \
                    Gazos-Murlison Co technology, the emperor has granted you the power \
                    to choose 14 points of upgrades to yourself. Choose wisely, as it \
                    will impact who you end up being, and you would need to completely \
                    wipe your brain again to change them. Talk to Statbot to spend your \
                    14 points and create your body.\"<reset>\n\
                    [Try <bold>\"statbot hi<reset>, to send hi to statbot - the \" means \
                    to whisper to a particular person in the room]"),
                description_less_explicit: None,
                grid_coords: GridCoords { x: 0, y: 0, z: 2 },
                exits: vec!()
            },
        ).into_iter().collect())
}

static STATIC_ROOM_MAP_BY_CODE: OnceCell<BTreeMap<&'static str, &'static Room>> = OnceCell::new();
pub fn room_map_by_code() -> &'static BTreeMap<&'static str, &'static Room> {
    STATIC_ROOM_MAP_BY_CODE.get_or_init(
        || room_list().iter().map(|r| (r.code, r)).collect())
}

static STATIC_ROOM_MAP_BY_LOC: OnceCell<BTreeMap<&'static GridCoords, &'static Room>> = OnceCell::new();
pub fn room_map_by_loc() -> &'static BTreeMap<&'static GridCoords, &'static Room> {
    STATIC_ROOM_MAP_BY_LOC.get_or_init(
        || room_list().iter().map(|r| (&r.grid_coords, r)).collect())
}

pub fn room_static_items() -> Box<dyn Iterator<Item = StaticItem>> {
    Box::new(room_list().iter().map(|r| StaticItem {
        item_code: r.code,
        initial_item: Box::new(|| Item {
            item_code: r.code.to_owned(),
            item_type: "room".to_owned(),
            display: r.description.to_owned(),
            location: format!("room/{}", r.code),
            is_static: true,
            ..Item::default()
        })
    }))
}

#[cfg(test)]
mod test {
    use super::*;
    #[test]
    fn room_zones_should_exist() {
        for room in room_list() {
            zone_details().get(room.zone).expect(
                &format!("zone {} for room {} should exist", room.zone, room.code));
        }
    }

    #[test]
    fn room_map_by_code_should_have_repro_xv_chargen() {
        assert_eq!(room_map_by_code().get("repro_xv_chargen").expect("repro_xv_chargen to exist").code,
                   "repro_xv_chargen");
    }
}