use telers::{
    event::{telegram::HandlerResult, EventReturn},
    methods::RestrictChatMember,
    types::{ChatPermissions, Message},
    Bot,
};

use crate::types::{
    enums::target_user::TargetUser,
    structs::{handler_entity::HandlerEntity, message_sender::MessageSenderBuilder},
};

pub async fn unmute(
    handler_entity: HandlerEntity,
    chat_id: i64,
    user: TargetUser,
) -> HandlerResult {
    let (bot, message, sender_builder): (Bot, Message, MessageSenderBuilder) = (
        handler_entity.bot_instance,
        handler_entity.message_reciever,
        handler_entity.message_sender_builder,
    );

    let user_id: i64 = match user {
        TargetUser::Id(id) => id,
        TargetUser::Reply => message.reply_to_message().unwrap().from().unwrap().id,
        _ => {
            return Ok(EventReturn::Cancel);
        }
    };

    let default_member_permissions = ChatPermissions::all()
        .can_change_info(false)
        .can_manage_topics(false)
        .can_invite_users(false)
        .can_pin_messages(false);

    let bot_action = RestrictChatMember::new(chat_id, user_id, default_member_permissions);

    if let Err(error) = bot.send(bot_action).await {
        sender_builder
            .text(format!(
                "Невозможно снять мьют с участника чата по причине: {error:?}"
            ))
            .build()
            .send(&bot)
            .await?;
        Ok(EventReturn::Cancel)
    } else {
        sender_builder
            .reply_to(message.id())
            .text("С пользователя был снят мьут.")
            .build()
            .send(&bot)
            .await
            .unwrap();
        Ok(EventReturn::Finish)
    }
}