use super::{
    get_player_item_or_fail, parsing::parse_count, search_items_for_user, user_error,
    ItemSearchParams, UResult, UserError, UserVerb, UserVerbRef, VerbContext,
};
use crate::{
    regular_tasks::queued_command::{
        queue_command_and_save, QueueCommand, QueueCommandHandler, QueuedCommandContext,
    },
    services::{
        capacity::recalculate_container_weight_mut,
        comms::broadcast_to_room,
        urges::{hunger_changed, thirst_changed},
    },
};
use ansi::ansi;
use async_trait::async_trait;
use std::{collections::BTreeMap, time};

pub struct QueueHandler;
#[async_trait]
impl QueueCommandHandler for QueueHandler {
    async fn start_command(&self, ctx: &mut QueuedCommandContext<'_>) -> UResult<time::Duration> {
        if ctx.item.death_data.is_some() {
            user_error(
                "You try to drink it, but your ghostly hands slip through it uselessly".to_owned(),
            )?;
        }
        let (item_type, item_code) = match ctx.command {
            QueueCommand::Drink {
                item_type,
                item_code,
            } => (item_type, item_code),
            _ => user_error("Unexpected command".to_owned())?,
        };
        let item = match ctx
            .trans
            .find_item_by_type_code(&item_type, &item_code)
            .await?
        {
            None => user_error("Item not found".to_owned())?,
            Some(it) => it,
        };
        if item.location != ctx.item.location && item.location != ctx.item.refstr() {
            user_error(format!(
                "You try to drink {} but realise you no longer have it",
                item.display_for_sentence(ctx.explicit().await?, 1, false)
            ))?
        }
        let msg = format!(
            "{} prepares to drink from {}\n",
            &ctx.item.display_for_sentence(true, 1, true),
            &item.display_for_sentence(true, 1, false)
        );
        broadcast_to_room(ctx.trans, &ctx.item.location, None, &msg).await?;
        Ok(time::Duration::from_secs(1))
    }

    #[allow(unreachable_patterns)]
    async fn finish_command(&self, ctx: &mut QueuedCommandContext<'_>) -> UResult<()> {
        if ctx.item.death_data.is_some() {
            user_error(
                "You try to drink it, but your ghostly hands slip through it uselessly".to_owned(),
            )?;
        }
        let (item_type, item_code) = match ctx.command {
            QueueCommand::Drink {
                item_type,
                item_code,
            } => (item_type, item_code),
            _ => user_error("Unexpected command".to_owned())?,
        };

        let item = match ctx
            .trans
            .find_item_by_type_code(&item_type, &item_code)
            .await?
        {
            None => user_error("Item not found".to_owned())?,
            Some(it) => it,
        };
        if item.location != ctx.item.location && item.location != ctx.item.refstr() {
            user_error(format!(
                "You try to drink {} but realise you no longer have it!",
                &item.display_for_sentence(ctx.explicit().await?, 1, false)
            ))?
        }
        let liquid_details = item
            .liquid_details
            .as_ref()
            .ok_or_else(|| UserError("You try to drink, but it's empty!".to_owned()))?;
        let mut it = liquid_details.contents.iter();
        let contents = it
            .next()
            .ok_or_else(|| UserError("You try to drink, but it's empty!".to_owned()))?;
        let contents_2 = it.next();
        if !contents_2.is_none() {
            user_error("It seems to be a weird mixture of different fluids... you are not sure you should drink it!".to_owned())?;
        }
        let drink_data = match contents.0.drink_data() {
            None => user_error(format!(
                "It smells like {}... you are not sure you should drink it!",
                contents.0.display()
            ))?,
            Some(v) => v,
        };

        let urges = ctx
            .item
            .urges
            .as_ref()
            .ok_or_else(|| UserError("You don't seem to have the thirst.".to_owned()))?;
        if (urges.thirst.value as i16) < -drink_data.thirst_impact {
            user_error("You don't seem to have the thirst.".to_owned())?;
        }
        let how_many_left = (if contents.1 <= &1 {
            1
        } else {
            contents.1.clone()
        }) as u64;
        let how_many_to_fill = if drink_data.thirst_impact >= 0 {
            1
        } else {
            urges.thirst.value / ((-drink_data.thirst_impact) as u16)
        };
        let how_many_drunk = how_many_to_fill.min(how_many_left.min(10000) as u16).max(1);

        let msg = format!(
            "{} drinks from {}\n",
            &ctx.item.display_for_sentence(true, 1, true),
            &item.display_for_sentence(true, 1, false)
        );
        broadcast_to_room(ctx.trans, &ctx.item.location, None, &msg).await?;

        if let Some(urges) = ctx.item.urges.as_mut() {
            urges.hunger.last_value = urges.hunger.value;
            urges.hunger.value = (urges.hunger.value as i64
                + (how_many_drunk as i64) * (drink_data.hunger_impact as i64))
                .clamp(0, 10000) as u16;
            urges.thirst.last_value = urges.thirst.value;
            urges.thirst.value = (urges.thirst.value as i64
                + (how_many_drunk as i64) * (drink_data.thirst_impact as i64))
                .clamp(0, 10000) as u16;
        }
        hunger_changed(&ctx.trans, &ctx.item).await?;
        thirst_changed(&ctx.trans, &ctx.item).await?;

        let mut item_mut = (*item).clone();
        if let Some(ld) = item_mut.liquid_details.as_mut() {
            if (*contents.1) <= how_many_drunk as u64 {
                ld.contents = BTreeMap::new();
            } else {
                ld.contents
                    .entry(contents.0.clone())
                    .and_modify(|v| *v -= how_many_drunk as u64);
            }
        }
        match item_mut.liquid_details.as_mut() {
            None => {}
            Some(ld) => {
                ld.contents = ld
                    .contents
                    .clone()
                    .into_iter()
                    .filter(|c| c.1 != 0)
                    .collect()
            }
        }
        recalculate_container_weight_mut(&ctx.trans, &mut item_mut).await?;
        ctx.trans.save_item_model(&item_mut).await?;
        Ok(())
    }
}

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

        if !remaining.starts_with("from ") {
            user_error(ansi!("Try <bold>drink from<reset> container.").to_owned())?;
        }
        remaining = remaining[5..].trim();

        let mut drink_limit = Some(1);
        if remaining == "all" || remaining.starts_with("all ") {
            remaining = remaining[3..].trim();
            drink_limit = None;
        } else if let (Some(n), remaining2) = parse_count(remaining) {
            drink_limit = Some(n);
            remaining = remaining2;
        }
        let targets = search_items_for_user(
            ctx,
            &ItemSearchParams {
                include_contents: true,
                include_loc_contents: true,
                limit: drink_limit.unwrap_or(100),
                ..ItemSearchParams::base(&player_item, &remaining)
            },
        )
        .await?;

        if player_item.death_data.is_some() {
            user_error(
                "You try to drink it, but your ghostly hands slip through it uselessly".to_owned(),
            )?;
        }

        for target in targets {
            if target.item_type != "possession" && target.item_type != "fixed_item" {
                user_error("You can't drink that!".to_owned())?;
            }
            if target.liquid_details.is_none() {
                user_error("There's nothing to drink!".to_owned())?;
            }
            queue_command_and_save(
                ctx,
                &player_item,
                &QueueCommand::Drink {
                    item_type: target.item_type.clone(),
                    item_code: target.item_code.clone(),
                },
            )
            .await?;
        }
        Ok(())
    }
}
static VERB_INT: Verb = Verb;
pub static VERB: UserVerbRef = &VERB_INT as UserVerbRef;