package eu.mrapik.utilities.utils;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import net.md_5.bungee.api.ChatColor;
import org.apache.commons.lang.StringUtils;
import org.bukkit.Bukkit;
import static org.bukkit.Bukkit.getServer;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.entity.Player;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;

public class Utils {

    public static void makeGlass(int id, Inventory inv) {
        ItemStack item = new ItemStack(Material.STAINED_GLASS_PANE, 1, (byte) id);
        ItemMeta im = item.getItemMeta();
        im.setDisplayName(Utils.colorizer("&0###"));
        item.setItemMeta(im);

        for (int i = 0; i < inv.getContents().length; i++) {
            ItemStack[] help = inv.getContents();
            if (help[i] == null) {
                Utils.setItem(i, item, inv);
            }
        }

    }

    public static void sendNiceMessage(Player player, String message) {
        player.sendMessage(Utils.colorizer("&8" + StringUtils.center("■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■", 50)));
        String blank = StringUtils.center(" ", 50);
        blank = Utils.colorizer(blank.substring(1, blank.length() - 1));
        player.sendMessage(blank);
        String text = StringUtils.center(message, 50);
        text = Utils.colorizer(text.substring(1, text.length() - 1));

        player.sendMessage(text);
        player.sendMessage(blank);
        player.sendMessage(Utils.colorizer("&8" + StringUtils.center("■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■", 50)));
    }

    public static void sendNiceMessage(Player player, List<String> message) {
        String blank = StringUtils.center(" ", 50);
        blank = Utils.colorizer(blank.substring(1, blank.length() - 1));

        player.sendMessage(Utils.colorizer("&8" + StringUtils.center("■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■", 50)));

        player.sendMessage(blank);

        for (String msg : message) {
            String text = msg;
            text = Utils.colorizer(text);
            player.sendMessage(text);
        }
        player.sendMessage(blank);
        player.sendMessage(Utils.colorizer("&8" + StringUtils.center("■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■", 50)));

    }

    public static boolean isOnline(String pl) {
        for (Player player : Bukkit.getServer().getOnlinePlayers()) {
            if (player.getName().equalsIgnoreCase(pl)) {
                return true;
            }
        }
        return false;
    }

    public static void setItem(int position, ItemStack is, Inventory inv) {
        inv.setItem(position, is);
    }

    public static ItemStack createItem(Material material, String name, String lore) {
        ItemStack is = new ItemStack(material);
        ItemMeta im = is.getItemMeta();
        im.setDisplayName(Utils.colorizer(name));
        im.setLore(Arrays.asList(Utils.colorizer(lore)));
        is.setItemMeta(im);
        return is;
    }

    public static String colorizer(String message) {
        return ChatColor.translateAlternateColorCodes('&', message);
    }

    public static String serializeLocation(Location loc) {
        return loc.getWorld().getName() + "=" + loc.getX() + "=" + loc.getY() + "=" + loc.getZ() + "=" + loc.getPitch() + "=" + loc.getYaw();
    }

    public static boolean isDouble(String str) {
        String regExp = "[\\x00-\\x20]*[+-]?(((((\\p{Digit}+)(\\.)?((\\p{Digit}+)?)([eE][+-]?(\\p{Digit}+))?)|(\\.((\\p{Digit}+))([eE][+-]?(\\p{Digit}+))?)|(((0[xX](\\p{XDigit}+)(\\.)?)|(0[xX](\\p{XDigit}+)?(\\.)(\\p{XDigit}+)))[pP][+-]?(\\p{Digit}+)))[fFdD]?))[\\x00-\\x20]*";
        boolean matches = str.matches(regExp);
        return matches;
    }

    public static void catchEx(Exception ex) {
        Utils.sendConsoleMessage(Options.PREFIX + "&c INTERNAL ERROR: " + ex.getMessage() + " EXCEPTION: " + ex.getClass().toString());
        for (StackTraceElement se : ex.getStackTrace()) {
            Utils.sendConsoleMessage(Options.PREFIX + "&e FILE: &b" + se.getFileName() + " &eLINE: &b" + se.getLineNumber() + "&e METHOD: &b" + se.getMethodName());
        }
    }

    public static void broadcastMessage(boolean bold, String br) {
        for (Player col : Bukkit.getServer().getOnlinePlayers()) {
            if (bold) {
                col.sendMessage(Utils.colorizer(br));
            } else {
                col.sendMessage(Utils.colorizer(br));
            }
        }
    }

    public static void sendConsoleMessage(String message) {
        getServer().getConsoleSender().sendMessage(colorizer(message));
    }

    public static boolean isInteger(String str) {
        boolean toReturn = false;
        try {
            int op1 = Integer.parseInt(str);
            toReturn = true;
        } catch (NumberFormatException e) {
            toReturn = false;
        }
        return toReturn;
    }

    public static Location unserializeLocation(String loc) {

        if (loc.equals("NOEXIST")) {
            return null;
        }

        String[] split = loc.split("=");
        return new Location(getServer().getWorld(split[0]),
                Double.parseDouble(split[1]), Double.parseDouble(split[2]),
                Double.parseDouble(split[3]), Float.parseFloat(split[4]),
                Float.parseFloat(split[5]));
    }

    public static ItemStack createItem(Material m, String name, List<String> lore) {
        ItemStack is = new ItemStack(m);
        ItemMeta i = is.getItemMeta();
        i.setDisplayName(name);
        if (lore != null) {
            i.setLore(lore);
        }
        is.setItemMeta(i);
        return is;
    }

    public static void setMessage(FileConfiguration messages, String string, String text) {
        if (!messages.contains(string)) {
            messages.set(string, text);
        }
    }

    public static boolean playerHasEnoughLimit(Player p, Integer count, String perm) {
        //p = hráč
        //count = počet, který chceme ověřit
        //perm string bez čísla

        for (int i = 1; i < 500; i++) {
            if (p.hasPermission(perm + "." + i) && count == i) {
                return true;
            }
        }
        return true;
    }

    public static Integer getLimit(Player p, String perm) {
        int limit = 0;
        for (int i = 1; i < 500; i++) {
            if (p.hasPermission(perm + "." + i)) {
                if (limit < i) {
                    limit = i;
                }
            }
        }
        return limit;
    }

    public static String formatDouble(double amount) {

        String pattern = "###,###.###";
        Locale locale = new Locale("en", "UK");
        DecimalFormat decimalFormat = (DecimalFormat) NumberFormat.getNumberInstance(locale);
        decimalFormat.applyPattern(pattern);
        return decimalFormat.format(amount);
    }

    public static double round(double value, int places) {
        if (places < 0) {
            throw new IllegalArgumentException();
        }

        BigDecimal bd = new BigDecimal(value);
        bd = bd.setScale(places, RoundingMode.HALF_UP);
        return bd.doubleValue();
    }

    public static double roundToInt(double value) {
        int test = (int) value;
        test = Integer.valueOf(test);
        double toRet = (double) test;
        return Double.valueOf(toRet);
    }

    public static Map<String, Integer> sortByComparator(Map<String, Integer> unsortMap, final boolean order) {

        List<Map.Entry<String, Integer>> list = new LinkedList<Map.Entry<String, Integer>>(unsortMap.entrySet());

        // Sorting the list based on values
        Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
            public int compare(Map.Entry<String, Integer> o1,
                    Map.Entry<String, Integer> o2) {
                if (order) {
                    return o1.getValue().compareTo(o2.getValue());
                } else {
                    return o2.getValue().compareTo(o1.getValue());

                }
            }
        });

        // Maintaining insertion order with the help of LinkedList
        Map<String, Integer> sortedMap = new LinkedHashMap<String, Integer>();
        for (Map.Entry<String, Integer> entry : list) {
            sortedMap.put(entry.getKey(), entry.getValue());
        }

        return sortedMap;
    }

}