package me.bradleysteele.worldborderpatches.worker;

import com.google.common.collect.Lists;
import me.bradleysteele.commons.register.worker.BWorker;
import me.bradleysteele.commons.resource.Resource;
import me.bradleysteele.worldborderpatches.resource.ResourceType;
import me.bradleysteele.worldborderpatches.resource.Resources;
import me.bradleysteele.worldborderpatches.resource.yml.Config;
import org.bukkit.*;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.block.*;
import org.bukkit.event.entity.CreatureSpawnEvent;
import org.bukkit.event.entity.EntityChangeBlockEvent;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.entity.EntityExplodeEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.player.PlayerMoveEvent;
import org.bukkit.event.player.PlayerTeleportEvent;

import java.util.Iterator;
import java.util.List;

/**
 * @author Bradley Steele
 */
public class WorkerPatches extends BWorker {

    private static final WorkerPatches instance = new WorkerPatches();

    public static WorkerPatches get() {
        return instance;
    }

    private final List<Material> FALLING_BLOCKS = Lists.newArrayList(Material.SAND, Material.GRAVEL);

    private Resource netherResource;
    private BorderContainer netherBorder;

    private WorkerPatches() {
    }

    @Override
    public void onRegister() {
        // netherResource = Resources.get().getResource(ResourceType.NETHER);
        // netherBorder = new BorderContainer(netherResource.getDouble("centerX"), netherResource.getDouble("centerZ"), netherResource.getDouble("size", 100000000));
    }

    @EventHandler
    public void onPlayerMove(PlayerMoveEvent event) {
        if (isOutsideBorder(event.getTo()) && !isOutsideBorder(event.getFrom())) {
            event.setTo(event.getFrom());
        }
    }

    @EventHandler
    public void onPlayerTeleport(PlayerTeleportEvent event) {
        if (isOutsideBorder(event.getTo()) && !isOutsideBorder(event.getFrom())) {
            event.setCancelled(true);
            event.setTo(event.getFrom());
        }
    }

    @EventHandler
    public void onBlockBreak(BlockBreakEvent event) {
        if (Config.BLOCK_BREAK.getAsBoolean()) {
            event.setCancelled(isOutsideBorder(event.getBlock().getLocation()));
        }
    }

    @EventHandler
    public void BlockPlaceEvent(BlockPlaceEvent event) {
        location.getWorld().spawnFallingBlock(location, Material.Bedrock, blockData);

        if (event.getBlock().getWorld().getName().equals(plugin.getConfig().getString("space"))) {
            if (event.getBlock().getType().equals(Material.SAND) || event.getBlock().getType().equals(Material.WEB)) {

                Block block = event.getBlock();
                Location loc = block.getLocation().add(0, -1, 0);
                if (loc.getBlock().getType().equals(Material.AIR) || event.getBlock().getType().equals(Material.WEB))) {
                    loc.getBlock().setType(Material.STONE);

                    plugin.getServer().getScheduler().runTaskLater(plugin, new Runnable() {
                        public void run() {
                            loc.getBlock().setType(Material.AIR);
                        }
                    }, 1L);

                }

            }

        }

    }

    @EventHandler
    public void onEntityChangeBlock(EntityChangeBlockEvent event) {
        Material material = e.getBlock().getType();

        if (material == Material.SAND && e.getEntityType() == EntityType.FALLING_BLOCK){
            e.getEntity().remove();
        }
    }

    private void handleFallingBlock(Block block) {
        Material type = block.getType();
        Block current = block;
        Block next;

        for (int i = block.getY(); i > 0; i--) {
            next = current.getRelative(0, -1, 0);

                /*if (isPlayerAt(next.getWorld(), next.getX(), next.getY(), next.getZ())) {
                    event.setCancelled(true);
                    return;
                }*/

            if (next.getType() != Material.AIR) {
                block.setType(Material.AIR);
                current.setType(type);
                break;
            } else {
                current = next;
            }
        }
    }

    private boolean isPlayerAt(World world, int x, int y, int z) {
        for (Player player : world.getPlayers()) {
            if (player.getLocation().getBlockX() == x && player.getLocation().getBlockY() == y && player.getLocation().getBlockZ() == z) {
                return true;
            }
        }

        return false;
    }

    @EventHandler
    public void onBlockFromTo(BlockFromToEvent event) {
        if (Config.BLOCK_FROM_TO.getAsBoolean()) {
            event.setCancelled(isOutsideBorder(event.getToBlock().getLocation()));
        }
    }

    @EventHandler
    public void onEntityExplode(EntityExplodeEvent event) {
        if (Config.EXPLOSIONS.getAsBoolean()) {
            if (isOutsideBorder(event.getLocation())) {
                event.setCancelled(true);
            } else {
                handleIterator(event.blockList().iterator());
            }
        }
    }

    @EventHandler
    public void onBlockExplode(BlockExplodeEvent event) {
        if (Config.EXPLOSIONS.getAsBoolean()) {
            if (isOutsideBorder(event.getBlock().getLocation())) {
                event.setCancelled(true);
            } else {
                handleIterator(event.blockList().iterator());
            }
        }
    }

    @EventHandler
    public void onPlayerInteract(PlayerInteractEvent event) {
        if (Config.INTERACT.getAsBoolean()) {
            if (event.hasBlock() && isOutsideBorder(event.getClickedBlock().getLocation())) {
                event.setCancelled(true);
            }
        }
    }

    @EventHandler
    public void onCreatureSpawn(CreatureSpawnEvent event) {
        if (Config.CREATURE_SPAWN.getAsBoolean()) {
            event.setCancelled(isOutsideBorder(event.getLocation()));
        }
    }

    @EventHandler
    public void onBlockPiston(BlockPistonExtendEvent event) {
        if (Config.PISTON.getAsBoolean()) {
            for (Block block : event.getBlocks()) {
                if (isOutsideBorder(block.getRelative(event.getDirection()).getLocation())) {
                    event.setCancelled(true);
                    return;
                }
            }
        }
    }

    @EventHandler
    public void onBlockUpdate(EntityChangeBlockEvent event) {
        if (Config.BLOCK_UPDATE.getAsBoolean()) {
            event.setCancelled(isOutsideBorder(event.getBlock().getLocation()));
        }
    }

    @EventHandler
    public void onEntityDamage(EntityDamageByEntityEvent event) {
        if (Config.ENTITY_DAMAGE.getAsBoolean()) {
            if (event.getDamager() instanceof Player) {
                event.setCancelled(isOutsideBorder(event.getEntity().getLocation()));
            }
        }
    }

    public BorderContainer getNetherBorder() {
        return netherBorder;
    }

    public void setNetherBorder(double centerX, double centerZ, double size) {
        netherBorder.centerX = centerX;
        netherBorder.centerZ = centerZ;
        netherBorder.size = size;

        // Save resource
        netherResource.set("centerX", centerX);
        netherResource.set("centerZ", centerZ);
        netherResource.set("size", size);
        plugin.getResourceProvider().saveResource(netherResource);
    }

    private void handleIterator(Iterator<Block> iterator) {
        Block block;

        while (iterator.hasNext()) {
            block = iterator.next();

            if (isOutsideBorder(block.getLocation())) {
                iterator.remove();
            }
        }
    }

    private boolean isOutsideBorder(Location location, int buffer) {
        BorderContainer border = new BorderContainer(location.getWorld().getWorldBorder());

        /*if (location.getWorld().getEnvironment() == World.Environment.NETHER) {
            border = netherBorder;
        } else {
            border = new BorderContainer(location.getWorld().getWorldBorder());
        }*/

        double size = (border.size / 2) - buffer;
        double x = location.getBlockX() - (border.centerX - 0.5D);
        double z = location.getBlockZ() - (border.centerZ - 0.5D);

        return ((x > size || (-x) > size) || (z > size || (-z) > size));
    }

    private boolean isOutsideBorder(Location location) {
        return isOutsideBorder(location, 0);
    }

    public class BorderContainer {

        double centerX;
        double centerZ;
        double size;

        BorderContainer(double centerX, double centerZ, double size) {
            this.centerX = centerX;
            this.centerZ = centerZ;
            this.size = size;
        }

        BorderContainer(WorldBorder border) {
            this(border.getCenter().getX(), border.getCenter().getZ(), border.getSize());
        }

        public double getCenterX() {
            return centerX;
        }

        public double getCenterZ() {
            return centerZ;
        }

        public double getSize() {
            return size;
        }
    }
}