use super::{
    get_player_item_or_fail,
    map::{render_map, render_map_dyn},
    open::{is_door_in_direction, DoorSituation},
    search_item_for_user, user_error, UResult, UserError, UserVerb, UserVerbRef, VerbContext,
};
#[double]
use crate::db::DBTrans;
use crate::{
    db::ItemSearchParams,
    language,
    models::item::{
        DoorState, Item, ItemFlag, ItemSpecialData, LiquidDetails, LiquidType, LocationActionType,
        Subattack,
    },
    services::{combat::max_health, skills::calc_level_gap},
    static_content::{
        dynzone,
        possession_type::{possession_data, recipe_craft_by_recipe},
        room::{self, Direction},
        species::{species_info_map, SpeciesType},
    },
};
use ansi::{ansi, flow_around, word_wrap};
use async_trait::async_trait;
use itertools::Itertools;
use mockall_double::double;
use std::collections::BTreeSet;
use std::sync::Arc;

pub async fn describe_normal_item(
    player_item: &Item,
    ctx: &VerbContext<'_>,
    item: &Item,
) -> UResult<()> {
    let mut contents_desc = String::new();

    let mut items = ctx
        .trans
        .find_items_by_location(&format!("{}/{}", item.item_type, item.item_code))
        .await?;
    items.sort_unstable_by(|it1, it2| {
        (&it1.action_type)
            .cmp(&it2.action_type)
            .then((&it1.display).cmp(&it2.display))
    });

    let all_groups: Vec<Vec<&Arc<Item>>> = items
        .iter()
        .filter(|it| it.action_type != LocationActionType::Worn)
        .group_by(|i| (i.display_for_sentence(true, 1, false), &i.action_type))
        .into_iter()
        .map(|(_, g)| g.collect::<Vec<&Arc<Item>>>())
        .collect::<Vec<Vec<&Arc<Item>>>>();

    if all_groups.len() > 0 {
        contents_desc.push_str(&(language::caps_first(&item.pronouns.subject)));
        if item.item_type == "player" || item.item_type == "npc" {
            contents_desc.push_str("'s carrying ");
        } else {
            contents_desc.push_str(" contains ");
        }
        let mut phrases = Vec::<String>::new();
        for group_items in all_groups {
            let head = &group_items[0];
            let mut details = head.display_for_sentence(
                !ctx.session_dat.less_explicit_mode,
                group_items.len(),
                false,
            );
            match head.action_type {
                LocationActionType::Wielded => details.push_str(" (wielded)"),
                LocationActionType::Worn => continue,
                _ => {}
            }
            phrases.push(details);
        }
        let phrases_str: Vec<&str> = phrases.iter().map(|p| p.as_str()).collect();
        contents_desc.push_str(&(language::join_words(&phrases_str) + ".\n"));
    }

    if let Some(liq_data) = item
        .static_data()
        .and_then(|sd| sd.liquid_container_data.as_ref())
    {
        match item.liquid_details.as_ref() {
            Some(LiquidDetails { contents, .. }) if !contents.is_empty() => {
                let total_volume: u64 = contents.iter().map(|c| c.1.clone()).sum();
                let vol_frac = (total_volume as f64) / (liq_data.capacity as f64);
                if vol_frac >= 0.99 {
                    contents_desc.push_str("It's full to the top with");
                } else if vol_frac >= 0.75 {
                    contents_desc.push_str("It's nearly completely full of");
                } else if vol_frac > 0.6 {
                    contents_desc.push_str("It's more than half full of");
                } else if vol_frac > 0.4 {
                    contents_desc.push_str("It's about half full of");
                } else if vol_frac > 0.29 {
                    contents_desc.push_str("It's about a third full of");
                } else if vol_frac > 0.22 {
                    contents_desc.push_str("It's about a quarter full of");
                } else {
                    contents_desc.push_str("It contains a tiny bit of");
                }
                contents_desc.push_str(" ");
                let mut it = contents.iter();
                let f1_opt = it.next();
                let f2_opt = it.next();
                match (f1_opt, f2_opt) {
                    (Some((&LiquidType::Water, _)), None) => contents_desc.push_str("water"),
                    _ => contents_desc.push_str("mixed fluids"),
                }
                contents_desc.push_str(".\n");
            }

            _ => contents_desc.push_str("It's completely dry.\n"),
        }
    }

    let anything_worn = items
        .iter()
        .any(|it| it.action_type == LocationActionType::Worn);
    if anything_worn {
        let mut any_part_text = false;
        let mut seen_clothes: BTreeSet<String> = BTreeSet::new();
        for part in species_info_map()
            .get(&item.species)
            .map(|s| s.body_parts.clone())
            .unwrap_or_else(|| vec![])
        {
            if let Some((top_item, covering_parts)) = items
                .iter()
                .filter_map(|it| {
                    if it.action_type != LocationActionType::Worn {
                        None
                    } else {
                        it.possession_type
                            .as_ref()
                            .and_then(|pt| possession_data().get(&pt))
                            .and_then(|pd| pd.wear_data.as_ref())
                            .and_then(|wd| {
                                if wd.covers_parts.contains(&part) {
                                    Some((it, wd.covers_parts.clone()))
                                } else {
                                    None
                                }
                            })
                    }
                })
                .filter_map(|(it, parts)| it.action_type_started.map(|st| ((it, parts), st)))
                .max_by_key(|(_it, st)| st.clone())
                .map(|(it, _)| it)
            {
                any_part_text = true;
                let display = top_item.display_for_session(&ctx.session_dat);
                if !seen_clothes.contains(&display) {
                    seen_clothes.insert(display.clone());
                    contents_desc.push_str(&format!(
                        "On {} {}, you see {}. ",
                        &item.pronouns.possessive,
                        &language::join_words(
                            &covering_parts
                                .iter()
                                .map(|p| p.display(None))
                                .collect::<Vec<&'static str>>()
                        ),
                        &display
                    ));
                }
            } else {
                if !ctx.session_dat.less_explicit_mode {
                    any_part_text = true;
                    contents_desc.push_str(&format!(
                        "{} {} {} completely bare. ",
                        &language::caps_first(&item.pronouns.possessive),
                        part.display(item.sex.clone()),
                        part.copula(item.sex.clone())
                    ));
                }
            }
        }
        if any_part_text {
            contents_desc.push_str("\n");
        }
    } else if (item.item_type == "npc" || item.item_type == "player")
        && item.species == SpeciesType::Human
        && !ctx.session_dat.less_explicit_mode
    {
        contents_desc.push_str(&format!(
            "{} is completely naked.\n",
            &language::caps_first(&item.pronouns.subject)
        ));
    }

    let health_max = max_health(&item);
    if health_max > 0 {
        let health_ratio = (item.health as f64) / (health_max as f64);
        if item.item_type == "player" || item.item_type == "npc" {
            if health_ratio == 1.0 {
                contents_desc.push_str(&format!(
                    "{} is in perfect health.\n",
                    &language::caps_first(&item.pronouns.subject)
                ));
            } else if health_ratio >= 0.75 {
                contents_desc.push_str(&format!(
                    "{} has some minor cuts and bruises.\n",
                    &language::caps_first(&item.pronouns.subject)
                ));
            } else if health_ratio >= 0.5 {
                contents_desc.push_str(&format!(
                    "{} has deep wounds all over {} body.\n",
                    &language::caps_first(&item.pronouns.subject),
                    &item.pronouns.possessive
                ));
            } else if health_ratio >= 0.25 {
                contents_desc.push_str(&format!(
                    "{} looks seriously injured.\n",
                    &language::caps_first(&item.pronouns.subject)
                ));
            } else {
                contents_desc.push_str(&format!(
                    "{} looks like {}'s on death's door.\n",
                    &language::caps_first(&item.pronouns.subject),
                    &item.pronouns.possessive
                ));
            }

            if ctx
                .trans
                .check_task_by_type_code(
                    "DelayedHealth",
                    &format!("{}/{}/bandage", &item.item_type, &item.item_code),
                )
                .await?
            {
                contents_desc.push_str(&format!(
                    "{} is wrapped up in bandages.\n",
                    &language::caps_first(&item.pronouns.subject)
                ));
            }
        } else if item.item_type == "possession" {
            if health_ratio == 1.0 {
                contents_desc.push_str(&format!(
                    "{}'s in perfect condition.\n",
                    &language::caps_first(&item.pronouns.subject)
                ));
            } else if health_ratio >= 0.75 {
                contents_desc.push_str(&format!(
                    "{}'s slightly beaten up.\n",
                    &language::caps_first(&item.pronouns.subject)
                ));
            } else if health_ratio >= 0.5 {
                contents_desc.push_str(&format!(
                    "{}'s pretty beaten up.\n",
                    &language::caps_first(&item.pronouns.subject)
                ));
            } else if health_ratio >= 0.25 {
                contents_desc.push_str(&format!(
                    "{}'s seriously damaged.\n",
                    &language::caps_first(&item.pronouns.subject)
                ));
            } else {
                contents_desc.push_str(&format!(
                    "{}'s nearly completely destroyed.\n",
                    &language::caps_first(&item.pronouns.subject)
                ));
            }
        }
    }

    if item.item_type == "possession" {
        if let Some(charge_data) = item
            .possession_type
            .as_ref()
            .and_then(|pt| possession_data().get(&pt))
            .and_then(|pd| pd.charge_data.as_ref())
        {
            let unit = if item.charges == 1 {
                charge_data.charge_name_prefix.to_owned() + " " + charge_data.charge_name_suffix
            } else {
                language::pluralise(charge_data.charge_name_prefix)
                    + " "
                    + charge_data.charge_name_suffix
            };
            contents_desc.push_str(&format!("It has {} {} left.\n", item.charges, unit));
        }

        if let Some(recipe_craft_data) = item
            .possession_type
            .as_ref()
            .and_then(|pt| recipe_craft_by_recipe().get(pt))
        {
            contents_desc.push_str("You will need:\n");
            for (input_pt, count) in &recipe_craft_data.craft_data.inputs.iter().counts() {
                if let Some(pd) = possession_data().get(&input_pt) {
                    let thing = if ctx.session_dat.less_explicit_mode {
                        pd.display_less_explicit.unwrap_or(pd.display)
                    } else {
                        pd.display
                    };
                    contents_desc.push_str(&format!(
                        "  {} {}\n",
                        count,
                        &(if count != &1 {
                            language::pluralise(thing)
                        } else {
                            thing.to_owned()
                        })
                    ));
                }
            }
            match recipe_craft_data.bench.as_ref() {
                None => contents_desc.push_str("You can make this without any special bench.\n"),
                Some(bench) => {
                    if let Some(pd) = possession_data().get(bench) {
                        contents_desc.push_str(&format!(
                            "You'll need to make this on a {}.\n",
                            if ctx.session_dat.less_explicit_mode {
                                pd.display_less_explicit.unwrap_or(pd.display)
                            } else {
                                pd.display
                            }
                        ))
                    }
                }
            }
            let diff = calc_level_gap(
                &player_item,
                &recipe_craft_data.craft_data.skill,
                recipe_craft_data.craft_data.difficulty,
            );
            let challenge_level = if diff > 5.0 {
                "You are rather unlikely to succeed in making this."
            } else if diff >= 4.0 {
                "You're not that likely to succeed in making this, and you're likely to be too confused to learn anything making it."
            } else if diff >= 3.0 {
                "You've got about a 1/4 chance to succeed at making this, and you might learn something making it."
            } else if diff >= 2.0 {
                "You've got about a 1/3 chance to succeed at making this, and you might learn something making it."
            } else if diff >= 0.0 {
                "You've got a less than 50/50 chance to succeed at making this, and you'll probably learn a lot."
            } else if diff >= -2.0 {
                "You've got a better than 50/50 chance to succeed at making this, and you'll probably learn a lot."
            } else if diff >= -3.0 {
                "Three out of four times, you'll succeed at making this, and you might still learn something."
            } else if diff >= -4.0 {
                "Most of the time, you'll succeed at making this, but you'll only rarely learn something new."
            } else {
                "You're highly likely to succeed at making this, but unlikely to learn anything new."
            };
            contents_desc.push_str(&format!("{}\n", challenge_level));
        }
    }

    ctx.trans
        .queue_for_session(
            ctx.session,
            Some(&format!(
                "{}\n{}\n{}",
                &item.display_for_session(&ctx.session_dat),
                item.details_for_session(&ctx.session_dat).unwrap_or(""),
                contents_desc,
            )),
        )
        .await?;
    Ok(())
}

fn exits_for(room: &room::Room) -> String {
    let exit_text: Vec<String> = room
        .exits
        .iter()
        .map(|ex| {
            format!(
                "{}{}",
                if ex.exit_climb.is_some() {
                    ansi!("<red>^")
                } else {
                    ansi!("<yellow>")
                },
                ex.direction.describe()
            )
        })
        .collect();
    format!(
        ansi!("<cyan>[ Exits: <bold>{} <reset><cyan>]<reset>"),
        exit_text.join(" ")
    )
}

fn exits_for_dyn(dynroom: &dynzone::Dynroom) -> String {
    let exit_text: Vec<String> = dynroom
        .exits
        .iter()
        .map(|ex| format!(ansi!("<yellow>{}"), ex.direction.describe()))
        .collect();
    format!(
        ansi!("<cyan>[ Exits: <bold>{} <reset><cyan>]<reset>"),
        exit_text.join(" ")
    )
}

pub async fn describe_room(
    ctx: &VerbContext<'_>,
    item: &Item,
    room: &room::Room,
    contents: &str,
) -> UResult<()> {
    let zone = room::zone_details()
        .get(room.zone)
        .map(|z| z.display)
        .unwrap_or("Outside of time");
    ctx.trans
        .queue_for_session(
            ctx.session,
            Some(&flow_around(
                &render_map(room, 5, 5),
                10,
                ansi!("<reset>  "),
                &word_wrap(
                    &format!(
                        ansi!("<yellow>{}<reset> (<blue>{}<reset>)\n{}.{}\n{}\n"),
                        item.display_for_session(&ctx.session_dat),
                        zone,
                        item.details_for_session(&ctx.session_dat).unwrap_or(""),
                        contents,
                        exits_for(room)
                    ),
                    |row| if row >= 5 { 80 } else { 68 },
                ),
                68,
            )),
        )
        .await?;
    Ok(())
}

pub async fn describe_dynroom(
    ctx: &VerbContext<'_>,
    item: &Item,
    dynzone: &dynzone::Dynzone,
    dynroom: &dynzone::Dynroom,
    contents: &str,
) -> UResult<()> {
    ctx.trans
        .queue_for_session(
            ctx.session,
            Some(&flow_around(
                &render_map_dyn(dynzone, dynroom, 5, 5),
                10,
                ansi!("<reset>  "),
                &word_wrap(
                    &format!(
                        ansi!("<yellow>{}<reset> (<blue>{}<reset>)\n{}.{}\n{}\n"),
                        item.display_for_session(&ctx.session_dat),
                        dynzone.zonename,
                        item.details_for_session(&ctx.session_dat).unwrap_or(""),
                        contents,
                        exits_for_dyn(dynroom)
                    ),
                    |row| if row >= 5 { 80 } else { 68 },
                ),
                68,
            )),
        )
        .await?;
    Ok(())
}

async fn describe_door(
    ctx: &VerbContext<'_>,
    room_item: &Item,
    state: &DoorState,
    direction: &Direction,
) -> UResult<()> {
    let mut msg = format!("That exit is blocked by {}.", &state.description);
    if let Some(lock) = ctx
        .trans
        .find_by_action_and_location(
            &room_item.refstr(),
            &LocationActionType::InstalledOnDoorAsLock((*direction).clone()),
        )
        .await?
        .first()
    {
        let lock_desc = lock.display_for_session(&ctx.session_dat);
        msg.push_str(&format!(" The door is locked with {}", &lock_desc));
    }
    msg.push('\n');
    ctx.trans.queue_for_session(ctx.session, Some(&msg)).await?;
    Ok(())
}

async fn list_room_contents<'l>(ctx: &'l VerbContext<'_>, item: &'l Item) -> UResult<String> {
    if item.flags.contains(&ItemFlag::NoSeeContents) {
        return Ok(" It is too foggy to see who or what else is here.".to_owned());
    }
    let mut buf = String::new();
    let mut items = ctx
        .trans
        .find_items_by_location(&format!("{}/{}", item.item_type, item.item_code))
        .await?;
    items.sort_unstable_by(|it1, it2| (&it1.display).cmp(&it2.display));

    let all_groups: Vec<Vec<&Arc<Item>>> = items
        .iter()
        .filter(|i| i.action_type.is_visible_in_look())
        .group_by(|i| i.display_for_sentence(true, 1, false))
        .into_iter()
        .map(|(_, g)| g.collect::<Vec<&Arc<Item>>>())
        .collect::<Vec<Vec<&Arc<Item>>>>();

    for group_items in all_groups {
        let head = &group_items[0];
        let is_creature = head.item_type == "player" || head.item_type.starts_with("npc");
        buf.push(' ');
        buf.push_str(&head.display_for_sentence(
            !ctx.session_dat.less_explicit_mode,
            group_items.len(),
            true,
        ));
        buf.push_str(if group_items.len() > 1 {
            " are "
        } else {
            " is "
        });
        match head.action_type {
            LocationActionType::Sitting(ref on) => {
                buf.push_str("sitting ");
                if let Some((on_type, on_code)) =
                    on.as_ref().and_then(|on_ref| on_ref.split_once("/"))
                {
                    if let Some(sit_on) = ctx.trans.find_item_by_type_code(on_type, on_code).await?
                    {
                        buf.push_str("on ");
                        buf.push_str(&sit_on.display_for_session(&ctx.session_dat));
                    }
                }
            }
            LocationActionType::Reclining(ref on) => {
                buf.push_str("reclining ");
                if let Some((on_type, on_code)) =
                    on.as_ref().and_then(|on_ref| on_ref.split_once("/"))
                {
                    if let Some(sit_on) = ctx.trans.find_item_by_type_code(on_type, on_code).await?
                    {
                        buf.push_str("on ");
                        buf.push_str(&sit_on.display_for_session(&ctx.session_dat));
                    }
                }
            }
            LocationActionType::Normal | LocationActionType::Attacking(_) if is_creature => {
                if head.death_data.is_some() {
                    buf.push_str("lying ");
                } else {
                    buf.push_str("standing ");
                }
            }
            _ => {}
        }
        buf.push_str("here");
        if let LocationActionType::Attacking(subattack) = &head.action_type {
            match subattack {
                Subattack::Powerattacking => buf.push_str(", powerattacking "),
                Subattack::Feinting => buf.push_str(", feinting "),
                Subattack::Grabbing => buf.push_str(", grabbing "),
                Subattack::Wrestling => buf.push_str(", wrestling "),
                _ => buf.push_str(", attacking "),
            }
            match &head
                .active_combat
                .as_ref()
                .and_then(|ac| ac.attacking.clone())
                .or_else(|| head.presence_target.clone())
            {
                None => buf.push_str("someone"),
                Some(who) => match who.split_once("/") {
                    None => buf.push_str("someone"),
                    Some((ttype, tcode)) => {
                        match ctx.trans.find_item_by_type_code(ttype, tcode).await? {
                            None => buf.push_str("someone"),
                            Some(it) => buf.push_str(&it.display_for_session(&ctx.session_dat)),
                        }
                    }
                },
            }
        }
        buf.push('.');
    }
    Ok(buf)
}

pub async fn direction_to_item(
    trans: &DBTrans,
    use_location: &str,
    direction: &Direction,
) -> UResult<Option<Arc<Item>>> {
    // Firstly check dynamic exits, since they apply to rooms and dynrooms...
    if let Some(dynroom_result) = trans.find_exact_dyn_exit(use_location, direction).await? {
        return Ok(Some(Arc::new(dynroom_result)));
    }

    let (heretype, herecode) = use_location
        .split_once("/")
        .unwrap_or(("room", "repro_xv_chargen"));

    if heretype == "dynroom" {
        let old_dynroom_item = match trans.find_item_by_type_code(heretype, herecode).await? {
            None => user_error("Your current room has vanished!".to_owned())?,
            Some(v) => v,
        };
        let (dynzone_code, dynroom_code) = match old_dynroom_item.special_data.as_ref() {
            Some(ItemSpecialData::DynroomData {
                dynzone_code,
                dynroom_code,
            }) => (dynzone_code, dynroom_code),
            _ => user_error("Your current room is invalid!".to_owned())?,
        };
        let dynzone = dynzone::dynzone_by_type()
            .get(
                &dynzone::DynzoneType::from_str(dynzone_code).ok_or_else(|| {
                    UserError("The type of your current zone no longer exists".to_owned())
                })?,
            )
            .ok_or_else(|| {
                UserError("The type of your current zone no longer exists".to_owned())
            })?;
        let dynroom = dynzone
            .dyn_rooms
            .get(dynroom_code.as_str())
            .ok_or_else(|| UserError("Your current room type no longer exists".to_owned()))?;
        let exit = dynroom
            .exits
            .iter()
            .find(|ex| ex.direction == *direction)
            .ok_or_else(|| UserError("There is nothing in that direction".to_owned()))?;
        return match exit.target {
            dynzone::ExitTarget::ExitZone => {
                let (zonetype, zonecode) = old_dynroom_item
                    .location
                    .split_once("/")
                    .ok_or_else(|| UserError("Invalid zone for your room".to_owned()))?;
                let zoneitem = trans
                    .find_item_by_type_code(zonetype, zonecode)
                    .await?
                    .ok_or_else(|| UserError("Can't find your zone".to_owned()))?;
                let zone_exit = match zoneitem.special_data.as_ref() {
                    Some(ItemSpecialData::DynzoneData {
                        zone_exit: None, ..
                    }) => user_error("That exit doesn't seem to go anywhere".to_owned())?,
                    Some(ItemSpecialData::DynzoneData {
                        zone_exit: Some(zone_exit),
                        ..
                    }) => zone_exit,
                    _ => user_error(
                        "The zone you are in has invalid data associated with it".to_owned(),
                    )?,
                };
                let (zone_exit_type, zone_exit_code) =
                    zone_exit.split_once("/").ok_or_else(|| {
                        UserError("Oops, that way out seems to be broken.".to_owned())
                    })?;
                Ok(trans
                    .find_item_by_type_code(zone_exit_type, zone_exit_code)
                    .await?)
            }
            dynzone::ExitTarget::Intrazone { subcode } => {
                let to_item = trans
                    .find_item_by_location_dynroom_code(&old_dynroom_item.location, &subcode)
                    .await?
                    .ok_or_else(|| {
                        UserError("Can't find the room in that direction.".to_owned())
                    })?;
                Ok(Some(Arc::new(to_item)))
            }
        };
    }
    if heretype != "room" {
        user_error("Navigating outside rooms not yet supported.".to_owned())?
    }
    let room = room::room_map_by_code()
        .get(herecode)
        .ok_or_else(|| UserError("Can't find your current location".to_owned()))?;
    let exit = room
        .exits
        .iter()
        .find(|ex| ex.direction == *direction)
        .ok_or_else(|| UserError("There is nothing in that direction".to_owned()))?;
    let new_room = room::resolve_exit(room, exit)
        .ok_or_else(|| UserError("Can't find that room".to_owned()))?;
    Ok(trans.find_item_by_type_code("room", new_room.code).await?)
}

pub struct Verb;
#[async_trait]
impl UserVerb for Verb {
    async fn handle(
        self: &Self,
        ctx: &mut VerbContext,
        _verb: &str,
        remaining: &str,
    ) -> UResult<()> {
        let player_item = get_player_item_or_fail(ctx).await?;

        let mut rem_trim = remaining.trim().to_lowercase();
        let rem_orig = rem_trim.clone();
        if rem_trim.starts_with("in ") {
            rem_trim = rem_trim[3..].trim_start().to_owned();
        }
        let use_location = if player_item.death_data.is_some() {
            "room/repro_xv_respawn"
        } else {
            &player_item.location
        };
        let (heretype, herecode) = use_location
            .split_once("/")
            .unwrap_or(("room", "repro_xv_chargen"));
        let item: Arc<Item> = if rem_trim == "" {
            ctx.trans
                .find_item_by_type_code(heretype, herecode)
                .await?
                .ok_or_else(|| UserError("Sorry, that no longer exists".to_owned()))?
        } else if let Some(dir) =
            Direction::parse(&rem_trim).or_else(|| Direction::parse(&rem_orig))
        {
            // This is complex because "in" is overloaded, and if this fails, we want
            // to also consider if they are looking in a container.
            match is_door_in_direction(&ctx.trans, &dir, use_location).await {
                Ok(DoorSituation::NoDoor)
                | Ok(DoorSituation::DoorOutOfRoom {
                    state: DoorState { open: true, .. },
                    ..
                })
                | Ok(DoorSituation::DoorIntoRoom {
                    state: DoorState { open: true, .. },
                    ..
                })
                | Err(UserError(_)) => {}
                Ok(DoorSituation::DoorIntoRoom {
                    state,
                    room_with_door,
                    ..
                }) => {
                    if let Some(rev_dir) = dir.reverse() {
                        return describe_door(ctx, &room_with_door, &state, &rev_dir).await;
                    }
                }
                Ok(DoorSituation::DoorOutOfRoom {
                    state,
                    room_with_door,
                    ..
                }) => {
                    return describe_door(ctx, &room_with_door, &state, &dir).await;
                }
                Err(e) => Err(e)?,
            }
            match direction_to_item(&ctx.trans, use_location, &dir).await {
                Ok(Some(item)) => item,
                Ok(None) | Err(UserError(_)) => search_item_for_user(
                    &ctx,
                    &ItemSearchParams {
                        include_contents: true,
                        include_loc_contents: true,
                        limit: 1,
                        ..ItemSearchParams::base(&player_item, &rem_trim)
                    },
                )
                .await
                .map_err(|e| match e {
                    UserError(_) => UserError("There's nothing in that direction".to_owned()),
                    e => e,
                })?,
                Err(e) => Err(e)?,
            }
        } else if rem_trim == "me" || rem_trim == "self" {
            player_item.clone()
        } else {
            search_item_for_user(
                &ctx,
                &ItemSearchParams {
                    include_contents: true,
                    include_loc_contents: true,
                    limit: 1,
                    ..ItemSearchParams::base(&player_item, &rem_trim)
                },
            )
            .await?
        };
        if item.item_type == "room" {
            let room = room::room_map_by_code()
                .get(item.item_code.as_str())
                .ok_or_else(|| UserError("Sorry, that room no longer exists".to_owned()))?;
            describe_room(ctx, &item, &room, &list_room_contents(ctx, &item).await?).await?;
        } else if item.item_type == "dynroom" {
            let (dynzone, dynroom) = match &item.special_data {
                Some(ItemSpecialData::DynroomData {
                    dynzone_code,
                    dynroom_code,
                }) => dynzone::DynzoneType::from_str(dynzone_code.as_str())
                    .and_then(|dz_t| dynzone::dynzone_by_type().get(&dz_t))
                    .and_then(|dz| dz.dyn_rooms.get(dynroom_code.as_str()).map(|dr| (dz, dr)))
                    .ok_or_else(|| UserError("Dynamic room doesn't exist anymore.".to_owned()))?,
                _ => user_error("Expected dynroom to have DynroomData".to_owned())?,
            };
            describe_dynroom(
                ctx,
                &item,
                &dynzone,
                &dynroom,
                &list_room_contents(ctx, &item).await?,
            )
            .await?;
        } else {
            describe_normal_item(&player_item, ctx, &item).await?;
        }
        Ok(())
    }
}
static VERB_INT: Verb = Verb;
pub static VERB: UserVerbRef = &VERB_INT as UserVerbRef;