package Modules;

import CORE.Core;
import Manager.ChatManager;
import Manager.UserManager;
import Utility.MessageConstants;
import Utility.User.MyUser;
import Utility.User.Roles;
import Utility.User.State;
import Utility.User.UserPermission;

import Utility.chat.Chat;
import Utility.chat.ChatCategory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.telegram.telegrambots.meta.api.methods.ParseMode;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.methods.updatingmessages.EditMessageText;
import org.telegram.telegrambots.meta.api.objects.Update;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.InlineKeyboardMarkup;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.InlineKeyboardButton;

import java.net.MalformedURLException;
import java.net.URL;
import java.util.*;

import static java.lang.Math.toIntExact;
import static Utility.KeyBoards.*;

public class AdminMenue implements Module{

    private static Logger log = LoggerFactory.getLogger(AdminMenue.class);

    private Core core;

    private Map<Long, Chat> adminAddChatMap;
    private Map<Long, Long> adminCurrentCategoryMap;

    public AdminMenue(Core core) {
        this.core = core;

        this.adminAddChatMap = new HashMap<>();
        this.adminCurrentCategoryMap = new HashMap<>();

    }

    public void execute(Update update) {

        /*----------Update has text----------*/

        //////////////////////////////////
        //  HAS TEXT
        /////////////////////////////////

        if (update.hasMessage() && update.getMessage().getChat().isUserChat() && update.getMessage().hasText() && UserManager.checkAdmin(update.getMessage().getFrom().getId())) {

            long user_id = update.getMessage().getFrom().getId();

            String text = update.getMessage().getText();

            State state = core.getUserMap().containsKey(user_id) ? core.getUserMap().get(user_id).getState() : null;

            /*----------Admin sent username to find a user----------*/

            if (state == State.ADMIN_LOADUSER && !text.equals("/cancel")) {
                loadUserEntry(Long.parseLong(text), user_id);
            }

            /*----------Admin sent username to unblock a user----------*/

            else if (state == State.ADMIN_UNBLOCKUSER && !text.equals("/cancel")) {
                MyUser blockedUser = UserManager.loadBlockedUser(Long.parseLong(text));

                // User wasn't found
                if (blockedUser == null) {
                    SendMessage message = new SendMessage().setChatId(user_id).setParseMode(ParseMode.HTML).setText(
                            MessageConstants.MESSAGE_ADMINTOOLS_USERNOTFOUND);

                    core.send_message(message);
                } else {
                    log.info(" - unblocked user: " + blockedUser.getUserName());
                    core.getUserMap().get(user_id).setState(null);

                    UserManager.unblock(blockedUser.getId(), core);

                    SendMessage message = new SendMessage();

                    InlineKeyboardMarkup keyboard = buildBackButtonAdmintools();

                    String message_text = MessageConstants.MESSAGE_ADMINTOOLS_USERUNBLOCKED.replace("$user",
                            blockedUser.getUserName());

                    message.setChatId(user_id).setParseMode(ParseMode.HTML).setReplyMarkup(keyboard).setText(
                            message_text);

                    core.send_message(message);
                }
            }

            // Admin is about to create a new Category
            else if (state == State.ADMIN_ADDCHATCATEGORY) {
                long uid = ChatManager.getBiggestChatCategoryUid() + 1;
                ChatManager.addCategory(new ChatCategory(uid, text));

                InlineKeyboardMarkup keyboardMarkup = buildCategoriesMenu(user_id);

                SendMessage message = new SendMessage().setChatId(user_id).setParseMode(ParseMode.HTML).setReplyMarkup(
                        keyboardMarkup).setText(MessageConstants.MESSAGE_CHATS_CATEGORYADDED);

                core.getUserMap().get(user_id).setState(null);
                core.send_message(message);
            }

            // Admin sent a UID for a new chat
            else if ((state == State.ADMIN_ADDCHATUID) && (!text.equalsIgnoreCase("/cancel"))) {
                //Check if UID is actually a number
                if (!text.matches("\\d+")) {

                    SendMessage message = new SendMessage()
                            .setParseMode(ParseMode.HTML)
                            .setChatId(user_id)
                            .setText(MessageConstants.MESSAGE_CHATS_NOTANUMBER);

                    core.send_message(message);

                }
                //Check if a chat with that UID might allready exist
                else if (ChatManager.checkChatUID(Long.parseLong(text))) {

                    SendMessage message = new SendMessage()
                            .setParseMode(ParseMode.HTML)
                            .setChatId(user_id)
                            .setText(MessageConstants.MESSAGE_CHATS_CHATEXISTSALLREADY);

                    core.send_message(message);

                }
                //Check if UID is only 4 chars long
                else if (text.length() > 4) {
                    SendMessage message = new SendMessage()
                            .setParseMode(ParseMode.HTML)
                            .setChatId(user_id)
                            .setText(MessageConstants.MESSAGE_CHATS_CHATNUMBERTOLONG);

                    core.send_message(message);
                }
                //UID seems okay, save it and ask for name
                else {
                    long uid = Long.parseLong(text);
                    adminAddChatMap.put(user_id, new Chat(uid, null));

                    SendMessage message = new SendMessage()
                            .setChatId(user_id)
                            .setParseMode(ParseMode.HTML)
                            .setText(MessageConstants.MESSAGE_CHATS_ADDCHATNAME);

                    core.getUserMap().get(user_id).setState(State.ADMIN_ADDCHATNAME);

                    core.send_message(message);
                }
            }

            // Admin send a Chatname (anything is okay as a chatname, so just save it and ask for URL)
            else if ((state == State.ADMIN_ADDCHATNAME) && (!text.equalsIgnoreCase("/cancel"))) {
                long uid = adminAddChatMap.get(user_id).getUid();

                adminAddChatMap.remove(user_id);
                adminAddChatMap.put(user_id, new Chat(uid, text));

                SendMessage message = new SendMessage()
                        .setChatId(user_id)
                        .setParseMode(ParseMode.HTML)
                        .setText(MessageConstants.MESSAGE_CHATS_ADDURL);

                core.getUserMap().get(user_id).setState(State.ADMIN_ADDCHATURL);

                core.send_message(message);
            }

            //Admin send a URL for a chat
            else if ((state == State.ADMIN_ADDCHATURL) && (!text.equalsIgnoreCase("/cancel"))) {
                try {
                    URL url = new URL(text);
                    //UrlValidator validator = new UrlValidator();

                    //if (validator.isValid(text)) {
                    Chat chat = (Chat) adminAddChatMap.get(user_id);
                    chat.setUrl(text);

                    InlineKeyboardMarkup keyboardMarkup = buildPossiblePermissions();
                    SendMessage message = new SendMessage()
                            .setChatId(user_id)
                            .setParseMode(ParseMode.HTML)
                            .setReplyMarkup(keyboardMarkup)
                            .setText(MessageConstants.MESSAGE_CHATS_ADDPERMISSION);

                    core.getUserMap().get(user_id).setState(null);

                    core.send_message(message);

                } catch (MalformedURLException e) {
                    SendMessage message = new SendMessage()
                            .setChatId(user_id)
                            .setParseMode(ParseMode.HTML)
                            .setText(MessageConstants.MESSAGE_CHATS_NOTAURL);

                    core.send_message(message);
                }
            }

            //
            else if ((state == State.ADMIN_EDITCHAT) && (!text.equalsIgnoreCase("/cancel"))) {
                if (!text.matches("\\d+")) {
                    SendMessage message = new SendMessage()
                            .setChatId(user_id)
                            .setParseMode(ParseMode.HTML)
                            .setText(MessageConstants.MESSAGE_CHATS_NOTFOUND);

                    core.send_message(message);
                    return;
                }

                Chat chat = ChatManager.loadChatFromCategory(Long.parseLong(text), adminCurrentCategoryMap.get(user_id));

                if (chat == null)
                {
                    SendMessage message = new SendMessage()
                            .setChatId(user_id)
                            .setParseMode(ParseMode.HTML)
                            .setText(MessageConstants.MESSAGE_CHATS_NOTFOUND);

                    core.send_message(message);
                } else {
                    InlineKeyboardMarkup keyboardMarkup = buildEditChat(chat, adminCurrentCategoryMap.get(user_id));

                    String respond = MessageConstants.MESSAGE_CHATS_CHATFOUND.replace("$fullname", chat.getFullName()).replace("$permission", chat.getPermissionNeeded().toString()).replace("$url", chat.getUrl());

                    SendMessage message = new SendMessage()
                            .setChatId(user_id)
                            .setParseMode(ParseMode.HTML)
                            .setReplyMarkup(keyboardMarkup)
                            .setText(respond);

                    core.send_message(message);
                }

            }
            else if ((state == State.ADMIN_CHANGECHATUID) && (!text.equalsIgnoreCase("/cancel"))) {
                if (!text.matches("\\d+"))
                {
                    SendMessage message = new SendMessage()
                            .setParseMode(ParseMode.HTML)
                            .setChatId(user_id)
                            .setText(MessageConstants.MESSAGE_CHATS_NOTANUMBER);

                    core.send_message(message);
                } else if (ChatManager.checkChatUID(Long.parseLong(text)))
                {
                    SendMessage message = new SendMessage()
                            .setParseMode(ParseMode.HTML)
                            .setChatId(user_id)
                            .setText(MessageConstants.MESSAGE_CHATS_CHATEXISTSALLREADY);

                    core.send_message(message);
                } else if (text.length() > 4)
                {
                    SendMessage message = new SendMessage()
                            .setParseMode(ParseMode.HTML)
                            .setChatId(user_id)
                            .setText(MessageConstants.MESSAGE_CHATS_CHATNUMBERTOLONG);

                    core.send_message(message);
                } else {
                    long uid = Long.parseLong(text);

                    Chat chat = (Chat)adminAddChatMap.get(user_id);
                    long oldUid = chat.getUid();
                    chat.setUid(uid);

                    ChatManager.changeUid(chat, adminCurrentCategoryMap.get(user_id), oldUid);

                    String respond = MessageConstants.MESSAGE_CHATS_CHATFOUND.replace("$fullname", chat.getFullName()).replace("$permission", chat.getPermissionNeeded().toString()).replace("$url", chat.getUrl());

                    InlineKeyboardMarkup keyboardMarkup = buildEditChat(chat, adminCurrentCategoryMap.get(user_id));

                    SendMessage message = new SendMessage()
                            .setChatId(user_id)
                            .setParseMode(ParseMode.HTML)
                            .setReplyMarkup(keyboardMarkup).setText(respond);

                    core.getUserMap().get(user_id).setState(null);
                    adminAddChatMap.remove(user_id);
                    adminCurrentCategoryMap.remove(user_id);

                    core.send_message(message);
                }

            }
            else if ((state == State.ADMIN_CHANGECHATNAME) && (!text.equalsIgnoreCase("/cancel"))) {
                Chat chat = (Chat)adminAddChatMap.get(user_id);
                chat.setName(text);

                ChatManager.saveChat(chat, adminCurrentCategoryMap.get(user_id));

                String respond = "<b>Chat gefunden: $fullname</b> \n\nBenötigte Permission: $permission\nURL: $url".replace("$fullname", chat.getFullName()).replace("$permission", chat.getPermissionNeeded().toString()).replace("$url", chat.getUrl());

                InlineKeyboardMarkup keyboardMarkup = buildEditChat(chat, adminCurrentCategoryMap.get(user_id));

                SendMessage message = new SendMessage()
                        .setChatId(user_id)
                        .setParseMode(ParseMode.HTML)
                        .setReplyMarkup(keyboardMarkup)
                        .setText(respond);

                core.getUserMap().get(user_id).setState(null);
                adminAddChatMap.remove(user_id);
                adminCurrentCategoryMap.remove(user_id);

                core.send_message(message);

            }
            else if ((state == State.ADMIN_CHANGECHATURL) && (!text.equalsIgnoreCase("/cancel"))) {
                try {
                    URL url = new URL(text);
                    //UrlValidator validator = new UrlValidator();

                    //if (validator.isValid(text)) {
                    Chat chat = (Chat)adminAddChatMap.get(user_id);
                    chat.setUrl(text);
                    ChatManager.saveChat(chat, adminCurrentCategoryMap.get(user_id));
                    String respond = "<b>Chat gefunden: $fullname</b> \n\nBenötigte Permission: $permission\nURL: $url".replace("$fullname", chat.getFullName()).replace("$permission", chat.getPermissionNeeded().toString()).replace("$url", chat.getUrl());

                    InlineKeyboardMarkup keyboardMarkup = buildEditChat(chat, adminCurrentCategoryMap.get(user_id));

                    SendMessage message = new SendMessage()
                            .setChatId(user_id)
                            .setParseMode(ParseMode.HTML)
                            .setReplyMarkup(keyboardMarkup)
                            .setText(respond);

                    core.getUserMap().get(user_id).setState(null);
                    adminAddChatMap.remove(user_id);
                    adminCurrentCategoryMap.remove(user_id);

                    core.send_message(message);

                } catch (MalformedURLException e) {
                    SendMessage message = new SendMessage()
                            .setChatId(user_id)
                            .setParseMode(ParseMode.HTML)
                            .setText("Es tut mir Leid, aber das ist keine valide URL. Bitte versuche es noch einmal.");

                    core.send_message(message);
                }
            }

        }

        /*----------Update has a Callback Query (aka Button was clicked)----------*/

        //////////////////////////////////////////
        //      HAS CALLBACKQUERY
        ////////////////////////////////////////

        if (update.hasCallbackQuery()) {

            String call_data = update.getCallbackQuery().getData();

            long message_id = update.getCallbackQuery().getMessage().getMessageId();
            long user_id = update.getCallbackQuery().getFrom().getId();
            String user_name = Core.getUserAsMention(update.getCallbackQuery().getFrom());

            State state = core.getUserMap().containsKey(user_id) ? core.getUserMap().get(user_id).getState() : null;



            /*----------Admintools----------*/

            ///////////////////////////////////
            // admintools x _ x _
            //////////////////////////////////

            if (call_data.startsWith("admintools") && UserManager.checkAdmin(user_id) && state == null) {
                String[] call_data_parts = call_data.split(" ");

                // *************** admintools x menu x _ ***********************//
                // Load admin tools menu
                if (call_data_parts[1].equals("menu")) {
                    EditMessageText message = new EditMessageText();

                    InlineKeyboardMarkup keyboard = buildAdminMenu();

                    message.setChatId(user_id).setParseMode(ParseMode.HTML).setMessageId(toIntExact(message_id))
                            .setReplyMarkup(keyboard).setText("Admin Tools:");

                    core.edit_message(message);
                }

                // *************** admintools x loadrequests x _ ***********************//
                // Load currenty open Requests
                else if (call_data_parts[1].equals("loadrequests")) {

                    if (core.getOpen_requests().size() == 0) {
                        EditMessageText message = new EditMessageText();

                        InlineKeyboardMarkup keyboard = new InlineKeyboardMarkup();
                        List<List<InlineKeyboardButton>> buttons = new ArrayList<>();
                        List<InlineKeyboardButton> row = new ArrayList<>();

                        row.add(new InlineKeyboardButton().setText("Zurück").setCallbackData("admintools menu"));

                        buttons.add(row);

                        keyboard.setKeyboard(buttons);

                        message.setChatId(user_id).setParseMode(ParseMode.HTML).setMessageId(toIntExact(message_id))
                                .setReplyMarkup(keyboard).setText(MessageConstants.MESSAGE_PERMISSION_NO_OPENREQUESTS);

                        core.edit_message(message);
                    } else {
                        EditMessageText message = new EditMessageText();

                        InlineKeyboardMarkup keyboard = buildOpenRequests(core.getOpen_requests());

                        message.setChatId(user_id).setParseMode(ParseMode.HTML).setMessageId(toIntExact(message_id))
                                .setReplyMarkup(keyboard).setText(MessageConstants.MESSAGE_PERMISSION_OPENREQUESTS);

                        core.edit_message(message);
                    }
                }

                // *************** admintools x loadopenuser x USER_ID ***********************//
                // Load specific request
                else if (call_data_parts[1].equals("loadopenuser")) {
                    long open_user_id = Long.parseLong(call_data_parts[2]);

                    MyUser open_user = core.getOpen_requests().get(open_user_id);

                    EditMessageText message = new EditMessageText();

                    InlineKeyboardMarkup keyboard = buildRequestAnswers(open_user_id);

                    String message_text;
                    if (open_user.getRole() == Roles.GUEST) {
                        message_text = MessageConstants.MESSAGE_PERMISSION_OPENUSER_GUEST.replace("$user",
                                open_user.getUserName());
                    } else {
                        message_text = MessageConstants.MESSAGE_PERMISSION_OPENUSER.replace("$user", open_user.getUserName());
                    }

                    message.setChatId(user_id).setParseMode(ParseMode.HTML).setMessageId(toIntExact(message_id))
                            .setReplyMarkup(keyboard).setText(message_text);

                    core.edit_message(message);
                }

                // *************** admintools x grant x USER_ID ***********************//

                // Permission was granted
                else if (call_data_parts[1].equals("grant")) {

                    log.info("Grant by " + user_name + " - " + user_id + " for " + call_data_parts[2]);

                    long open_user_id = Long.parseLong(call_data_parts[2]);
                    MyUser user = core.getOpen_requests().get(open_user_id);

                    //What if open request doesnt exist anymore?
                    if (user == null) {
                        EditMessageText message = new EditMessageText();

                        InlineKeyboardMarkup keyboard = buildBackButtonAdmintools();

                        message.setChatId(user_id).setParseMode(ParseMode.HTML).setMessageId(toIntExact(message_id))
                                .setReplyMarkup(keyboard).setText(MessageConstants.MESSAGE_ADMINTOOLS_NULLREQUEST);

                        core.edit_message(message);
                    } else {
                        UserManager.whitelistUser(user, core);

                        // Send message to user, to tell him, he was whitelisted
                        SendMessage message = new SendMessage();

                        String message_text;
                        if (user.getRole() == Roles.GUEST) {
                            message_text = MessageConstants.MESSAGE_PERMISSION_GUEST_GRANTED;
                        } else {
                            message_text = MessageConstants.MESSAGE_PERMISSION_GRANTED;
                        }

                        message.setChatId((long) user.getId()).setParseMode(ParseMode.HTML).setText(message_text);

                        core.send_message(message);

                        // Inform admins that a request was granted
                        SendMessage admin_message = new SendMessage();
                        String admin_message_text;
                        if (user.getRole() == Roles.GUEST) {
                            admin_message_text = MessageConstants.MESSAGE_PERMISSION_GUEST_REQUEST_GRANTED.replace(
                                    "$user", user.getUserName())
                                    .replace("$admin", user_name);
                        } else {
                            admin_message_text = MessageConstants.MESSAGE_PERMISSION_USER_REQUEST_GRANTED.replace(
                                    "$user", user.getUserName())
                                    .replace("$admin", user_name);
                        }

                        admin_message.setParseMode(ParseMode.HTML).setText(admin_message_text);

                        core.send_message_toadmins(admin_message);

                        // Edit admin message to tell him, he is done
                        EditMessageText new_message = new EditMessageText();

                        String new_message_text;
                        if (user.getRole() == Roles.GUEST) {
                            new_message_text = MessageConstants.MESSAGE_PERMISSION_GUEST_GRANTED_ADMIN.replace("$user", user.getUserName());
                        } else {
                            new_message_text = MessageConstants.MESSAGE_PERMISSION_GRANTED_ADMIN.replace("$user", user.getUserName());
                        }

                        InlineKeyboardMarkup keyboard = new InlineKeyboardMarkup();
                        List<List<InlineKeyboardButton>> buttons = new ArrayList<>();
                        List<InlineKeyboardButton> row = new ArrayList<>();

                        row.add(new InlineKeyboardButton().setText("Zurück")
                                .setCallbackData("admintools loadrequests"));

                        buttons.add(row);

                        keyboard.setKeyboard(buttons);

                        new_message.setChatId(user_id).setParseMode(ParseMode.HTML).setMessageId(toIntExact(message_id))
                                .setReplyMarkup(keyboard).setText(new_message_text);

                        core.edit_message(new_message);
                        core.getOpen_requests().remove(open_user_id);

                    }
                }

                // *************** admintools x deny x USER_ID ***********************//

                // Permission was denied
                else if (call_data_parts[1].equals("deny")) {

                    log.info("Deny by " + user_name + " - " + user_id + " for " + call_data_parts[2]);

                    long open_user_id = Long.parseLong(call_data_parts[2]);
                    MyUser user = core.getOpen_requests().get(open_user_id);

                    //What if open request doesnt exist anymore?
                    if (user == null) {
                        EditMessageText message = new EditMessageText();

                        InlineKeyboardMarkup keyboard = buildBackButtonAdmintools();

                        message.setChatId(user_id).setParseMode(ParseMode.HTML).setMessageId(toIntExact(message_id))
                                .setReplyMarkup(keyboard).setText(MessageConstants.MESSAGE_ADMINTOOLS_NULLREQUEST);

                        core.edit_message(message);
                    } else {
                        core.getOpen_requests().remove(open_user_id);

                        // Send message to user, to tell him, that his request was denied
                        SendMessage message = new SendMessage();

                        message.setChatId((long) user.getId()).setParseMode(ParseMode.HTML).setText(
                                MessageConstants.MESSAGE_PERMISSION_DENIED);

                        core.send_message(message);

                        // Inform admins that a request was denied
                        SendMessage admin_message = new SendMessage();
                        String admin_message_text = MessageConstants.MESSAGE_PERMISSION_REQUEST_DENIED.replace(
                                "$user", user.getUserName())
                                .replace("$admin", user_name);


                        admin_message.setParseMode(ParseMode.HTML).setText(admin_message_text);
                        core.send_message_toadmins(admin_message);

                        // Edit admin message to tell him, he is done
                        EditMessageText new_message = new EditMessageText();

                        String new_message_text = MessageConstants.MESSAGE_PERMISSION_DENIED_ADMIN.replace("$user",
                                user.getUserName());

                        InlineKeyboardMarkup keyboard = new InlineKeyboardMarkup();
                        List<List<InlineKeyboardButton>> buttons = new ArrayList<>();
                        List<InlineKeyboardButton> row = new ArrayList<>();

                        row.add(new InlineKeyboardButton().setText("Zurück")
                                .setCallbackData("admintools loadrequests"));

                        buttons.add(row);

                        keyboard.setKeyboard(buttons);

                        new_message.setChatId(user_id).setParseMode(ParseMode.HTML).setMessageId(toIntExact(message_id))
                                .setReplyMarkup(keyboard).setText(new_message_text);

                        core.edit_message(new_message);
                    }
                }

                // *************** admintools x denyandblock x USER_ID ***********************//
                // Permission was denied and user was blocked
                else if (call_data_parts[1].equals("denyandblock")) {

                    log.info("DenyBlock by " + user_name + " - " + user_id + " for " + call_data_parts[2]);


                    long open_user_id = Long.parseLong(call_data_parts[2]);
                    MyUser user = core.getOpen_requests().get(open_user_id);

                    //What if open request doesnt exist anymore?
                    if (user == null) {
                        EditMessageText message = new EditMessageText();

                        InlineKeyboardMarkup keyboard = buildBackButtonAdmintools();

                        message.setChatId(user_id).setParseMode(ParseMode.HTML).setMessageId(toIntExact(message_id))
                                .setReplyMarkup(keyboard).setText(MessageConstants.MESSAGE_ADMINTOOLS_NULLREQUEST);

                        core.edit_message(message);
                    } else {
                        core.getOpen_requests().remove(open_user_id);

                        UserManager.blockUser(user, core);

                        // Send message to user, to tell him, that his request was denied and he got blocked
                        SendMessage message = new SendMessage();

                        message.setChatId((long) user.getId()).setParseMode(ParseMode.HTML).setText(
                                MessageConstants.MESSAGE_PERMISSION_BLOCKED);

                        core.send_message(message);

                        // Edit admin message to tell him, he is done
                        EditMessageText new_message = new EditMessageText();

                        String new_message_text = MessageConstants.MESSAGE_PERMISSION_BLOCKED_ADMIN.replace("$user",
                                user.getUserName());

                        InlineKeyboardMarkup keyboard = new InlineKeyboardMarkup();
                        List<List<InlineKeyboardButton>> buttons = new ArrayList<>();
                        List<InlineKeyboardButton> row = new ArrayList<>();

                        row.add(new InlineKeyboardButton().setText("Zurück")
                                .setCallbackData("admintools loadrequests"));

                        buttons.add(row);

                        keyboard.setKeyboard(buttons);

                        new_message.setChatId(user_id).setParseMode(ParseMode.HTML).setMessageId(toIntExact(message_id))
                                .setReplyMarkup(keyboard).setText(new_message_text);

                        core.edit_message(new_message);
                    }
                }

                // *************** admintools x whitelist x _ ***********************//
                //Load current whitelist
                else if (call_data_parts[1].equals("whitelist")) {
                    List<MyUser> adminlist = UserManager.buildAdminList();
                    List<MyUser> whitelist = UserManager.buildUserList();
                    List<MyUser> guestlist = UserManager.buildGuestList();

                    EditMessageText message = new EditMessageText();

                    InlineKeyboardMarkup keyboard = buildWhitelistMenu();

                    StringBuilder message_text = new StringBuilder().append(MessageConstants.MESSAGE_ADMINTOOLS_WHITELIST);

                    message_text.append("Admins: \n");
                    for (MyUser admin : adminlist) {
                        message_text.append(admin.getUserName()).append(" - <code>").append(admin.getId()).append("</code>\n");
                    }

                    message_text.append("\nUsers: \n");
                    for (MyUser user : whitelist) {
                        message_text.append(user.getUserName()).append(" - <code>").append(user.getId()).append("</code>     ");

                        if(user.getPermission() != null && user.getPermission().size() > 0){
                            for (UserPermission permission : user.getPermission()) {
                                message_text.append("<i>").append(permission.toString().charAt(0)).append("</i> ");
                            }
                        }

                        message_text.append("\n");
                    }

                    message_text.append("\nGäste: \n");

                    for (MyUser guest : guestlist) {
                        message_text.append(guest.getUserName()).append(" - <code>").append(guest.getId()).append("</code>\n");
                    }

                    message.setChatId(user_id).setParseMode(ParseMode.HTML).setMessageId(toIntExact(message_id))
                            .setReplyMarkup(keyboard).setText(message_text.toString());

                    core.edit_message(message);
                }

                // *************** admintools x loaduser x _ ***********************//
                // Load specific user on whitelist
                else if (call_data_parts[1].equals("loaduser")) {
                    core.getUserMap().get(user_id).setState(State.ADMIN_LOADUSER);

                    EditMessageText message = new EditMessageText();

                    message.setChatId(user_id).setParseMode(ParseMode.HTML).setMessageId(toIntExact(message_id))
                            .setText(MessageConstants.MESSAGE_ADMINTOOLS_LOADUSER);

                    core.edit_message(message);
                }

                // *************** admintools x change  ROLE/PERMISSION x USER_ID *********************** //

                else if (call_data_parts[1].matches("change[^ ]+")) {

                    String changeData = call_data_parts[1].replace("change", "");


                    log.info("Change by " + user_name + " - " + user_id + " for " + call_data_parts[2] + " for:" + changeData);


                    // change Role on match
                    for (Roles x : Roles.values()) {
                        if (changeData.equalsIgnoreCase(x.name())) {

                            MyUser abstractUser = UserManager.loadUser(Long.parseLong(call_data_parts[2]));

                            // User cannot be found
                            if (abstractUser == null) {
                                EditMessageText message = new EditMessageText();

                                InlineKeyboardMarkup keyboard = buildBackButtonAdmintools();

                                message.setChatId(user_id).setParseMode(ParseMode.HTML).setMessageId(toIntExact(message_id))
                                        .setReplyMarkup(keyboard).setText(MessageConstants.MESSAGE_ADMINTOOLS_USERNOTFOUND);

                                core.edit_message(message);
                                break;
                            }

                            // If user already has Role switch: Guest -> User, Admin -> User
                            else if (abstractUser.getRole() == x) {
                                //HARDCODED MAY CHANGE PROPERLY OR DO NOT TOUCH!
                                if (x == Roles.ADMIN) {
                                    abstractUser.setRole(Roles.USER);
                                } else if (x == Roles.USER) {
                                    abstractUser.setRole(Roles.GUEST);
                                } else if (x == Roles.GUEST) {
                                    abstractUser.setRole(Roles.USER);
                                }
                                UserManager.changeUser(abstractUser, core);
                                reloadUserEntry(message_id, abstractUser.getId(), user_id);
                            }
                            // Otherwise change to Role X
                            else {
                                abstractUser.setRole(x);
                            }

                            UserManager.changeUser(abstractUser, core);
                            reloadUserEntry(message_id, abstractUser.getId(), user_id);

                            break;
                        }
                    }

                    // change Permission on match
                    for (UserPermission x : UserPermission.values()) {
                        if (changeData.equalsIgnoreCase(x.name())) {

                            MyUser user = UserManager.loadUser(Long.parseLong(call_data_parts[2]));

                            // User cannot be found
                            if (user == null) {
                                EditMessageText message = new EditMessageText();

                                InlineKeyboardMarkup keyboard = buildBackButtonAdmintools();

                                message.setChatId(user_id).setParseMode(ParseMode.HTML).setMessageId(toIntExact(message_id))
                                        .setReplyMarkup(keyboard).setText(MessageConstants.MESSAGE_ADMINTOOLS_USERNOTFOUND);

                                core.edit_message(message);
                            }

                            // Change Permission status X
                            else {
                                user.changePermission(x);
                                UserManager.changeUser(user, core);
                                reloadUserEntry(message_id, user.getId(), user_id);
                            }
                            break;
                        }
                    }

                }
                // ************************ admintools x block x USERID ******************************//
                // Admin want to block a user ask to confirm
                else if (call_data_parts[1].equals("block")) {

                    MyUser user = UserManager.loadUser(Long.parseLong(call_data_parts[2]));

                    // User cannot be found
                    if (user == null) {
                        EditMessageText message = new EditMessageText();

                        InlineKeyboardMarkup keyboard = buildBackButtonAdmintools();

                        message.setChatId(user_id).setParseMode(ParseMode.HTML).setMessageId(toIntExact(message_id))
                                .setReplyMarkup(keyboard).setText(MessageConstants.MESSAGE_ADMINTOOLS_USERNOTFOUND);

                        core.edit_message(message);
                    } else {
                        EditMessageText message = new EditMessageText();

                        InlineKeyboardMarkup keyboard = buildBlockOptions(user);

                        String message_text = MessageConstants.MESSAGE_ADMINTOOLS_ABOUTTOBLOCK.replace("$user",
                                user.getUserName());

                        message.setChatId(user_id).setParseMode(ParseMode.HTML).setMessageId(toIntExact(message_id))
                                .setReplyMarkup(keyboard).setText(message_text);

                        core.edit_message(message);
                    }

                    // *********************** admintools x blockapproval x USERID *************************//
                    // admin confirmed to Block a user
                } else if (call_data_parts[1].equals("blockapproval")) {

                    log.info("BlockApprove by " + user_name + " - " + user_id + " for " + call_data_parts[2]);

                    MyUser user = UserManager.loadUser(Long.parseLong(call_data_parts[2]));

                    // User cannot be found
                    if (user == null) {
                        user = new MyUser(Integer.parseInt(call_data_parts[2]),"");
                    }
                    UserManager.blockUser(user, core);

                    EditMessageText message = new EditMessageText();

                    InlineKeyboardMarkup keyboard = buildBackButtonAdmintools();

                    String message_text = MessageConstants.MESSAGE_ADMINTOOLS_BLOCKED.replace("user", user.getUserName());

                    message.setChatId(user_id).setParseMode(ParseMode.HTML).setMessageId(toIntExact(message_id))
                            .setReplyMarkup(keyboard).setText(message_text);

                    core.edit_message(message);

                }

                // ******************* admintools x blocklist x _ ****************************************//
                //Load current blocklist
                else if (call_data_parts[1].equals("blocklist")) {
                    List<MyUser> blocklist = UserManager.buildBlockList();

                    EditMessageText message = new EditMessageText();

                    InlineKeyboardMarkup keyboard = buildBlocklistMenu();

                    StringBuilder message_text = new StringBuilder();
                    message_text.append(MessageConstants.MESSAGE_ADMINTOOLS_BLOCKLIST);

                    for (MyUser user : blocklist) {
                        message_text.append(user.getUserName()).append(" - <code>").append(user.getId()).append("</code>\n");
                    }

                    message.setChatId(user_id).setParseMode(ParseMode.HTML).setMessageId(toIntExact(message_id))
                            .setReplyMarkup(keyboard).setText(message_text.toString());

                    core.edit_message(message);
                }

                //******************** admintools x unblock x USERID ***********************************//
                // Load specific user on blocklist to unblock
                else if (call_data_parts[1].equals("unblock")) {

                    log.info("UnBlock by " + user_name + " - " + user_id);


                    core.getUserMap().get(user_id).setState(State.ADMIN_UNBLOCKUSER);

                    EditMessageText message = new EditMessageText();

                    message.setChatId(user_id).setParseMode(ParseMode.HTML).setMessageId(toIntExact(message_id))
                            .setText(MessageConstants.MESSAGE_ADMINTOOLS_UNBLOCK);

                    core.edit_message(message);
                }
            }

            ///////////////////////////////////
            // CHAT HANDEL
            ///////////////////////////////////

            else if (call_data.startsWith("chats") && UserManager.checkAdmin(user_id)) {
                String[] call_data_parts = call_data.split(" ");

                if ((call_data_parts[1].equalsIgnoreCase("addcategory"))) {
                    EditMessageText messageText = new EditMessageText()
                            .setChatId(user_id)
                            .setMessageId(Math.toIntExact(message_id))
                            .setParseMode(ParseMode.HTML)
                            .setText(MessageConstants.MESSAGE_CHATS_ADDCATEGORY);

                    core.getUserMap().get(user_id).setState(State.ADMIN_ADDCHATCATEGORY);
                    core.edit_message(messageText);

                }
                else if ((call_data_parts[1].equalsIgnoreCase("addchat"))) {
                    EditMessageText messageText = new EditMessageText()
                            .setChatId(user_id)
                            .setMessageId(Math.toIntExact(message_id))
                            .setParseMode(ParseMode.HTML)
                            .setText("Okay! Bitte gib mir zuerst eine noch nicht verwendete Chatnummer (maximal 4-stellige Ganzzahl) für den Chat.");

                    adminCurrentCategoryMap.put(user_id, Long.valueOf(call_data_parts[2]));
                    core.getUserMap().get(user_id).setState(State.ADMIN_ADDCHATUID);
                    core.edit_message(messageText);

                }
                else if ((call_data_parts[1].equalsIgnoreCase("editcategory"))) {
                    long uid = Long.parseLong(call_data_parts[2]);
                    ChatCategory category = ChatManager.loadCategory(uid);

                    InlineKeyboardMarkup keyboardMarkup = buildEditCategory(category);

                    String text = MessageConstants.MESSAGE_CHATS_ADMINEDITCATEGORY.replace("$category", category.getName());

                    EditMessageText messageText = new EditMessageText()
                            .setChatId(user_id)
                            .setMessageId(Math.toIntExact(message_id))
                            .setParseMode(ParseMode.HTML)
                            .setReplyMarkup(keyboardMarkup)
                            .setText(text);

                    core.edit_message(messageText);

                }
                else if ((call_data_parts[1].equalsIgnoreCase("editchat")))
                {
                    EditMessageText messageText = new EditMessageText()
                            .setChatId(user_id)
                            .setMessageId(Math.toIntExact(message_id))
                            .setParseMode(ParseMode.HTML)
                            .setText(MessageConstants.MESSAGE_CHATS_LOADCHAT);

                    adminCurrentCategoryMap.put(user_id, Long.valueOf(call_data_parts[2]));
                    core.getUserMap().get(user_id).setState(State.ADMIN_EDITCHAT);
                    core.edit_message(messageText);

                }
                else if ((call_data_parts[1].equalsIgnoreCase("deletechat"))) {
                    long chatId = Long.parseLong(call_data_parts[2]);
                    long categoryId = Long.parseLong(call_data_parts[3]);

                    ChatManager.deleteChat(chatId);

                    InlineKeyboardMarkup keyboard = buildEditCategory(ChatManager.loadCategory(categoryId));

                    EditMessageText messageText = new EditMessageText()
                            .setChatId(user_id)
                            .setMessageId(Math.toIntExact(message_id))
                            .setReplyMarkup(keyboard)
                            .setParseMode(ParseMode.HTML)
                            .setText(MessageConstants.MESSAGE_CHATS_CHATDELETED);

                    core.edit_message(messageText);
                }
                else if ((call_data_parts[1].equalsIgnoreCase("deletecategory"))) {
                    long uid = Long.parseLong(call_data_parts[2]);
                    ChatCategory category = ChatManager.loadCategory(uid);

                    InlineKeyboardMarkup keyboardMarkup = buildConfirmCategoryDelete(category);

                    String text = MessageConstants.MESSAGE_CHATS_ADMINDELETECATEGORY.replace("$category", category.getName());

                    EditMessageText messageText = new EditMessageText()
                            .setChatId(user_id)
                            .setMessageId(Math.toIntExact(message_id))
                            .setParseMode(ParseMode.HTML)
                            .setReplyMarkup(keyboardMarkup)
                            .setText(text);

                    core.edit_message(messageText);

                }
                else if ((call_data_parts[1].equalsIgnoreCase("deletecategoryconfirm"))) {
                    long uid = Long.parseLong(call_data_parts[2]);
                    ChatManager.deleteCategory(uid);

                    InlineKeyboardMarkup keyboardMarkup = buildCategoriesMenu(user_id);

                    EditMessageText messageText = new EditMessageText()
                            .setChatId(user_id)
                            .setMessageId(Math.toIntExact(message_id))
                            .setParseMode(ParseMode.HTML)
                            .setReplyMarkup(keyboardMarkup)
                            .setText(MessageConstants.MESSAGE_CHATS_ADMINCATEGORYDELETED);

                    core.edit_message(messageText);
                }
                else if ((call_data_parts[1].equalsIgnoreCase("addpermission"))) {
                    Chat chat = (Chat) adminAddChatMap.get(user_id);
                    adminAddChatMap.remove(user_id);

                    UserPermission permission = UserPermission.valueOf(call_data_parts[2]);
                    chat.setPermissionNeeded(permission);

                    ChatCategory category = ChatManager.loadCategory((adminCurrentCategoryMap.get(user_id)));
                    adminCurrentCategoryMap.remove(user_id);

                    ChatManager.saveChat(chat, category.getUid());

                    InlineKeyboardMarkup keyboardMarkup = buildEditCategory(category);

                    EditMessageText messageText = new EditMessageText()
                            .setChatId(user_id)
                            .setMessageId(Math.toIntExact(message_id))
                            .setParseMode(ParseMode.HTML)
                            .setReplyMarkup(keyboardMarkup)
                            .setText(MessageConstants.MESSAGE_CHATS_CHATADDED);

                    core.edit_message(messageText);

                }
                else if ((call_data_parts[1].equalsIgnoreCase("changeuid"))) {
                    adminCurrentCategoryMap.put(user_id, Long.valueOf(call_data_parts[3]));
                    adminAddChatMap.put(user_id, ChatManager.loadChatFromCategory(Long.parseLong(call_data_parts[2]), Long.parseLong(call_data_parts[3])));

                    EditMessageText messageText = new EditMessageText()
                            .setChatId(user_id)
                            .setMessageId(Math.toIntExact(message_id))
                            .setParseMode(ParseMode.HTML)
                            .setText(MessageConstants.MESSAGE_CHATS_CHANGEUID);

                    core.edit_message(messageText);

                    core.getUserMap().get(user_id).setState(State.ADMIN_CHANGECHATUID);
                }
                else if ((call_data_parts[1].equalsIgnoreCase("changeurl"))) {
                    adminCurrentCategoryMap.put(user_id, Long.valueOf(call_data_parts[3]));
                    adminAddChatMap.put(user_id, ChatManager.loadChatFromCategory(Long.parseLong(call_data_parts[2]), Long.parseLong(call_data_parts[3])));

                    EditMessageText messageText = new EditMessageText()
                            .setChatId(user_id)
                            .setMessageId(Math.toIntExact(message_id))
                            .setParseMode(ParseMode.HTML)
                            .setText(MessageConstants.MESSAGE_CHATS_CHANGEURL);

                    core.edit_message(messageText);

                    core.getUserMap().get(user_id).setState(State.ADMIN_CHANGECHATURL);
                }
                else if ((call_data_parts[1].equalsIgnoreCase("changename"))) {
                    adminCurrentCategoryMap.put(user_id, Long.valueOf(call_data_parts[3]));
                    adminAddChatMap.put(user_id, ChatManager.loadChatFromCategory(Long.parseLong(call_data_parts[2]), Long.parseLong(call_data_parts[3])));

                    EditMessageText messageText = new EditMessageText()
                            .setChatId(user_id)
                            .setMessageId(Math.toIntExact(message_id))
                            .setParseMode(ParseMode.HTML)
                            .setText(MessageConstants.MESSAGE_CHATS_CHANGENAME);

                    core.edit_message(messageText);

                    core.getUserMap().get(user_id).setState(State.ADMIN_CHANGECHATNAME);

                }
                else if ((call_data_parts[1].equalsIgnoreCase("changepermission"))) {
                    adminCurrentCategoryMap.put(user_id, Long.valueOf(call_data_parts[3]));
                    adminAddChatMap.put(user_id, ChatManager.loadChatFromCategory(Long.parseLong(call_data_parts[2]), Long.parseLong(call_data_parts[3])));

                    InlineKeyboardMarkup keyboardMarkup = buildChangePermissions();

                    EditMessageText messageText = new EditMessageText()
                            .setChatId(user_id)
                            .setMessageId(Math.toIntExact(message_id))
                            .setReplyMarkup(keyboardMarkup)
                            .setParseMode(ParseMode.HTML)
                            .setText(MessageConstants.MESSAGE_CHATS_CHANGEPERMISSION);

                    core.edit_message(messageText);

                    core.getUserMap().get(user_id).setState(State.ADMIN_CHANGECHATUID);

                }
                else if ((call_data_parts[1].equalsIgnoreCase("changepermissionconfirm"))) {
                    UserPermission permission = UserPermission.valueOf(call_data_parts[2]);

                    Chat chat = adminAddChatMap.get(user_id);
                    chat.setPermissionNeeded(permission);

                    ChatManager.saveChat(chat, adminCurrentCategoryMap.get(user_id));
                    InlineKeyboardMarkup keyboardMarkup = buildEditChat(chat, adminCurrentCategoryMap.get(user_id));

                    adminAddChatMap.remove(user_id);
                    adminCurrentCategoryMap.remove(user_id);
                    core.getUserMap().get(user_id).setState(null);

                    String respond = MessageConstants.MESSAGE_CHATS_CHATFOUND.replace("$fullname", chat.getFullName()).replace("$permission", chat.getPermissionNeeded().toString()).replace("$url", chat.getUrl());

                    EditMessageText messageText = new EditMessageText()
                            .setChatId(user_id)
                            .setMessageId(Math.toIntExact(message_id))
                            .setReplyMarkup(keyboardMarkup)
                            .setParseMode(ParseMode.HTML)
                            .setText(respond);

                    core.edit_message(messageText);
                }
            }
        }
    }

    /*----------Help Methods to load or reload a User Entry----------*/

    private void loadUserEntry(long userID, long adminId) {
        MyUser abstractUser = UserManager.loadUser(userID);

        //Send Error message if no user is found
        if (abstractUser == null) {
            SendMessage message = new SendMessage().setChatId(adminId).setParseMode(ParseMode.HTML).setText(
                    MessageConstants.MESSAGE_ADMINTOOLS_USERNOTFOUND);

            core.send_message(message);
        }

        //Check that no one is able to load himself
        else if (abstractUser.getId() == adminId) {
            InlineKeyboardMarkup keyboardMarkup = buildBackButtonWhitelist();

            SendMessage messageText = new SendMessage().setChatId(adminId).setParseMode(ParseMode.HTML).setReplyMarkup(
                    keyboardMarkup).setText(MessageConstants.MESSAGE_ADMINTOOLS_CANTCHANGESELF);

            core.getUserMap().get(adminId).setState(null);
            core.send_message(messageText);
        }

        //Check that no one is able to load the Master
        else if (abstractUser.getId() == Core.ADMIN_CHAT_ID) {
            InlineKeyboardMarkup keyboardMarkup = buildBackButtonWhitelist();

            SendMessage message = new SendMessage().setChatId(adminId).setParseMode(ParseMode.HTML).setReplyMarkup(
                    keyboardMarkup).setText(MessageConstants.MESSAGE_ADMINTOOLS_CANTCHANGEMASTER);

            core.getUserMap().get(adminId).setState(null);
            core.send_message(message);
        }

        //Load User
        else if (abstractUser.getRole() == Roles.ADMIN) {
            InlineKeyboardMarkup keyboardMarkup = buildAdminFound(abstractUser);

            String text = MessageConstants.MESSAGE_ADMINTOOLS_ADMINFOUND.replace("$user", abstractUser.getUserName());

            SendMessage message = new SendMessage().setChatId(adminId).setParseMode(ParseMode.HTML).setReplyMarkup(
                    keyboardMarkup).setText(text);

            core.getUserMap().get(adminId).setState(null);
            core.send_message(message);
        } else if (abstractUser.getRole() == Roles.GUEST) {
            InlineKeyboardMarkup keyboardMarkup = buildGuestFound(abstractUser);

            String text = MessageConstants.MESSAGE_ADMINTOOLS_GUESTFOUND.replace("$user", abstractUser.getUserName());

            SendMessage message = new SendMessage().setChatId(adminId).setParseMode(ParseMode.HTML).setReplyMarkup(
                    keyboardMarkup).setText(text);

            core.getUserMap().get(adminId).setState(null);
            core.send_message(message);
        } else if (abstractUser.getRole() == Roles.USER) {
            InlineKeyboardMarkup keyboardMarkup = buildUserFound(abstractUser);

            StringBuilder text = new StringBuilder();
            text.append(MessageConstants.MESSAGE_ADMINTOOLS_USERFOUND.replace("$user", abstractUser.getUserName()));

            if (abstractUser.getPermission() != null && abstractUser.getPermission().size() > 0) {
                for (UserPermission permission : abstractUser.getPermission()) {
                    text.append("\n").append(permission.toString());
                }
            }

            SendMessage message = new SendMessage().setChatId(adminId).setParseMode(ParseMode.HTML).setReplyMarkup(
                    keyboardMarkup).setText(text.toString());

            core.getUserMap().get(adminId).setState(null);
            core.send_message(message);
        }
    }

    //check
    private void reloadUserEntry(long messageId, long userID, long adminId) {
        MyUser abstractUser = UserManager.loadUser(userID);

        //Send Error message if no user is found
        if (abstractUser == null) {
            EditMessageText message = new EditMessageText().setChatId(adminId).setMessageId(toIntExact(messageId))
                    .setParseMode(ParseMode.HTML).setText(MessageConstants.MESSAGE_ADMINTOOLS_USERNOTFOUND);

            core.edit_message(message);
        }

        //Load User
        else if (abstractUser.getRole() == Roles.ADMIN) {
            InlineKeyboardMarkup keyboardMarkup = buildAdminFound(abstractUser);

            String text = MessageConstants.MESSAGE_ADMINTOOLS_ADMINFOUND
                    .replace("$user", abstractUser.getUserName());

            EditMessageText message = new EditMessageText().setChatId(adminId).setMessageId(toIntExact(messageId))
                    .setParseMode(ParseMode.HTML).setReplyMarkup(keyboardMarkup).setText(text);

            core.edit_message(message);
        } else if (abstractUser.getRole() == Roles.GUEST) {
            InlineKeyboardMarkup keyboardMarkup = buildGuestFound(abstractUser);

            String text = MessageConstants.MESSAGE_ADMINTOOLS_GUESTFOUND.replace("$user", abstractUser.getUserName());

            EditMessageText message = new EditMessageText().setChatId(adminId).setMessageId(toIntExact(messageId))
                    .setParseMode(ParseMode.HTML).setReplyMarkup(keyboardMarkup).setText(text);

            core.edit_message(message);
        } else if (abstractUser.getRole() == Roles.USER) {
            InlineKeyboardMarkup keyboardMarkup = buildUserFound(abstractUser);

            StringBuilder text = new StringBuilder();
            text.append(MessageConstants.MESSAGE_ADMINTOOLS_USERFOUND.replace("$user", abstractUser.getUserName()));

            if (abstractUser.getPermission() != null && abstractUser.getPermission().size() > 0) {
                for (UserPermission permission : abstractUser.getPermission()) {
                    text.append("\n").append(permission.toString());
                }
            }

            EditMessageText message = new EditMessageText().setChatId(adminId).setMessageId(toIntExact(messageId))
                    .setParseMode(ParseMode.HTML).setReplyMarkup(keyboardMarkup).setText(text.toString());

            core.edit_message(message);
        }
    }
}