public static String itemArrayToBase(ItemStack[] items) throws IllegalStateException {
        try {
            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
            BukkitObjectOutputStream dataOutput = new BukkitObjectOutputStream(outputStream);

            dataOutput.writeInt(items.length);

            for (int i = 0; i < items.length; i++) {
                dataOutput.writeObject(items[i]);
            }

            dataOutput.close();
            return Base64Coder.encodeLines(outputStream.toByteArray());
        } catch (Exception e) {
            throw new IllegalStateException("Unable to save item stacks.", e);
        }
    }

    public static ItemStack[] itemStackArrayFromBase64(String data) throws IOException {
        try {
            ByteArrayInputStream inputStream = new ByteArrayInputStream(Base64Coder.decodeLines(data));
            BukkitObjectInputStream dataInput = new BukkitObjectInputStream(inputStream);
            ItemStack[] items = new ItemStack[dataInput.readInt()];

            for (int i = 0; i < items.length; i++) {
                items[i] = (ItemStack) dataInput.readObject();
            }

            dataInput.close();
            return items;
        } catch (ClassNotFoundException e) {
            throw new IOException("Unable to decode class type.", e);
        }
    }

    // itemcomplet
    public static String itemArrayToBaseIt(List<ItemComplet> items) throws IllegalStateException {
        try {
            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
            DataOutputStream dataOutput = new DataOutputStream(outputStream);
            ItemStack[] itemstacks = new ItemStack[items.size()];
            Integer[] slots = new Integer[items.size()];
            for (int i = 0; i < items.size(); i++) {
                itemstacks[i] = items.get(i).getItemstack();
                slots[i] = items.get(i).getSlot();
            }
            dataOutput.writeUTF(itemArrayToBase(itemstacks));
            StringBuilder sb = new StringBuilder();
            for (int slot : slots) {
                sb.append(slot + ";");
            }
            dataOutput.writeUTF(sb.toString());
            dataOutput.close();
            return Base64Coder.encodeLines(outputStream.toByteArray());
        } catch (Exception e) {
            throw new IllegalStateException("Unable to save item stacks.", e);
        }
    }

    public static ItemComplet[] itemStackArrayFromBase64ItemComplet(String data) throws IOException {
        ByteArrayInputStream inputStream = new ByteArrayInputStream(Base64Coder.decodeLines(data));
        DataInputStream dataInput = new DataInputStream(inputStream);
        String decode = dataInput.readUTF();
        String s = dataInput.readUTF();
        String[] slotstableau = s.split(";");
        List<ItemStack> items = Arrays.asList(itemStackArrayFromBase64(decode));
        ItemComplet[] i = new ItemComplet[items.size()];
        for (int k = 0; k < items.size(); k++) {
            ItemComplet itemComplet = new ItemComplet();
            itemComplet.setItemstack(items.get(k));
            itemComplet.setSlot(Integer.parseInt(slotstableau[k]));
            i[k] = itemComplet;
        }

        dataInput.close();
        return i;
    }

    public static String getInventorySerialiserPlayer(PlayerInventory playerInventory) {
        List<ItemComplet> contentItem = new ArrayList<>();
        int slot = 0;
        for (ItemStack itemStack : playerInventory) {
            if (itemStack != null && itemStack.getType() != Material.AIR) {
                ItemComplet itemComplet = new ItemComplet();
                itemComplet.setItemstack(itemStack);
                itemComplet.setSlot(slot);
                contentItem.add(itemComplet);
            }
            slot++;
        }
        return InventorySerializer.itemArrayToBaseIt(contentItem);
    }

    public static String getInventorySerialiserPlayerArmor(List<ItemStack> armor) {
        List<ItemComplet> contentItem = new ArrayList<>();
        int slot = 0;
        for (ItemStack itemStack : armor) {
            if (itemStack != null && itemStack.getType() != Material.AIR) {
                ItemComplet itemComplet = new ItemComplet();
                itemComplet.setItemstack(itemStack);
                itemComplet.setSlot(slot);
                contentItem.add(itemComplet);
            }
            slot++;
        }
        return InventorySerializer.itemArrayToBaseIt(contentItem);
    }

    public static String getInventorySerialiser(Inventory inventory) {
        ItemStack[] contents = inventory.getContents();
        List<ItemComplet> contentItem = new ArrayList<>();
        int slot = 0;
        for (int k = 0; k < contents.length; k++) {
            ItemStack itemStack = contents[k];
            if (itemStack == null || itemStack.getType() == null || itemStack.getType() == Material.AIR) continue;
            ItemComplet itemComplet = new ItemComplet();
            itemComplet.setItemstack(itemStack);
            itemComplet.setSlot(slot++);
            contentItem.add(itemComplet);
        }
        return InventorySerializer.itemArrayToBaseIt(contentItem);
    }

    public static Inventory getInventoryBySerialiser(String serialisedinventory, Integer size) {
        ItemComplet[] contents = null;
        try {
            contents = InventorySerializer.itemStackArrayFromBase64ItemComplet(serialisedinventory);
        } catch (IOException e) {
            e.printStackTrace();
        }
        Inventory inventory;
        String inventoryname = SkyCore.getInstance().getConfigLoader().getEnderchest_name().replace("%size%", "" + size);
        if (contents != null) {
            inventory = Bukkit.createInventory(null, 9 * size, inventoryname);
            for (ItemComplet item : contents) {
                inventory.setItem(item.getSlot(), item.getItemstack());
            }
        } else inventory = Bukkit.createInventory(null, 9 * size, inventoryname);
        return inventory;
    }

}