package tech.sbdevelopment.v10lift.api;

import com.cryptomorin.xseries.XMaterial;
import org.bukkit.*;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.block.BlockState;
import org.bukkit.block.Sign;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import tech.sbdevelopment.v10lift.V10LiftPlugin;
import tech.sbdevelopment.v10lift.api.objects.*;
import tech.sbdevelopment.v10lift.api.runnables.DoorCloser;
import tech.sbdevelopment.v10lift.api.runnables.MoveLift;
import tech.sbdevelopment.v10lift.managers.DataManager;
import tech.sbdevelopment.v10lift.managers.ForbiddenBlockManager;
import tech.sbdevelopment.v10lift.sbutils.LocationSerializer;
import tech.sbdevelopment.v10lift.utils.ConfigUtil;
import tech.sbdevelopment.v10lift.utils.BlockStateUtil;
import tech.sbdevelopment.v10lift.utils.DoorUtil;

import javax.annotation.Nonnull;
import java.util.*;

/**
 * The Main API class, for all the API methods
 */
public class V10LiftAPI {
    private static V10LiftAPI instance;

    private V10LiftAPI() {
    }

    public static V10LiftAPI getInstance() {
        if (instance == null) instance = new V10LiftAPI();
        return instance;
    }

    /* Private API methods */
    private void sortFloors(@Nonnull Lift lift) {
        ArrayList<Map.Entry<String, Floor>> as = new ArrayList<>(lift.getFloors().entrySet());
        as.sort(Comparator.comparingInt(o -> o.getValue().getY()));
        Iterator<Map.Entry<String, Floor>> iter = as.iterator();
        lift.getFloors().clear();
        Map.Entry<String, Floor> e;
        while (iter.hasNext()) {
            e = iter.next();
            lift.getFloors().put(e.getKey(), e.getValue());
        }
    }

    private void startLift(String liftName) {
        if (!DataManager.containsMovingTask(liftName)) {
            Lift lift = DataManager.getLift(liftName);
            DataManager.addMovingTask(liftName, Bukkit.getScheduler().scheduleSyncRepeatingTask(V10LiftPlugin.getInstance(), new MoveLift(liftName, lift.getSpeed()), lift.getSpeed(), lift.getSpeed()));
        }
    }

    /* API methods */

    /*
    @todo Fix creating lifts in adventure not working
     */

    /**
     * Create a new Lift
     *
     * @param p        The player [owner] of the lift
     * @param liftName The name of the lift
     * @return true if created, false if null or already exists
     */
    public boolean createLift(Player p, String liftName) {
        if (p == null || liftName == null || DataManager.containsLift(liftName)) return false;

        DataManager.addLift(liftName, new Lift(p.getUniqueId(), V10LiftPlugin.getSConfig().getFile().getInt("DefaultSpeed"), V10LiftPlugin.getSConfig().getFile().getBoolean("DefaultRealistic")));
        return true;
    }

    /**
     * Remove a lift
     *
     * @param liftName The name of the lift
     * @return true if removed, false if null or doesn't exists
     */
    public boolean removeLift(String liftName) {
        if (liftName == null || !DataManager.containsLift(liftName)) return false;

        Iterator<Map.Entry<UUID, String>> iter = DataManager.getEditors().entrySet().iterator();
        HashSet<UUID> activeEdits = new HashSet<>();
        while (iter.hasNext()) {
            Map.Entry<UUID, String> entry = iter.next();
            if (entry.getValue().equals(liftName)) {
                activeEdits.add(entry.getKey());
                iter.remove();
            }
        }

        for (UUID puuid : activeEdits) {
            DataManager.removeInputEditsPlayer(puuid);
            DataManager.removeInputRemovesPlayer(puuid);
            DataManager.removeOfflineEditsPlayer(puuid);
            DataManager.removeOfflineRemovesPlayer(puuid);
            DataManager.removeBuilderPlayer(puuid);
            DataManager.removeRopeEditPlayer(puuid);
            DataManager.removeRopeRemovesPlayer(puuid);
            DataManager.removeDoorEditPlayer(puuid);
        }

        if (DataManager.containsMovingTask(liftName)) {
            Bukkit.getScheduler().cancelTask(DataManager.getMovingTask(liftName));
            DataManager.removeMovingTask(liftName);
        }

        DataManager.removeLift(liftName);
        V10LiftPlugin.getDBManager().remove(liftName);
        return true;
    }

    /**
     * Get the name of a lift by a location (checking for cab blocks)
     *
     * @param loc The location you want to check for
     * @return The liftname
     */
    public String getLiftByLocation(Location loc) {
        for (Map.Entry<String, Lift> entry : DataManager.getLifts().entrySet()) {
            for (LiftBlock block : entry.getValue().getBlocks()) {
                //Check for world, x and z
                if (block.getWorld().equals(Objects.requireNonNull(loc.getWorld(), "World is null at getLiftByLocation").getName()) && block.getX() == loc.getBlockX() && block.getZ() == loc.getBlockZ()) {
                    return entry.getKey();
                }
            }
        }
        return null;
    }

    /**
     * Rename a lift
     *
     * @param liftName The name of the lift
     * @param newName  The new name of the lift
     */
    public void renameLift(String liftName, String newName) {
        if (liftName == null || newName == null || !DataManager.containsLift(liftName)) return;

        Lift lift = DataManager.getLift(liftName);
        DataManager.removeLift(liftName);
        DataManager.addLift(newName, lift);
        for (LiftSign ls : lift.getSigns()) {
            Block block = Objects.requireNonNull(Bukkit.getWorld(ls.getWorld()), "World is null at renameLift").getBlockAt(ls.getX(), ls.getY(), ls.getZ());
            BlockState bs = block.getState();
            if (!(bs instanceof Sign)) continue;
            Sign si = (Sign) bs;
            si.setLine(1, newName);
            si.update();
        }
    }

    /**
     * Add a block to a lift
     * Use {@link V10LiftAPI#sortLiftBlocks(String liftName)} after!
     *
     * @param liftName The name of the lift
     * @param block    The block
     * @return 0 if added, -1 if null or doesn't exists, -2 if forbidden, -3 if already added
     */
    public int addBlockToLift(String liftName, Block block) {
        if (liftName == null || block == null || !DataManager.containsLift(liftName)) return -1;
        Lift lift = DataManager.getLift(liftName);
        return addBlockToLift(lift.getBlocks(), block);
    }

    /**
     * Add a block to a lift
     * Use {@link V10LiftAPI#sortLiftBlocks(String liftName)} after!
     *
     * @param blocks The blockset
     * @param block  The block
     * @return 0 if added, -1 if null or doesn't exists, -2 if forbidden, -3 if already added
     */
    public int addBlockToLift(Set<LiftBlock> blocks, @Nonnull Block block) {
        return addBlockToLift(blocks, new LiftBlock(block));
    }

    /**
     * Add a block to a lift
     * Use {@link V10LiftAPI#sortLiftBlocks(String liftName)} after!
     *
     * @param blocks The blockset
     * @param block  The LiftBlock
     * @return 0 if added, -2 if forbidden, -3 if already added
     */
    public int addBlockToLift(@Nonnull Set<LiftBlock> blocks, @Nonnull LiftBlock block) {
        if (ForbiddenBlockManager.isForbidden(block.getMat())) return -2;
        if (blocks.contains(block)) return -3;
        blocks.add(block);
        return 0;
    }

    /**
     * Remove a block from a lift
     * Use {@link V10LiftAPI#sortLiftBlocks(String liftName)} after!
     *
     * @param liftName The name of the lift
     * @param block    The block
     * @return 0 if removed, -1 if null or doesn't exists, -2 if not added
     */
    public int removeBlockFromLift(String liftName, Block block) {
        if (liftName == null || block == null || !DataManager.containsLift(liftName)) return -1;
        Lift lift = DataManager.getLift(liftName);
        LiftBlock lb = new LiftBlock(block);
        if (!lift.getBlocks().contains(lb)) return -2;
        lift.getBlocks().remove(lb);
        return 0;
    }

    /**
     * Switch a block at a lift
     * Use {@link V10LiftAPI#sortLiftBlocks(String liftName)} after!
     *
     * @param liftName The name of the lift
     * @param block    The block
     * @return 0 if added, 1 if removed, -1 if null or doesn't exists, -2 if not added
     */
    public int switchBlockAtLift(String liftName, Block block) {
        if (liftName == null || block == null || !DataManager.containsLift(liftName)) return -1;
        return switchBlockAtLift(DataManager.getLift(liftName).getBlocks(), block);
    }

    /**
     * Switch a block at a lift
     * Use {@link V10LiftAPI#sortLiftBlocks(String liftName)} after!
     *
     * @param blocks The blockset
     * @param block  The block
     * @return 0 if added, 1 if removed, -1 if null or doesn't exists, -2 if not added
     */
    public int switchBlockAtLift(TreeSet<LiftBlock> blocks, Block block) {
        if (blocks == null || block == null) return -1;
        if (ForbiddenBlockManager.isForbidden(block.getType())) return -2;
        LiftBlock lb = new LiftBlock(block);
        if (blocks.contains(lb)) {
            blocks.remove(lb);
            return 1;
        }
        blocks.add(lb);
        return 0;
    }

    /**
     * Sort the blocks of a lift.
     * Use this after they have been modified.
     *
     * @param liftName The name of the lift
     */
    public void sortLiftBlocks(String liftName) {
        if (liftName != null && DataManager.containsLift(liftName)) {
            Lift lift = DataManager.getLift(liftName);
            if (lift.getWorldName() == null) lift.setWorldName(lift.getBlocks().first().getWorld());
            World world = Bukkit.getWorld(lift.getWorldName());
            if (world == null) return;
            lift.setY(world.getMaxHeight());
            for (LiftBlock lb : lift.getBlocks()) {
                if (lb.getY() < lift.getY()) {
                    lift.setY(lb.getY());
                    lift.setWorldName(lb.getWorld());
                }
            }
        }
    }

    /**
     * Open the door
     *
     * @param liftName The name of the lift
     * @return true/false
     */
    public boolean openDoor(String liftName) {
        if (liftName == null || !DataManager.containsLift(liftName)) return false;

        Lift lift = DataManager.getLift(liftName);

        if (lift.getQueue() != null) return false;

        Floor f = null;
        for (Floor fl : lift.getFloors().values()) {
            if (fl.getY() == lift.getY() && fl.getWorld().equals(lift.getWorldName())) {
                f = fl;
                break;
            }
        }

        if (f == null) return false;

        if (lift.getDoorOpen() != null && !closeDoor(liftName)) return false;

        for (LiftBlock lb : f.getDoorBlocks()) {
            Block block = Objects.requireNonNull(Bukkit.getWorld(lb.getWorld()), "World is null at openDoor").getBlockAt(lb.getX(), lb.getY(), lb.getZ());
            block.setType(Material.AIR);
        }

        for (LiftBlock lb : f.getRealDoorBlocks()) {
            Block block = Objects.requireNonNull(Bukkit.getWorld(lb.getWorld()), "World is null at openDoor").getBlockAt(lb.getX(), lb.getY(), lb.getZ());
            DoorUtil.openDoor(block);
        }

        lift.setDoorOpen(f);

        if (lift.isRealistic()) lift.setDoorCloser(new DoorCloser(liftName));
        return true;
    }

    /**
     * Open the door
     *
     * @param lift     The lift
     * @param liftName The name of the lift
     * @param f        The floor
     * @return true/false
     */
    public boolean openDoor(Lift lift, String liftName, Floor f) {
        if (lift == null || liftName == null || f == null) return false;
        if (lift.getDoorOpen() != null && !closeDoor(liftName)) return false;

        for (LiftBlock lb : f.getDoorBlocks()) {
            Block block = Objects.requireNonNull(Bukkit.getWorld(lb.getWorld()), "World is null at openDoor").getBlockAt(lb.getX(), lb.getY(), lb.getZ());
            block.setType(Material.AIR);
        }

        for (LiftBlock lb : f.getRealDoorBlocks()) {
            Block block = Objects.requireNonNull(Bukkit.getWorld(lb.getWorld()), "World is null at openDoor").getBlockAt(lb.getX(), lb.getY(), lb.getZ());
            DoorUtil.openDoor(block);
        }

        lift.setDoorOpen(f);

        if (lift.isRealistic()) lift.setDoorCloser(new DoorCloser(liftName));
        return true;
    }

    /**
     * Close a lift door
     *
     * @param liftName The name of the lift
     * @return true if door was closed, false if else.
     */
    public boolean closeDoor(String liftName) {
        if (liftName == null || !DataManager.containsLift(liftName)) return false;

        Lift lift = DataManager.getLift(liftName);

        boolean blocked = false;
        if (lift.getDoorOpen() == null) {
            return true;
        }

        if (lift.isRealistic()) {
            for (LiftBlock lb : lift.getDoorOpen().getDoorBlocks()) {
                Block block = Objects.requireNonNull(Bukkit.getWorld(lb.getWorld()), "World is null at closeDoor").getBlockAt(lb.getX(), lb.getY(), lb.getZ());
                for (Entity ent : block.getChunk().getEntities()) {
                    Location loc = ent.getLocation();
                    if (loc.getBlockX() == lb.getX() && loc.getBlockY() == lb.getY() && loc.getBlockZ() == lb.getZ()) {
                        blocked = true;
                        break;
                    }
                }
                if (blocked) break;
            }

            for (LiftBlock lb : lift.getDoorOpen().getRealDoorBlocks()) {
                Block block = Objects.requireNonNull(Bukkit.getWorld(lb.getWorld()), "World is null at closeDoor").getBlockAt(lb.getX(), lb.getY(), lb.getZ());
                for (Entity ent : block.getChunk().getEntities()) {
                    Location loc = ent.getLocation();

                    if (loc.getBlockX() == lb.getX() && loc.getBlockY() == lb.getY() && loc.getBlockZ() == lb.getZ()) {
                        blocked = true;
                        break;
                    }
                }
                if (blocked) break;
            }
        }

        if (!blocked) {
            for (LiftBlock lb : lift.getDoorOpen().getDoorBlocks()) {
                Block block = Objects.requireNonNull(Bukkit.getWorld(lb.getWorld()), "World is null at closeDoor").getBlockAt(lb.getX(), lb.getY(), lb.getZ());
                BlockState state = block.getState();
                state.setType(lb.getMat());
                state.update(true);
            }

            for (LiftBlock lb : lift.getDoorOpen().getRealDoorBlocks()) {
                Block block = Objects.requireNonNull(Bukkit.getWorld(lb.getWorld()), "World is null at closeDoor").getBlockAt(lb.getX(), lb.getY(), lb.getZ());
                DoorUtil.closeDoor(block);
            }

            lift.setDoorOpen(null);
            if (lift.getDoorCloser() != null) lift.getDoorCloser().stop();
        }

        return !blocked;
    }

    /**
     * To check if a lift has an open door.
     *
     * @param liftName The name of the lift
     * @return true if open, false if else
     */
    public boolean hasDoorOpen(String liftName) {
        return (liftName != null && DataManager.containsLift(liftName)) && DataManager.getLift(liftName).getDoorOpen() != null;
    }

    /**
     * Adds a new floor to a lift
     *
     * @param liftName  The name of the lift
     * @param floorName The name of the floor
     * @param floor     The floor object
     * @return 0 if added, -1 if null or doesn't exists, -2 if height is to high, -3 if floor already exists
     */
    public int addFloor(String liftName, String floorName, Floor floor) {
        if (liftName == null || floorName == null || floor == null || !DataManager.containsLift(liftName) || floor.getWorld() == null)
            return -1;
        if (floor.getY() > Objects.requireNonNull(Bukkit.getServer().getWorld(floor.getWorld()), "World is null at addNewFloor!").getMaxHeight())
            return -2;
        if (floorName.length() > 13) floorName = floorName.substring(0, 13).trim();
        Lift lift = DataManager.getLift(liftName);
        if (lift.getFloors().containsKey(floorName) || lift.getFloors().containsValue(floor)) return -3;

        lift.getFloors().put(floorName, floor);
        sortFloors(lift);
        return 0;
    }

    /**
     * Removes a floor from a lift
     *
     * @param liftName  The name of the lift
     * @param floorName The name of the floor
     * @return true if removed, false if null or doesn't exists
     */
    public boolean removeFloor(String liftName, String floorName) {
        if (liftName == null || floorName == null || !DataManager.containsLift(liftName)) return false;
        Lift lift = DataManager.getLift(liftName);
        if (!lift.getFloors().containsKey(floorName)) return false;

        lift.getFloors().remove(floorName);
        lift.getInputs().removeIf(liftBlock -> liftBlock.getFloor().equals(floorName));
        return true;
    }

    /**
     * Rename a floor from a lift
     *
     * @param liftName The name of the lift
     * @param oldName  The old name of the floor
     * @param newName  The new name of the floor
     * @return 0 if renamed, -1 if null or doesn't exists, -2 if floor doesn't exists, -3 if floor already exists
     */
    public int renameFloor(String liftName, String oldName, String newName) {
        if (liftName == null || oldName == null || newName == null || !DataManager.containsLift(liftName)) return -1;
        Lift lift = DataManager.getLift(liftName);
        if (!lift.getFloors().containsKey(oldName)) return -2;
        if (newName.length() > 13) newName = newName.substring(0, 13).trim();
        if (lift.getFloors().containsKey(newName)) return -3;

        Floor f = lift.getFloors().get(oldName);
        lift.getFloors().remove(oldName);
        lift.getFloors().put(newName, f);
        sortFloors(lift);
        Iterator<LiftBlock> liter = lift.getInputs().iterator();
        LiftBlock lb;
        ArrayList<LiftBlock> newBlocks = new ArrayList<>();
        while (liter.hasNext()) {
            lb = liter.next();
            if (lb.getFloor().equals(oldName)) {
                liter.remove();
                newBlocks.add(new LiftBlock(lb.getWorld(), lb.getX(), lb.getY(), lb.getZ(), newName));
            }
        }
        newBlocks.forEach(nlb -> lift.getInputs().add(nlb));
        return 0;
    }

    /**
     * Check if a lift is defective
     *
     * @param liftName The name of the lift
     * @return true/false
     */
    public boolean isDefective(String liftName) {
        if (liftName == null || !DataManager.containsLift(liftName)) return false;
        return DataManager.getLift(liftName).isDefective();
    }

    /**
     * Set a lift to (not) defective
     *
     * @param liftName The name of the lift
     * @param state    true/false
     * @return 0 if set, -1 if null or doesn't exists, -2 if same state, -3 if no signs, -4 if wrong sign
     */
    public int setDefective(String liftName, boolean state) {
        if (liftName == null || !DataManager.containsLift(liftName)) return -1;
        Lift lift = DataManager.getLift(liftName);
        boolean oldState = lift.isDefective();
        if (oldState == state) return -2;
        lift.setDefective(state);
        if (state) {
            //SET DEFECTIVE
            //Update sign
            for (LiftSign ls : lift.getSigns()) {
                Block block = Objects.requireNonNull(Bukkit.getWorld(ls.getWorld()), "World is null at setDefective").getBlockAt(ls.getX(), ls.getY(), ls.getZ());
                BlockState bs = block.getState();
                if (!(bs instanceof Sign)) {
                    Bukkit.getLogger().severe("[V10Lift] Wrong sign removed at: " + LocationSerializer.serialize(block.getLocation()));
                    return -4;
                }

                Sign s = (Sign) bs;
                ls.setOldText(s.getLine(3));
                s.setLine(3, ConfigUtil.getConfigText("DefectText"));
                s.update();
            }

            //Update all cab signs
            for (LiftBlock lb : lift.getBlocks()) {
                BlockState bs = Objects.requireNonNull(Bukkit.getWorld(lb.getWorld()), "World is null at setDefective").getBlockAt(lb.getX(), lb.getY(), lb.getZ()).getState();
                if (!(bs instanceof Sign)) continue;

                Sign s = (Sign) bs;
                lift.setSignText(s.getLine(3));
                s.setLine(3, ConfigUtil.getConfigText("DefectText"));
                s.update();
            }
        } else {

            //Update sign
            for (LiftSign ls : lift.getSigns()) {
                Block block = Objects.requireNonNull(Bukkit.getWorld(ls.getWorld()), "World is null at setDefective").getBlockAt(ls.getX(), ls.getY(), ls.getZ());
                BlockState bs = block.getState();
                if (!(bs instanceof Sign)) {
                    Bukkit.getLogger().severe("[V10Lift] Wrong sign removed at: " + LocationSerializer.serialize(block.getLocation()));
                    return -4;
                }

                Sign s = (Sign) bs;
                s.setLine(3, ls.getOldText());
                ls.setOldText(null);
                s.update();
            }

            //Update all cab signs
            for (LiftBlock lb : lift.getBlocks()) {
                BlockState bs = Objects.requireNonNull(Bukkit.getWorld(lb.getWorld()), "World is null at setDefective").getBlockAt(lb.getX(), lb.getY(), lb.getZ()).getState();
                if (!(bs instanceof Sign)) continue;

                Sign s = (Sign) bs;
                s.setLine(3, lift.getSignText());
                s.update();
            }
            lift.setSignText(null);
        }
        return 0;
    }

    /**
     * Get the userWhitelist of a lift
     *
     * @param liftName  The name of the lift
     * @param floorName The name of the floor
     * @return list with UUIDs of the players
     */
    public HashSet<UUID> getUserWhitelist(String liftName, String floorName) {
        HashSet<UUID> ret = new HashSet<>();
        if (liftName != null && floorName != null && DataManager.containsLift(liftName)) {
            Lift lift = DataManager.getLift(liftName);
            if (lift.getFloors().containsKey(floorName)) {
                ret = lift.getFloors().get(floorName).getUserWhitelist();
            }
        }
        return ret;
    }

    /**
     * Get the groupWhitelist of a lift
     *
     * @param liftName  The name of the lift
     * @param floorName The name of the floor
     * @return list with groupnames
     */
    public HashSet<String> getGroupWhitelist(String liftName, String floorName) {
        HashSet<String> ret = new HashSet<>();
        if (liftName != null && floorName != null && DataManager.containsLift(liftName)) {
            Lift lift = DataManager.getLift(liftName);
            if (lift.getFloors().containsKey(floorName)) {
                ret = lift.getFloors().get(floorName).getGroupWhitelist();
            }
        }
        return ret;
    }

    /**
     * Check if a lift is offline
     *
     * @param liftName The name of the lift
     * @return true/false
     */
    public boolean isOffline(String liftName) {
        if (liftName == null || !DataManager.containsLift(liftName)) return false;
        return DataManager.getLift(liftName).isOffline();
    }

    /**
     * Set a lift to (not) offline
     *
     * @param liftName The name of the lift
     * @param state    true/false
     * @return 0 if set, -1 if null or doesn't exists, -2 if same state
     */
    public int setOffline(String liftName, boolean state) {
        if (liftName == null || !DataManager.containsLift(liftName)) return -1;
        Lift lift = DataManager.getLift(liftName);
        boolean oldState = lift.isOffline();
        if (oldState == state) return -2;
        lift.setOffline(state);
        Iterator<LiftSign> liter = lift.getSigns().iterator();
        BlockState bs;
        Sign sign;
        if (state) {
            for (LiftBlock lb : lift.getBlocks()) {
                bs = Objects.requireNonNull(Bukkit.getWorld(lb.getWorld()), "World is null at setOffline").getBlockAt(lb.getX(), lb.getY(), lb.getZ()).getState();
                if (!(bs instanceof Sign)) continue;
                sign = (Sign) bs;
                if (!sign.getLine(0).equalsIgnoreCase(ConfigUtil.getConfigText("SignText"))) continue;
                sign.setLine(3, ConfigUtil.getConfigText("DisabledText"));
                sign.update();
            }

            while (liter.hasNext()) {
                LiftSign ls = liter.next();
                bs = Objects.requireNonNull(Bukkit.getWorld(ls.getWorld()), "World is null at setOffline").getBlockAt(ls.getX(), ls.getY(), ls.getZ()).getState();
                if (!(bs instanceof Sign)) {
                    Bukkit.getLogger().severe("[V10Lift] Wrong sign removed at: " + LocationSerializer.serialize(bs.getBlock().getLocation()));
                    liter.remove();
                    continue;
                }
                sign = (Sign) bs;
                ls.setOldText(sign.getLine(3));
                sign.setLine(3, ConfigUtil.getConfigText("DisabledText"));
                sign.update();
            }
        } else {
            for (LiftBlock lb : lift.getBlocks()) {
                bs = Objects.requireNonNull(Bukkit.getWorld(lb.getWorld()), "World is null at setOffline").getBlockAt(lb.getX(), lb.getY(), lb.getZ()).getState();
                if (!(bs instanceof Sign)) continue;
                sign = (Sign) bs;
                if (!sign.getLine(0).equalsIgnoreCase(ConfigUtil.getConfigText("SignText"))) continue;
                sign.setLine(3, "");
                sign.update();
            }

            while (liter.hasNext()) {
                LiftSign ls = liter.next();
                bs = Objects.requireNonNull(Bukkit.getWorld(ls.getWorld()), "World is null at setOffline").getBlockAt(ls.getX(), ls.getY(), ls.getZ()).getState();
                if (!(bs instanceof Sign)) {
                    Bukkit.getLogger().severe("[V10Lift] Wrong sign removed at: " + LocationSerializer.serialize(bs.getBlock().getLocation()));
                    liter.remove();
                    continue;
                }
                sign = (Sign) bs;
                sign.setLine(3, ls.getOldText());
                sign.update();
                ls.setOldText(null);
            }
        }
        return 0;
    }

    /**
     * Check if a lift contains the block as rope
     *
     * @param liftName The name of the lift
     * @param block    The block
     * @return true/false
     */
    public boolean containsRope(String liftName, Block block) {
        if (liftName == null || block == null || !DataManager.containsLift(liftName)) return false;

        Lift lift = DataManager.getLift(liftName);
        if (lift.getRopes().isEmpty()) return false;

        String world = block.getWorld().getName();
        int x = block.getX();
        int y = block.getY();
        int z = block.getZ();

        for (LiftRope rope : lift.getRopes()) {
            if (x != rope.getX() || z != rope.getZ()) continue;
            if (y >= rope.getMinY() && y <= rope.getMaxY()) {
                return true;
            }
        }
        return false;
    }

    /**
     * Check if a block is a rope
     *
     * @param b The block
     * @return true/false
     */
    public boolean isRope(Block b) {
        for (String lift : DataManager.getLifts().keySet()) {
            if (containsRope(lift, b)) return true;
        }
        return false;
    }

    /**
     * Send info about a lift to a player
     *
     * @param sender   Where you want to send it to
     * @param liftName The name of the lift
     */
    public void sendLiftInfo(CommandSender sender, String liftName) {
        sendLiftInfo(sender, liftName, DataManager.getLift(liftName));
    }

    /**
     * Send info about a lift to a player
     *
     * @param ent      Where you want to send it to
     * @param liftName The name of the lift
     * @param lift     The lift
     */
    public void sendLiftInfo(@Nonnull CommandSender ent, String liftName, @Nonnull Lift lift) {

        ent.sendMessage(ChatColor.GOLD + "Elevator: " + ChatColor.YELLOW + liftName);
        ent.sendMessage(ChatColor.GOLD + "Settings:");
        ent.sendMessage(ChatColor.GREEN + "  Speed: " + ChatColor.YELLOW + lift.getSpeed());
        ent.sendMessage(ChatColor.GREEN + "  Realistic Mode: " + ChatColor.YELLOW + lift.isRealistic());
        ent.sendMessage(ChatColor.GREEN + "  Malfunction: " + ChatColor.YELLOW + lift.isDefective());
        ent.sendMessage(ChatColor.GOLD + "Floors:");
        if (lift.getFloors().isEmpty()) {
            ent.sendMessage(ChatColor.RED + "None.");
        } else {
            for (Map.Entry<String, Floor> entry : lift.getFloors().entrySet()) {
                ent.sendMessage(ChatColor.GREEN + "  " + entry.getKey() + ":");
                Floor f = entry.getValue();
                ent.sendMessage(ChatColor.YELLOW + "    World: " + ChatColor.GREEN + f.getWorld());
                ent.sendMessage(ChatColor.YELLOW + "    Height: " + ChatColor.GREEN + f.getY());
                ent.sendMessage(ChatColor.YELLOW + "    Whitelist:");
                if (f.getUserWhitelist().isEmpty() && f.getGroupWhitelist().isEmpty()) {
                    ent.sendMessage(ChatColor.GOLD + "      None.");
                } else {
                    ChatColor color = ChatColor.DARK_PURPLE;
                    Iterator<UUID> iter = f.getUserWhitelist().iterator();
                    Iterator<String> iter2 = f.getGroupWhitelist().iterator();
                    StringBuilder sb = new StringBuilder();
                    sb.append("      ").append(color).append(Bukkit.getOfflinePlayer(iter.next()).getName());
                    while (iter.hasNext()) {
                        if (color == ChatColor.DARK_PURPLE) {
                            color = ChatColor.LIGHT_PURPLE;
                        } else {
                            color = ChatColor.DARK_PURPLE;
                        }
                        sb.append(ChatColor.AQUA).append(", ").append(color).append(Bukkit.getOfflinePlayer(iter.next()).getName());
                    }
                    while (iter2.hasNext()) {
                        if (color == ChatColor.DARK_PURPLE) {
                            color = ChatColor.LIGHT_PURPLE;
                        } else {
                            color = ChatColor.DARK_PURPLE;
                        }
                        sb.append(ChatColor.AQUA).append(", ").append(color).append("Group: ").append(iter2.next());
                    }
                    ent.sendMessage(sb.toString());
                }
            }
        }
    }

    /**
     * Add a rope to a lift
     *
     * @param lift  The name of the lift
     * @param world The world
     * @param x     The x-pos
     * @param minY  The min y-pos
     * @param maxY  The max y-pos
     * @param z     The z-pos
     * @return 0 if added, -1 if null or doesn't exists, -2 if not same mat, -3 if already a rope, -4 if forbidden material
     */
    public int addRope(String lift, World world, int x, int minY, int maxY, int z) {
        if (lift == null || !DataManager.containsLift(lift) || world == null) return -1;

        //minY = maxY, so reverse
        if (minY > maxY) {
            int tempY = minY;
            minY = maxY;
            maxY = tempY;
        }

        Block block = world.getBlockAt(x, minY, z);
        if (isRope(block)) return -3;
        Material mat = block.getType();
        if (ForbiddenBlockManager.isForbidden(mat)) return -4;

        for (int i = minY + 1; i <= maxY; i++) {
            block = world.getBlockAt(x, i, z);
            if (isRope(block)) return -3;
            if (block.getType() != mat) return -2;
        }

        LiftRope rope = new LiftRope(block, minY, maxY);
        DataManager.getLift(lift).getRopes().add(rope);

        return 0;
    }

    /**
     * Remove a rope from a lift
     *
     * @param lift  The name of the lift
     * @param block The block
     * @return true/false
     */
    public boolean removeRope(String lift, Block block) {
        if (lift == null || block == null || !DataManager.containsLift(lift) || !containsRope(lift, block))
            return false;

        String world = block.getWorld().getName();
        int x = block.getX();
        int y = block.getY();
        int z = block.getZ();
        Iterator<LiftRope> riter = DataManager.getLift(lift).getRopes().iterator();
        while (riter.hasNext()) {
            LiftRope rope = riter.next();
            if (x != rope.getX() || z != rope.getZ()) continue;
            if (world.equals(rope.getWorld())) {
                if (y >= rope.getMinY() && y <= rope.getMaxY()) {
                    riter.remove();
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * Set the queue of a lift
     *
     * @param liftName The name of the lift
     * @param queue    The queue
     * @return true/false
     */
    public boolean setQueue(String liftName, LinkedHashMap<String, Floor> queue) {
        if (liftName == null || queue == null || !DataManager.containsLift(liftName)) return false;

        Lift lift = DataManager.getLift(liftName);
        lift.setQueue(new LinkedHashMap<>());
        for (Map.Entry<String, Floor> e : queue.entrySet()) {
            addToQueue(liftName, e.getValue(), e.getKey());
        }
        return true;
    }

    /**
     * Add a location to the queue
     *
     * @param lift  The name of the lift
     * @param y     The y-pos
     * @param world The world
     * @return true/false
     */
    public boolean addToQueue(String lift, int y, World world) {
        return addToQueue(lift, y, world, null);
    }

    /**
     * Add a location to the queue
     *
     * @param lift      The name of the lift
     * @param y         The y-pos
     * @param world     The world
     * @param floorName The name of the flor
     * @return true/false
     */
    public boolean addToQueue(String lift, int y, @Nonnull World world, String floorName) {
        return addToQueue(lift, new Floor(y, world.getName()), floorName);
    }

    /**
     * Add a location to the queue
     *
     * @param lift      The name of the lift
     * @param floor     The {@link Floor}
     * @param floorName The name of the flor
     * @return true/false
     */
    public boolean addToQueue(String lift, Floor floor, String floorName) {
        if (lift == null || floor == null || !DataManager.containsLift(lift)) return false;

        Lift l = DataManager.getLift(lift);
        if (l.getQueue() == null) {
            l.setQueue(new LinkedHashMap<>());
        }

        if (!l.getQueue().containsValue(floor)) {
            if (floorName == null) {
                floorName = ChatColor.MAGIC + "-----";
                for (Map.Entry<String, Floor> e : l.getFloors().entrySet()) {
                    if (e.getValue().equals(floor)) {
                        floorName = e.getKey();
                        floor = e.getValue();
                        break;
                    }
                }
            }

            l.getQueue().put(floorName, floor);
            startLift(lift);
            return true;
        }
        return false;
    }
}