use super::{npc_by_code, HireData, HireHandler, NPC};
#[double]
use crate::db::DBTrans;
use crate::{
    message_handler::{
        user_commands::{rent::recursively_destroy_or_move_item, UResult},
        ListenerSession,
    },
    models::item::{FollowData, FollowState, Item, ItemFlag, Pronouns, StatType},
    services::comms::broadcast_to_room,
    static_content::{possession_type::PossessionType, species::SpeciesType},
    DResult,
};
use ansi::ansi;
use async_trait::async_trait;
use mockall_double::double;
use serde::Deserialize;
use serde_yaml::from_str as from_yaml_str;

struct RoboporterHandler;

#[derive(Deserialize)]
struct RoboporterDesc {
    code: String,
    spawn_room: String,
}

#[async_trait]
impl HireHandler for RoboporterHandler {
    async fn hire_handler(
        &self,
        trans: &DBTrans,
        session: &ListenerSession,
        hirer: &Item,
        target: &mut Item,
    ) -> UResult<()> {
        target.following = Some(FollowData {
            follow_whom: hirer.refstr(),
            state: FollowState::Active,
        });
        trans.queue_for_session(session,
                                Some(ansi!("You hear a metalic voice croaking: \"Thanks for hiring a <blue>Roboporter<reset> brand transportation robot! Just <bold>load<reset> me up with heavy things you can't lift. I'll try to follow your every move as long as you keep me hired and paid. Simply <bold>unload<reset> me when you reach your destination. When you are done with me, just fire me! I'll unload everything if I can, or if not, for your convenience, I'll auto-burn it in my internal furnace, and then return home as fast as you can blink!\"\n"))).await?;
        Ok(())
    }
    async fn fire_handler(&self, trans: &DBTrans, _firer: &Item, target: &mut Item) -> DResult<()> {
        target.following = None;
        let stats = trans.get_location_stats(&target.location).await?;
        let mut remaining_space = if stats.total_count >= 50 {
            0
        } else {
            50 - stats.total_count
        };
        let mut msg = String::new();
        let desc = target.display_for_sentence(1, true);
        for item in trans.find_items_by_location(&target.refstr()).await? {
            if remaining_space > 0 {
                msg.push_str(&format!(
                    "{} unloads {} from {}\n",
                    &desc,
                    &item.display_for_sentence(1, false),
                    &target.pronouns.intensive
                ));
                let mut item_mut = (*item).clone();
                item_mut.location = target.location.clone();
                trans.save_item_model(&item_mut).await?;
                remaining_space -= 1;
            } else {
                msg.push_str(&format!("{} unloads {} - but since there isn't enough space to put it down, flicks it into the Roboporter's onboard furnace compartment!\n",
                                          &desc, &item.display_for_sentence(1, false),
                ));
                recursively_destroy_or_move_item(trans, &item).await?;
            }
        }
        let old_location = target.location.clone();
        if let Some(return_to) = npc_by_code()
            .get(target.item_code.as_str())
            .map(|npc| npc.spawn_location.as_str())
        {
            if return_to != &target.location {
                target.location = return_to.to_owned();
                msg.push_str(
                        &format!("By some marvel of modern engineering, {} disappears in a puff of smoke and is gone.\n",
                                 desc));
            }
        }
        broadcast_to_room(trans, &old_location, None, msg.as_str()).await?;
        Ok(())
    }
}

static ROBOPORTER_HANDLER: RoboporterHandler = RoboporterHandler;

pub fn npc_list() -> Vec<NPC> {
    from_yaml_str::<Vec<RoboporterDesc>>(include_str!("roboporter.yaml"))
        .unwrap()
        .into_iter()
        .map(|rp|
             NPC {
                 code: format!("roboporter_{}", &rp.code),
                 name: format!("Roboporter {}", &rp.code),
                 pronouns: Pronouns { is_proper: true, ..Pronouns::default_inanimate() },
                 description: "Standing at an imposing height of over 5 metres, and as wide as a truck, the Roboporter is a marvel of mechanical engineering. Its sturdy metallic frame is built for strength and endurance, with hydraulic joints that allow for precise movements. The body is covered in scuffs and scratches, evidence of its relentless hauling duties.\n\nEquipped with a plethora of massive storage compartments, the Roboporter was clearly designed to carry large and heavy loads with ease. Its reinforced chassis and powerful motors enable it to traverse all terrains, from rubble-strewn streets to treacherous wastelands. It seems to have hinges all over it so it can dynamically transform its shape to sqeeze through doors and haul cargo into indoor spaces too. The faint hum of its internal machinery is ever-present, a testament to its unwavering efficiency.\n\nThe Roboporter's front panel displays a digital interface, showcasing real-time diagnostics and its current operational status. A pair of bright LED lights function as its eyes, pulsating with a soft glow. It lacks any human-like features, emphasizing its purely functional design.\n\nDespite its lack of emotions, the Roboporter exudes an aura of dependability and reliability. It stands as a symbol of resilience in a world ravaged by chaos, ready to assist survivors in their quest for survival.".to_owned(),
            aliases: vec!("roboporter".to_owned()),
                 spawn_location: format!("room/{}", &rp.spawn_room),
                 intrinsic_weapon: Some(PossessionType::Fangs),
                 species: SpeciesType::Robot,
                 hire_data: Some(HireData {
                     handler: &ROBOPORTER_HANDLER,
                     frequency_secs: 600,
                     price: 100,
                 }),
                 extra_flags: vec![ItemFlag::CanLoad],
                 total_stats: vec![(StatType::Brawn, 20.0)].into_iter().collect(),
                 ..Default::default()
             }
        ).collect()
}