// For things like signs that don't do much except stay where they are and carry a description.
use super::{possession_type::PossessionData, StaticItem};
use crate::{
    models::item::{Item, ItemStaticSpecialData, LocationActionType, Pronouns},
    static_content::room::{computer_museum, melbs},
};
use ansi::ansi;
use once_cell::sync::OnceCell;
use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;

#[derive(Serialize, Deserialize)]
pub struct FixedItem {
    pub code: String,
    pub name: String,
    pub description: String,
    pub location: String,
    pub proper_noun: bool,
    pub aliases: Vec<String>,
    pub static_special_data: Option<ItemStaticSpecialData>,
    pub action_type: LocationActionType,
}

impl Default for FixedItem {
    fn default() -> Self {
        Self {
            code: "default".to_owned(),
            name: "default".to_owned(),
            description: "A thingy".to_owned(),
            location: "unset".to_owned(),
            proper_noun: true,
            aliases: vec![],
            static_special_data: None,
            action_type: LocationActionType::Normal,
        }
    }
}

fn fixed_item_list() -> &'static Vec<FixedItem> {
    static FIXED_ITEM_LIST: OnceCell<Vec<FixedItem>> = OnceCell::new();
    FIXED_ITEM_LIST.get_or_init(|| {
        vec![
            FixedItem {
                code: "repro_xv_updates_red_poster".to_owned(),
                name: ansi!("red poster").to_owned(),
                description: "A larger faded poster with a thick red border. It says:\n\
                              \t\"Dear newly memory wiped citizen! Welcome to Melbs! A lot \
                              has changed since the memories your implant is based on were \
                              created. The global Gazos-Murlison Co empire fell in a nuclear \
                              attack, and most cities of the world were destroyed. \
                              A few cities around Australia, like this one, took some fallout \
                              but survived. The few remaining cities are now all independently \
                              run. I was a young governor under the empire, and I now rule inner \
                              Melbs as the King. I have gotten all the fallout out from the inner city, \
                              and I have a robot police force to keep you safe from the worst baddies, \
                              but be warned - there still are some dangers near by, and the world \
                              further out, outside my realm, is a dangerous and radioactive place.\"".to_owned(),
                location: "room/repro_xv_updates".to_owned(),
                proper_noun: false,
                aliases: vec!["poster".to_owned()],
                ..Default::default()
            },
        ].into_iter()
            .chain(computer_museum::fixed_items().into_iter())
            .chain(melbs::fixed_items().into_iter())
            .collect()
    })
}

pub fn fixed_item_properties() -> &'static BTreeMap<&'static str, PossessionData> {
    static PROPS: OnceCell<BTreeMap<&'static str, PossessionData>> = OnceCell::new();
    PROPS.get_or_init(|| {
        vec![]
            .into_iter()
            .chain(computer_museum::fixed_item_properties().into_iter())
            .chain(melbs::fixed_item_properties().into_iter())
            .collect()
    })
}

pub fn static_items() -> Box<dyn Iterator<Item = StaticItem>> {
    Box::new(fixed_item_list().iter().map(|r| StaticItem {
        item_code: r.code.clone(),
        initial_item: Box::new(|| Item {
            item_code: r.code.clone(),
            item_type: "fixed_item".to_owned(),
            display: r.name.clone(),
            details: Some(r.description.clone()),
            location: r.location.clone(),
            is_static: true,
            aliases: r.aliases.iter().map(|s| (*s).clone()).collect(),
            pronouns: Pronouns {
                is_proper: r.proper_noun,
                ..Pronouns::default_inanimate()
            },
            action_type: r.action_type.clone(),
            static_special_data: r.static_special_data.clone(),
            ..Item::default()
        }),
        extra_items_on_create: Box::new(|_| Box::new(std::iter::empty())),
    }))
}