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

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

use crate::{
    types::{
        enums::target_user::TargetUser,
        structs::handler_entity::{ExtractedEntityData, HandlerEntity},
        TimeValues,
    },
    utils::{
        general::get_duration::{get_duration, ExtractedDuration},
        telegram::{restrict::restrict, try_do::try_restrict},
    },
};

pub async fn mute(
    handler_entity: HandlerEntity,
    chat_id: i64,
    user: TargetUser,
    time: TimeValues,
) -> HandlerResult {
    let (bot, message, mut sender_builder): ExtractedEntityData = handler_entity.extract();

    let user_id: i64 = match user.get_id() {
        Some(id) => id,
        None => {
            sender_builder
                .text("Ответьте на сообщение, чтобы замьютить участника чата.")
                .reply_to(message.id())
                .build()
                .send(&bot)
                .await
                .unwrap();
            return Ok(EventReturn::Cancel);
        }
    };

    sleep(Duration::from_millis(time.1)).await;

    let (unmute_date, postfix, mute_duration): ExtractedDuration = get_duration(time);
    let demote_args: (&Bot, i64, i64) = (&bot, user_id, chat_id);
    let callback = || async { restrict(&bot, user_id, unmute_date, chat_id).await };

    sender_builder.set_text("Невозможно замьютить участника чата, демотните и попробуйте снова");

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

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

        Ok(EventReturn::Finish)
    }
}