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

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

use crate::{
    types::{
        enums::time_metrics::TimeMetrics,
        structs::{
            countable_time::CountableTime, handler_entity::HandlerEntity,
            message_sender::MessageSenderBuilder,
        },
        traits::countable_interface::ICountable,
    },
    utils::{
        general::unrestrict_date::unrestrict_date,
        telegram::{restrict::restrict, try_do::try_restrict},
    },
};

type HandlerEntityExtract = (Bot, Message, MessageSenderBuilder);
type TimeValues = (TimeMetrics, u64);

pub async fn mute(
    handler_entity: HandlerEntity,
    chat_id: i64,
    values: TimeValues,
) -> HandlerResult {
    let (bot, message, sender_builder): HandlerEntityExtract = (
        handler_entity.bot_instance,
        handler_entity.message_reciever,
        handler_entity.message_sender_builder,
    );
    let (metric, delay): TimeValues = values;

    let reply_to: Message;

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

    sleep(Duration::from_millis(delay)).await;

    let user: &User = reply_to.from().unwrap();

    let time_duration = metric.extract();

    let postfix = CountableTime::from_value(time_duration)
        .get_postfix(metric)
        .unwrap();
    let unmute_date = unrestrict_date(time_duration);

    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_builder
        .clone()
        .text("Невозможно замьютить участника чата, демотните и попробуйте снова");

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

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

        Ok(EventReturn::Finish)
    }
}