package world.bentobox.bentobox.util.teleport;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CompletableFuture;

import org.bukkit.Bukkit;
import org.bukkit.ChunkSnapshot;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.World.Environment;
import org.bukkit.block.BlockFace;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitTask;
import org.bukkit.util.Vector;
import org.eclipse.jdt.annotation.Nullable;

import world.bentobox.bentobox.BentoBox;
import world.bentobox.bentobox.api.user.User;
import world.bentobox.bentobox.database.objects.Island;
import world.bentobox.bentobox.util.Pair;
import world.bentobox.bentobox.util.Util;

/**
 * A class that calculates finds a safe spot asynchronously and then teleports the player there.
 * @author tastybento
 *
 */
public class SafeSpotTeleport {

    private static final int MAX_CHUNKS = 6;
    private static final long SPEED = 1;
    private static final int MAX_RADIUS = 50;
    private static final int MAX_HEIGHT = 235;
    private boolean notChecking;
    private BukkitTask task;

    // Parameters
    private final Entity entity;
    private final Location location;
    private boolean portal;
    private final int homeNumber;

    // Locations
    private Location bestSpot;

    private final BentoBox plugin;
    private List<Pair<Integer, Integer>> chunksToScan;
    private final Runnable runnable;
    private final CompletableFuture<Boolean> result;
    private final String homeName;

    /**
     * Teleports and entity to a safe spot on island
     * @param builder - safe spot teleport builder
     */
    SafeSpotTeleport(Builder builder) {
        this.plugin = builder.getPlugin();
        this.entity = builder.getEntity();
        this.location = builder.getLocation();
        this.portal = builder.isPortal();
        this.homeNumber = builder.getHomeNumber();
        this.homeName = builder.getHomeName();
        this.runnable = builder.getRunnable();
        this.result = builder.getResult();

        // If there is no portal scan required, try the desired location immediately
        Util.getChunkAtAsync(location).thenRun(()-> tryTogo(builder.getFailureMessage()));
    }

    private void tryTogo(String failureMessage) {
        if (plugin.getIslands().isSafeLocation(location)) {
            if (portal) {
                // If the desired location is safe, then that's where you'll go if there's no portal
                bestSpot = location;
            } else {
                // If this is not a portal teleport, then go to the safe location immediately
                Util.teleportAsync(entity, location).thenRun(() -> {
                    if (runnable != null) Bukkit.getScheduler().runTask(plugin, runnable);
                    result.complete(true);
                });
                return;
            }
        }
        // Get chunks to scan
        chunksToScan = getChunksToScan();

        // Start checking
        notChecking = true;

        // Start a recurring task until done or cancelled
        task = Bukkit.getScheduler().runTaskTimer(plugin, () -> gatherChunks(failureMessage), 0L, SPEED);
    }

    private void gatherChunks(String failureMessage) {
        if (!notChecking) {
            return;
        }
        notChecking = false;
        List<ChunkSnapshot> chunkSnapshot = new ArrayList<>();
        Iterator<Pair<Integer, Integer>> it = chunksToScan.iterator();
        if (!it.hasNext()) {
            // Nothing left
            tidyUp(entity, failureMessage);
            return;
        }
        // Add chunk snapshots to the list
        while (it.hasNext() && chunkSnapshot.size() < MAX_CHUNKS) {
            Pair<Integer, Integer> pair = it.next();
            if (location.getWorld() != null) {
                boolean isLoaded = location.getWorld().getChunkAt(pair.x, pair.z).isLoaded();
                chunkSnapshot.add(location.getWorld().getChunkAt(pair.x, pair.z).getChunkSnapshot());
                if (!isLoaded) {
                    location.getWorld().getChunkAt(pair.x, pair.z).unload();
                }
            }
            it.remove();
        }
        // Move to next step
        checkChunks(chunkSnapshot);
    }

    private void tidyUp(Entity entity, String failureMessage) {
        // Still Async!
        // Nothing left to check and still not canceled
        task.cancel();
        // Check portal
        if (portal && bestSpot != null) {
            // Portals found, teleport to the best spot we found
            teleportEntity(bestSpot);
        } else if (entity instanceof Player) {
            // Return to main thread and teleport the player
            Bukkit.getScheduler().runTask(plugin, () -> {
                // Failed, no safe spot
                if (!failureMessage.isEmpty()) {
                    User.getInstance(entity).notify(failureMessage);
                }
                if (!plugin.getIWM().inWorld(entity.getLocation())) {
                    // Last resort
                    ((Player)entity).performCommand("spawn");
                } else {
                    // Create a spot for the player to be
                    if (location.getWorld().getEnvironment().equals(Environment.NETHER)) {
                        makeAndTelport(Material.NETHERRACK);
                    } else if (location.getWorld().getEnvironment().equals(Environment.THE_END)) {
                        makeAndTelport(Material.END_STONE);
                    } else {
                        makeAndTelport(Material.COBBLESTONE);
                    }
                }
                result.complete(false);
            });
        } else {
            result.complete(false);
        }
    }

    private void makeAndTelport(Material m) {
        location.getBlock().getRelative(BlockFace.DOWN).setType(m, false);
        location.getBlock().setType(Material.AIR, false);
        location.getBlock().getRelative(BlockFace.UP).setType(Material.AIR, false);
        location.getBlock().getRelative(BlockFace.UP).getRelative(BlockFace.UP).setType(m, false);
        Util.teleportAsync(entity, location.clone().add(new Vector(0.5D, 0D, 0.5D))).thenRun(() -> {
            if (runnable != null) Bukkit.getScheduler().runTask(plugin, runnable);
            result.complete(true);
        });
    }

    /**
     * Gets a set of chunk coords that will be scanned.
     * @return - list of chunk coords to be scanned
     */
    private List<Pair<Integer, Integer>> getChunksToScan() {
        List<Pair<Integer, Integer>> chunksToScan = new ArrayList<>();
        int maxRadius = plugin.getIslands().getIslandAt(location).map(Island::getProtectionRange).orElseGet(() -> plugin.getIWM().getIslandProtectionRange(location.getWorld()));
        maxRadius = Math.min(MAX_RADIUS, maxRadius);
        int x = location.getBlockX();
        int z = location.getBlockZ();
        // Create ever increasing squares around the target location
        int radius = 0;
        do {
            for (int i = x - radius; i <= x + radius; i+=16) {
                for (int j = z - radius; j <= z + radius; j+=16) {
                    addChunk(chunksToScan, new Pair<>(i,j), new Pair<>(i >> 4, j >> 4));
                }
            }
            radius++;
        } while (radius < maxRadius);
        return chunksToScan;
    }

    private void addChunk(List<Pair<Integer, Integer>> chunksToScan, Pair<Integer, Integer> blockCoord, Pair<Integer, Integer> chunkCoord) {
        if (!chunksToScan.contains(chunkCoord) && plugin.getIslands().getIslandAt(location).map(is -> is.inIslandSpace(blockCoord)).orElse(true)) {
            chunksToScan.add(chunkCoord);
        }
    }

    /**
     * Loops through the chunks and if a safe spot is found, fires off the teleportation
     * @param chunkSnapshot - list of chunk snapshots to check
     */
    private void checkChunks(final List<ChunkSnapshot> chunkSnapshot) {
        // Run async task to scan chunks
        Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
            for (ChunkSnapshot chunk: chunkSnapshot) {
                if (scanChunk(chunk)) {
                    task.cancel();
                    return;
                }
            }
            // Nothing happened, change state
            notChecking = true;
        });
    }


    /**
     * @param chunk - chunk snapshot
     * @return true if a safe spot was found
     */
    private boolean scanChunk(ChunkSnapshot chunk) {
        // Run through the chunk
        for (int x = 0; x< 16; x++) {
            for (int z = 0; z < 16; z++) {
                // Work down from the entry point up
                for (int y = Math.min(chunk.getHighestBlockYAt(x, z), MAX_HEIGHT); y >= 0; y--) {
                    if (checkBlock(chunk, x,y,z)) {
                        return true;
                    }
                } // end y
            } //end z
        } // end x
        return false;
    }

    /**
     * Teleports entity to the safe spot
     */
    private void teleportEntity(final Location loc) {
        task.cancel();
        // Return to main thread and teleport the player
        Bukkit.getScheduler().runTask(plugin, () -> {
            if (!portal && entity instanceof Player && (homeNumber > 0 || !homeName.isEmpty())) {
                // Set home if so marked
                plugin.getIslands().setHomeLocation(User.getInstance(entity), loc, homeName);
            }
            Util.teleportAsync(entity, loc).thenRun(() -> {
                if (runnable != null) Bukkit.getScheduler().runTask(plugin, runnable);
                result.complete(true);
            });
        });
    }

    /**
     * Returns true if the location is a safe one.
     * @param chunk - chunk snapshot
     * @param x - x coordinate
     * @param y - y coordinate
     * @param z - z coordinate
     * @return true if this is a safe spot, false if this is a portal scan
     */
    boolean checkBlock(ChunkSnapshot chunk, int x, int y, int z) {
        World world = location.getWorld();
        Material type = chunk.getBlockType(x, y, z);
        Material space1 = chunk.getBlockType(x, Math.min(y + 1, SafeSpotTeleport.MAX_HEIGHT), z);
        Material space2 = chunk.getBlockType(x, Math.min(y + 2, SafeSpotTeleport.MAX_HEIGHT), z);
        if (space1.equals(Material.NETHER_PORTAL) || space2.equals(Material.NETHER_PORTAL)) {
            // A portal has been found, switch to non-portal mode now
            portal = false;
        }
        if (plugin.getIslands().checkIfSafe(world, type, space1, space2)) {
            return safe(chunk, x, y, z, world);
        }
        return false;
    }

    private boolean safe(ChunkSnapshot chunk, int x, int y, int z, World world) {
        Vector newSpot = new Vector((chunk.getX() << 4) + x + 0.5D, y + 1.0D, (chunk.getZ() << 4) + z + 0.5D);
        if (portal) {
            if (bestSpot == null) {
                // Stash the best spot
                bestSpot = newSpot.toLocation(world);
            }
            return false;
        } else {
            teleportEntity(newSpot.toLocation(world));
            return true;
        }
    }

    public static class Builder {
        private final BentoBox plugin;
        private Entity entity;
        private int homeNumber = 0;
        private String homeName = "";
        private boolean portal = false;
        private String failureMessage = "";
        private Location location;
        private Runnable runnable;
        private CompletableFuture<Boolean> result = new CompletableFuture<>();

        public Builder(BentoBox plugin) {
            this.plugin = plugin;
        }

        /**
         * Set who or what is going to teleport
         * @param entity entity to teleport
         * @return Builder
         */
        public Builder entity(Entity entity) {
            this.entity = entity;
            return this;
        }

        /**
         * Set the island to teleport to
         * @param island island destination
         * @return Builder
         */
        public Builder island(Island island) {
            this.location = island.getProtectionCenter();
            return this;
        }

        /**
         * Set the home number to this number
         * @param homeNumber home number
         * @return Builder
         * @deprecated use {@link #homeName}
         */
        @Deprecated
        public Builder homeNumber(int homeNumber) {
            this.homeNumber = homeNumber;
            return this;
        }

        /**
         * Set the home name
         * @param homeName - home name
         * @return Builder
         * @Since 1.16.0
         */
        public Builder homeName(String homeName) {
            this.homeName = homeName;
            return this;
        }

        /**
         * This is a portal teleportation
         * @return Builder
         */
        public Builder portal() {
            this.portal = true;
            return this;
        }

        /**
         * Set the failure message if this teleport cannot happen
         * @param failureMessage failure message to report to user
         * @return Builder
         */
        public Builder failureMessage(String failureMessage) {
            this.failureMessage = failureMessage;
            return this;
        }

        /**
         * Set the desired location
         * @param location the location
         * @return Builder
         */
        public Builder location(Location location) {
            this.location = location;
            return this;
        }

        /**
         * Try to teleport the player
         * @return CompletableFuture that will become true if successfull and false if not
         * @since 1.14.0
         */
        @Nullable
        public CompletableFuture<Boolean> buildFuture() {
            build();
            return result;
        }

        /**
         * Try to teleport the player
         * @return SafeSpotTeleport
         */
        @Nullable
        public SafeSpotTeleport build() {
            // Error checking
            if (entity == null) {
                plugin.logError("Attempt to safe teleport a null entity!");
                result.complete(null);
                return null;
            }
            if (location == null) {
                plugin.logError("Attempt to safe teleport to a null location!");
                result.complete(null);
                return null;
            }
            if (failureMessage.isEmpty() && entity instanceof Player) {
                failureMessage = "general.errors.no-safe-location-found";
            }
            return new SafeSpotTeleport(this);
        }

        /**
         * The task to run after the player is safely teleported.
         * @param runnable - task
         * @return Builder
         * @since 1.13.0
         */
        public Builder thenRun(Runnable runnable) {
            this.runnable = runnable;
            return this;
        }

        /**
         * @return the plugin
         */
        public BentoBox getPlugin() {
            return plugin;
        }

        /**
         * @return the entity
         */
        public Entity getEntity() {
            return entity;
        }

        /**
         * @return the homeNumber
         */
        public int getHomeNumber() {
            return homeNumber;
        }

        /**
         * @return the homeName
         */
        public String getHomeName() {
            return homeName;
        }

        /**
         * @return the portal
         */
        public boolean isPortal() {
            return portal;
        }

        /**
         * @return the failureMessage
         */
        public String getFailureMessage() {
            return failureMessage;
        }

        /**
         * @return the location
         */
        public Location getLocation() {
            return location;
        }

        /**
         * @return the runnable
         */
        public Runnable getRunnable() {
            return runnable;
        }

        /**
         * @return the result
         * @since 1.14.0
         */
        public CompletableFuture<Boolean> getResult() {
            return result;
        }


    }
}