package com.garbagemule.MobArena;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.UUID;

import com.garbagemule.MobArena.events.ArenaCompleteEvent;

import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.craftbukkit.Main;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Zombie;
import org.bukkit.inventory.ItemStack;

import com.garbagemule.MobArena.events.NewWaveEvent;
import com.garbagemule.MobArena.framework.Arena;
import com.garbagemule.MobArena.region.ArenaRegion;
import com.garbagemule.MobArena.waves.*;
import com.garbagemule.MobArena.waves.enums.WaveType;
import com.garbagemule.MobArena.waves.types.BossWave;
import com.garbagemule.MobArena.waves.types.SupplyWave;
import com.garbagemule.MobArena.waves.types.UpgradeWave;

public class MASpawnThread implements Runnable
{
    private MobArena plugin;
    private Arena arena;
    private ArenaRegion region;
    private RewardManager rewardManager;
    private WaveManager waveManager;
    private MonsterManager monsterManager;

    private int playerCount, monsterLimit;
    private boolean waveClear, bossClear, preBossClear, wavesAsLevel;

    /**
     * Create a new monster spawner for the input arena. Note that the arena's
     * WaveManager is reset
     *
     * @param plugin
     *            a MobArena instance
     * @param arena
     *            an arena
     */
    public MASpawnThread(MobArena plugin, Arena arena) {
    this.plugin = plugin;
    this.arena = arena;
    this.region = arena.getRegion();
    this.rewardManager = arena.getRewardManager();
    this.waveManager = arena.getWaveManager();
    this.monsterManager = arena.getMonsterManager();

    reset();
    }

    /**
     * Reset the spawner, so all systems and settings are ready for a new
     * session.
     */
    public void reset() {
    waveManager.reset();
    playerCount = arena.getPlayersInArena().size();
    monsterLimit = arena.getSettings().getInt("monster-limit", 100);
    waveClear = arena.getSettings().getBoolean("clear-wave-before-next", false);
    bossClear = arena.getSettings().getBoolean("clear-boss-before-next", false);
    preBossClear = arena.getSettings().getBoolean("clear-wave-before-boss", false);
    wavesAsLevel = arena.getSettings().getBoolean("display-waves-as-level", false);
    }

    public void run() {
    // If the arena isn't running or if there are no players in it.
    if (!arena.isRunning() || arena.getPlayersInArena().isEmpty()) {
        return;
    }

    // Clear out all dead monsters in the monster set.
    removeDeadMonsters();
    removeCheatingPlayers();

    // In case some players were removed, check again.
    if (!arena.isRunning()) {
        return;
    }

    // Grab the wave number.
    int nextWave = waveManager.getWaveNumber() + 1;

    // Check if wave needs to be cleared first. If so, return!
    if (!isWaveClear()) {
        arena.scheduleTask(this, 60);
        return;
    }

    // Fire off the event. If cancelled, try again in 3 seconds.
    NewWaveEvent event = new NewWaveEvent(arena, waveManager.getNext(), nextWave);
    plugin.getServer().getPluginManager().callEvent(event);
    if (event.isCancelled()) {
        arena.scheduleTask(this, 60);
        return;
    }

    // Spawn the next wave.
    MobSpawningTasks.put(arena.getSettings().getName(), spawnWave(nextWave));

    // Update stats
    updateStats(nextWave);

    // Reschedule the spawner for the next wave.
    arena.scheduleTask(this, arena.getSettings().getInt("wave-interval", 3) * 20);
    }


    public Random rand = new Random();
    public Map<String, Integer> MobSpawningTasks = new HashMap<String, Integer>();

    private int spawnWave(final int wave) {
    final Wave w = waveManager.next();

    w.announce(arena, wave);

    arena.getScoreboard().updateWave(wave);

    //If the task is not cleared for any reason remove it before creating a new one,
    if (MobSpawningTasks.containsKey(arena.getSettings().getName())) {
    MobSpawningTasks.remove(arena.getSettings().getName());
    }



    int TaskID = Bukkit.getScheduler().scheduleSyncRepeatingTask(MobArena.plugin, new Runnable() {

        Map<MACreature, Integer> monsters = w.getMonstersToSpawn(wave, playerCount, arena);
        List<Location> spawnpoints = w.getSpawnpoints(arena);



        boolean SingleTimeCode = false;

        @Override public void run() {

        World world = arena.getWorld();
        for (Map.Entry<MACreature, Integer> entry : monsters.entrySet()) {
            int amount = entry.getValue();

            // Grab a spawnpoint
            Location spawnpoint = spawnpoints.get(1);

            // Spawn the monster
            LivingEntity e = entry.getKey().spawn(arena, world, spawnpoint);
                    Zombie z = (Zombie) e;
                    z.setBaby(false);
                    z.setVillager(false);
                    z.setCanPickupItems(false);
                    z.getEquipment().setBootsDropChance(0);
                    z.getEquipment().setLeggingsDropChance(0);
                    z.getEquipment().setChestplateDropChance(0);
                    z.getEquipment().setHelmetDropChance(0);
                    z.getEquipment().setItemInHandDropChance(0);
                    z.setRemoveWhenFarAway(false);


            // Add it to the arena.
            monsterManager.addMonster(e);

            // Set the health.
            e.resetMaxHealth();
            int health = 10 + wave*3 + arena.getPlayerCount();
            e.setMaxHealth(health + 1);
            e.setHealth(health);

            MACreature maCreature = entry.getKey();

            //Code will only run ONCE per wave...
            if (SingleTimeCode == false) {

            //Set zombie amount
            amount = BaseAmount(wave) + playerCount + rand.nextInt((9 - 1) + 1) + 1;
            SingleTimeCode = true;
            }

            //Lower the amount of mobs to spawn by one
            if (amount > 0) {
            monsters.clear();
            monsters.put(maCreature, amount - 1);
            }

            //If all mobs have spawned cancel the spawn task.
            if (amount <= 0) {
            Bukkit.getScheduler().cancelTask(MobSpawningTasks.get(arena.getSettings().getName()));
            MobSpawningTasks.remove(arena.getSettings().getName());
            }

        }

        }
    }, 0l, 20l);

    return TaskID;
    }