use futures::stream::futures_unordered;
use telers::{
    event::{telegram::HandlerResult, EventReturn},
    types::{Message, User},
    Bot,
};

use tokio::time::{sleep, Duration as DurationSleep};

use crate::{
    types::{
        enums::time_metrics::TimeMetrics,
        structs::{
            bot_entity::BotEntity, countable_time::CountableTime, message_sender::MessageSender,
        },
        traits::countable_interface::ICountable,
    },
    utils::telegram::try_do_action::try_restrict,
};

use crate::utils::{general::unrestrict_date::unrestrict_date, telegram::restrict::restrict};

pub async fn mute(bot_entity: BotEntity, values: (TimeMetrics, u64)) -> HandlerResult {
    let (bot, message, sender): (Bot, Message, MessageSender) = (
        bot_entity.bot_instance,
        bot_entity.receive_message,
        bot_entity.message_sender,
    );

    let reply_to: Message;
    let chat_id: i64 = message.chat().id();

    if let Some(msg) = message.reply_to_message() {
        reply_to = msg.clone();
    } else {
        sender
            .reply_to(message.id())
            .text("Ответьте на сообщение, чтобы замьютить.")
            .send(&bot)
            .await?;
        return Ok(EventReturn::Cancel);
    }

    let user_data: &User = reply_to.from().unwrap();
    let user_id: i64 = user_data.id;

    sleep(DurationSleep::from_millis(values.1)).await;

    let time_duration = values.0.extract();
    let unmute_date = unrestrict_date(time_duration);
    let postfix = CountableTime::from_value(time_duration)
        .get_postfix(values.0)
        .unwrap();

    let future = || async { restrict(&bot, user_id, unmute_date, chat_id).await };
    let demote_args: (&Bot, i64, i64) = (&bot, user_id, chat_id);
    let failure_sender: MessageSender = sender
        .clone()
        .text("Невозможно замьютить участника чата, демотните и попробуйте снова");

    if try_restrict(future, demote_args, failure_sender)
        .await
        .is_err()
    {
        Ok(EventReturn::Cancel)
    } else {
        let muted_user_name = reply_to.from().unwrap().clone().username.unwrap();

        sender
            .reply_to(message.id())
            .text(format!(
                "Пользователь {} замьючен на {:?} {}.",
                muted_user_name, time_duration, postfix
            ))
            .send(&bot)
            .await?;

        Ok(EventReturn::Finish)
    }
}