package Modules;

import CORE.Core;
import Manager.UserManager;
import Utility.KeyBoards;
import Utility.MessageConstants;
import Utility.User.MyUser;
import Utility.User.Roles;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.telegram.telegrambots.meta.api.methods.ParseMode;
import org.telegram.telegrambots.meta.api.methods.groupadministration.GetChatMember;
import org.telegram.telegrambots.meta.api.methods.groupadministration.RestrictChatMember;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.objects.*;
import org.telegram.telegrambots.meta.exceptions.TelegramApiException;

import java.time.Duration;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.TimeUnit;

public class ModCommands implements Module {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    private Core core;

    public ModCommands(Core core) {
        this.core = core;
    }

    public void execute(Update update) {

        //Filter for text not from bots
        if (update.hasMessage() && update.getMessage().hasText() && !update.getMessage().getFrom().getBot()) {

            //Filter for only Admins
            //TODO May implement for moderator
            //TODO implement Unban
            if (UserManager.checkAdmin(update.getMessage().getFrom().getId())) {

                ///////////////////////
                // BAN
                ///////////////////////
                if (update.getMessage().getText().matches("(?is:/ban.*)")) {

                    //Wenn auf etwas geantwortet banne User der nachricht
                    MyUser user;

                    //Ban via answer author
                    if (update.getMessage().isReply()) {

                        user = getUserFromReply(update.getMessage().getReplyToMessage());

                        //Sonst versuche einen User heraus zu lesen.
                    } else if (update.getMessage().hasEntities() || getUserFromEntetie(update.getMessage()) != null) {

                        org.telegram.telegrambots.meta.api.objects.User tgUser = getUserFromEntetie(update.getMessage());
                        user = new MyUser(tgUser.getId(), Core.getUserAsMention(tgUser), Roles.BLOCKED);

                        //sonst fehler
                    } else {
                        SendMessage message = new SendMessage()
                                .setChatId(update.getMessage().getChat().getId())
                                .setReplyToMessageId(update.getMessage().getMessageId())
                                .setText(MessageConstants.ERROR);
                        core.send_message(message);
                        return;
                    }

                    logger.debug("Command Ban by " + update.getMessage().getFrom().getId() + " - " + Core.getUserAsMention(update.getMessage().getFrom()));

                    SendMessage message = new SendMessage()
                            .setChatId((long) update.getMessage().getFrom().getId())
                            .setText(MessageConstants.MESSAGE_ADMINTOOLS_ABOUTTOBLOCK.replace("$user", user.getUserName()))
                            .setReplyMarkup(KeyBoards.buildBlockOptions(user))
                            .setParseMode(ParseMode.HTML);

                    core.send_message(message);

                    ///////////////////////
                    // Mute
                    ///////////////////////
                } else if (update.getMessage().getText().matches("(?is:/mute.*)")) {

                    //Wenn auf etwas geantwortet banne User der nachricht
                    MyUser user;

                    //Mute via answer author
                    if (update.getMessage().isReply()) {

                        user = getUserFromReply(update.getMessage().getReplyToMessage());

                        //Sonst versuche einen User heraus zu lesen.
                    } else if (update.getMessage().hasEntities() || getUserFromEntetie(update.getMessage()) != null) {

                        org.telegram.telegrambots.meta.api.objects.User tgUser = getUserFromEntetie(update.getMessage());
                        user = new MyUser(tgUser.getId(), Core.getUserAsMention(tgUser));
                    } else {
                        SendMessage message = new SendMessage()
                                .setChatId(update.getMessage().getChat().getId())
                                .setReplyToMessageId(update.getMessage().getMessageId())
                                .setText(MessageConstants.ERROR);
                        core.send_message(message);
                        return;
                    }

                    muteUser(user.getId());

                    SendMessage message = new SendMessage()
                            .setChatId(update.getMessage().getChat().getId())
                            .setReplyToMessageId(update.getMessage().getMessageId())
                            .setText("OK");
                    core.send_message(message);

                    //notify Admins about mute
                    message = new SendMessage()
                            .setText(
                                    MessageConstants.MESSAGE_PERMISSION_MUTED_ADMIN_FROM
                                            .replace("$user", user.getUserName())
                                            .replace("$admin", Core.getUserAsMention(update.getMessage().getFrom()))
                            )
                            .setParseMode(ParseMode.HTML);
                    core.send_message_toadmins(message);


                    ///////////////////////
                    // UnMute
                    ///////////////////////
                } else if (update.getMessage().getText().matches("(?is:/unmute.*)")) {

                    //Wenn auf etwas geantwortet banne User der nachricht
                    MyUser user;

                    //UnMute via answer author
                    if (update.getMessage().isReply()) {

                        user = getUserFromReply(update.getMessage().getReplyToMessage());

                        //Sonst versuche einen User heraus zu lesen.
                    } else if (update.getMessage().hasEntities() || getUserFromEntetie(update.getMessage()) != null) {

                        org.telegram.telegrambots.meta.api.objects.User tgUser = getUserFromEntetie(update.getMessage());
                        user = new MyUser(tgUser.getId(), Core.getUserAsMention(tgUser));

                    } else {
                        SendMessage message = new SendMessage()
                                .setChatId(update.getMessage().getChat().getId())
                                .setReplyToMessageId(update.getMessage().getMessageId())
                                .setText(MessageConstants.ERROR);
                        core.send_message(message);
                        return;
                    }

                    unMuteUser(user.getId());

                    SendMessage message = new SendMessage()
                            .setChatId(update.getMessage().getChat().getId())
                            .setReplyToMessageId(update.getMessage().getMessageId())
                            .setText("OK");
                    core.send_message(message);

                    //notify Admins about mute
                    message = new SendMessage()
                            .setText(
                                    MessageConstants.MESSAGE_PERMISSION_UNMUTED_ADMIN_FROM
                                            .replace("$user", user.getUserName())
                                            .replace("$admin", Core.getUserAsMention(update.getMessage().getFrom()))
                            )
                            .setParseMode(ParseMode.HTML);
                    core.send_message_toadmins(message);

                    ///////////////////////
                    // Grant
                    ///////////////////////
                } else if (update.getMessage().getText().matches("(?is:/promote.*)") || update.getMessage().getText().matches("(?is:/prom.*)")) {

                    //Wenn auf etwas geantwortet banne User der nachricht
                    MyUser user;

                    //Promote via answer author
                    if (update.getMessage().isReply()) {

                        user = getUserFromReply(update.getMessage().getReplyToMessage());

                        //Sonst versuche einen User heraus zu lesen.
                    } else if (update.getMessage().hasEntities() || getUserFromEntetie(update.getMessage()) != null) {

                        org.telegram.telegrambots.meta.api.objects.User tgUser = getUserFromEntetie(update.getMessage());
                        user = new MyUser(tgUser.getId(), Core.getUserAsMention(tgUser), Roles.GUEST);

                    } else {
                        SendMessage message = new SendMessage()
                                .setChatId(update.getMessage().getChat().getId())
                                .setReplyToMessageId(update.getMessage().getMessageId())
                                .setText(MessageConstants.ERROR);
                        core.send_message(message);
                        return;
                    }

                    core.getOpen_requests().put((long)user.getId(), new MyUser(user.getId(), user.getUserName(), Roles.GUEST));

                    SendMessage message = new SendMessage()
                            .setChatId((long) update.getMessage().getFrom().getId())
                            .setText(MessageConstants.MESSAGE_PERMISSION_OPENUSER_GUEST.replace("$user", user.getUserName()))
                            .setReplyMarkup(KeyBoards.buildRequestAnswers(user.getId()))
                            .setParseMode(ParseMode.HTML);
                    core.send_message(message);

                    //////////////////////////////
                    // Add Chat to WatchingChats
                    /////////////////////////////
                } else if (update.getMessage().getText().matches("(?is:/init)")) {

                    core.getWatchingChats().add(update.getMessage().getChat().getId());
                    core.saveWhatchingChats();

                    //////////////////////////////
                    // Add Chat to WatchingChats
                    /////////////////////////////
                } else if (update.getMessage().getText().matches("(?is:/exit)")) {

                    core.getWatchingChats().remove(update.getMessage().getChat().getId());
                    core.saveWhatchingChats();

                }
            }
        }
    }

    private void muteUser(int userID) {

        for (long chat : core.getWatchingChats()) {
            RestrictChatMember action = new RestrictChatMember()
                    .forTimePeriod(Duration.ofMinutes(Core.MUTETIMER))
                    .setCanSendMessages(false)
                    .setChatId(chat)
                    .setUserId(userID)
                    .setCanAddWebPagePreviews(false)
                    .setCanSendMediaMessages(false)
                    .setCanSendOtherMessages(false);
            try {
                action.validate();
                core.execute(action);

                new Timer().schedule(new TimerTask() {
                    @Override
                    public void run() {
                        unMuteUser(action.getUserId());
                    }
                }, TimeUnit.MINUTES.toMillis(Core.MUTETIMER));

            } catch (TelegramApiException e) {
                e.printStackTrace();
            }
        }
    }

    private void unMuteUser(int userID) {
        for (long chat : core.getWatchingChats()) {
            RestrictChatMember revoce = new RestrictChatMember()
                    .setCanSendMessages(true)
                    .setChatId(chat)
                    .setUserId(userID)
                    .setCanAddWebPagePreviews(true)
                    .setCanSendMediaMessages(true)
                    .setCanSendOtherMessages(true);
            try {
                revoce.validate();
                core.execute(revoce);
            } catch (TelegramApiException e) {
                e.printStackTrace();
            }
        }
    }

    private MyUser getUserFromEntetie(Message message) {

        for (MessageEntity x : message.getEntities()) {

            //if its no no username mention all good id is given
            if (x.getType().matches("(?i:text_mention)") && x.getUser() != null) {
                return new MyUser(x.getUser().getId(), Core.getUserAsMention(x.getUser()));

                //else ID is missing ... so look nake up
            } else if (x.getType().matches("(?i:mention)") && x.getUser() != null) {

                GetChatMember getChatMember = new GetChatMember()
                        .setChatId(x.getUser().getUserName());
                try {
                    getChatMember.validate();
                    User user = core.execute(getChatMember).getUser();
                    return new MyUser(user.getId(), Core.getUserAsMention(user));
                } catch (TelegramApiException e){
                    logger.error(e.getMessage());
                }
            }

        }

        return null;
    }

    private MyUser getUserFromReply(Message message){
        //if replay is to join message use the new chat member mentioned
        if (message.getNewChatMembers() != null && message.getNewChatMembers().size() > 0)
            return new MyUser(message.getNewChatMembers().get(0).getId(), Core.getUserAsMention(message.getNewChatMembers().get(0)));
        else
            return new MyUser(message.getFrom().getId(), Core.getUserAsMention(message.getFrom()), Roles.BLOCKED);    }
}