package com.wondertrademod.wondertrade;

import com.google.common.collect.ImmutableList;
import com.pixelmonmod.pixelmon.RandomHelper;
import com.pixelmonmod.pixelmon.config.PixelmonConfig;
import com.pixelmonmod.pixelmon.config.PixelmonEntityList;
import com.pixelmonmod.pixelmon.entities.pixelmon.EntityPixelmon;
import com.pixelmonmod.pixelmon.entities.pixelmon.stats.Level;
import com.pixelmonmod.pixelmon.enums.EnumPokemon;
import com.wondertrademod.wondertrade.config.WondertradeConfig;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Timer;
import java.util.UUID;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.server.MinecraftServer;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.fml.common.eventhandler.EventBus;
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
import net.minecraftforge.fml.common.gameevent.TickEvent.WorldTickEvent;

public class WondertradeManager
{
  public ArrayList<EntityPixelmon> pokemonPool = new ArrayList();
  public HashMap<UUID, Long> cooldowns = new HashMap();
  public static WondertradeManager instance;
  private HashMap<UUID, Integer> defaultCooldowns = new HashMap();

  public WondertradeManager()
  {
    instance = this;
  }

  public void initializePool()
  {
    Wondertrade.world = Utilities.getServer().func_71218_a(0);
    this.pokemonPool = generateRandomPool(Integer.valueOf(WondertradeConfig.poolSize));
  }

  @SubscribeEvent
  public void onWorldTick(TickEvent.WorldTickEvent event)
  {
    instance.initializePool();
    if ((!WondertradeConfig.announcement.equals("")) && (WondertradeConfig.announcementInterval > 0)) {
      new Timer().scheduleAtFixedRate(new Announcer(), 10000L, 60000L);
    }
    MinecraftForge.EVENT_BUS.unregister(this);
  }

  public void checkPoolSize()
  {
    if (this.pokemonPool.size() < WondertradeConfig.poolSize)
    {
      ArrayList<EntityPixelmon> supplementPool = generateRandomPool(Integer.valueOf(WondertradeConfig.poolSize - this.pokemonPool.size()));
      for (EntityPixelmon p : supplementPool) {
        this.pokemonPool.add(p);
      }
    }
    else if (this.pokemonPool.size() > WondertradeConfig.poolSize)
    {
      for (int i = 0; i < this.pokemonPool.size() - WondertradeConfig.poolSize; i++) {
        this.pokemonPool.remove(0);
      }
    }
  }

  public void doPoolAnnouncement()
  {
    int numLegendaries = 0;
    int numShinies = 0;

    checkPoolSize();
    for (EntityPixelmon p : this.pokemonPool)
    {
      if (EnumPokemon.legendaries.contains(p.func_70005_c_())) {
        numLegendaries++;
      }
      if (p.getIsShiny()) {
        numShinies++;
      }
    }
    String[] splits = WondertradeConfig.announcement.split("::");
    for (int i = 0; i < splits.length; i++) {
      if (!splits[i].equals("")) {
        Utilities.sendServerWideMessage(splits[i]);
      }
    }
    Utilities.sendServerWideMessage(WondertradeConfig.currentPool.replaceAll("POOLSIZE", this.pokemonPool.size() + ""));
    if (numLegendaries > 0)
    {
      String msg = WondertradeConfig.howManyLegendaries.replaceAll("LEGENDARYCOUNT", numLegendaries + "");
      if (numLegendaries == 1) {
        msg = msg.replaceAll("ISARE", "is");
      } else {
        msg = msg.replaceAll("ISARE", "are");
      }
      Utilities.sendServerWideMessage(msg);
    }
    if (PixelmonConfig.shinyRate != 1.0F)
    {
      String msg = WondertradeConfig.howManyShinies.replaceAll("SHINYCOUNT", numShinies + "");
      if (numShinies > 0)
      {
        if (numShinies == 1) {
          msg = msg.replaceAll("ISARE", "is");
        } else {
          msg = msg.replaceAll("ISARE", "are");
        }
        Utilities.sendServerWideMessage(msg);
      }
    }
    Utilities.sendServerWideMessage(WondertradeConfig.tryYourLuck);
  }

  public ArrayList<EntityPixelmon> generateRandomPool(Integer intSize)
  {
    ArrayList<EntityPixelmon> pool = new ArrayList();
    for (int i = 0; i < intSize.intValue(); i++)
    {
      EntityPixelmon p = getRandomEntityPixelmon();
      if (p != null) {
        pool.add(p);
      }
    }
    return pool;
  }

  public EntityPixelmon getRandomEntityPixelmon()
  {
    EntityPixelmon pokemon;
    if ((WondertradeConfig.legendaryRate < 1) || (RandomHelper.getRandomNumberBetween(1, WondertradeConfig.legendaryRate) != 1))
    {
      EntityPixelmon pokemon;
      do
      {
        pokemon = (EntityPixelmon)PixelmonEntityList.createEntityByName(EnumPokemon.randomPoke().name, Wondertrade.world);
      } while (EnumPokemon.legendaries.contains(pokemon.func_70005_c_()));
    }
    else
    {
      String legendary;
      do
      {
        legendary = (String)EnumPokemon.legendaries.get(RandomHelper.getRandomNumberBetween(0, EnumPokemon.legendaries.size() - 1));
      } while (!EnumPokemon.getNameList().contains(legendary));
      pokemon = (EntityPixelmon)PixelmonEntityList.createEntityByName(legendary, Wondertrade.world);
    }
    pokemon.getLvl().setLevel(RandomHelper.getRandomNumberBetween(WondertradeConfig.minLevel, WondertradeConfig.maxLevel));
    if ((RandomHelper.getRandomNumberBetween(1, (int)PixelmonConfig.shinyRate) > 1) || (PixelmonConfig.shinyRate == 0.0F)) {
      pokemon.setIsShiny(false);
    } else {
      pokemon.setIsShiny(true);
    }
    return pokemon;
  }

  public EntityPixelmon exchangePokemon(String username, EntityPixelmon entityPixelmonFromPlayer)
  {
    int rand = RandomHelper.getRandomNumberBetween(0, this.pokemonPool.size() - 1);
    EntityPixelmon entityPixelmonFromPool = (EntityPixelmon)this.pokemonPool.get(rand);
    this.pokemonPool.remove(rand);
    this.pokemonPool.add(entityPixelmonFromPlayer);
    checkAddAnnouncement(username, entityPixelmonFromPlayer);
    checkReceiveAnnouncement(username, entityPixelmonFromPool);

    return entityPixelmonFromPool;
  }

  public void checkAddAnnouncement(String username, EntityPixelmon entityPixelmonFromPlayer)
  {
    try
    {
      if (EnumPokemon.legendaries.contains(entityPixelmonFromPlayer.func_70005_c_()))
      {
        Utilities.sendServerWideMessage(WondertradeConfig.legendaryAdded.replaceAll("PLAYERNAME", username).replaceAll("POKEMONNAME", entityPixelmonFromPlayer.func_70005_c_()));
        Utilities.sendServerWideMessage(WondertradeConfig.tryYourLuck);
      }
      if ((entityPixelmonFromPlayer.getIsShiny()) && (PixelmonConfig.shinyRate != 1.0F))
      {
        Utilities.sendServerWideMessage(WondertradeConfig.shinyAdded.replaceAll("PLAYERNAME", username).replaceAll("POKEMONNAME", entityPixelmonFromPlayer.func_70005_c_()));
        Utilities.sendServerWideMessage(WondertradeConfig.tryYourLuck);
      }
    }
    catch (Exception e)
    {
      e.printStackTrace();
    }
  }

  public void checkReceiveAnnouncement(String username, EntityPixelmon entityPixelmonToPlayer)
  {
    try
    {
      if (EnumPokemon.legendaries.contains(entityPixelmonToPlayer.func_70005_c_()))
      {
        Utilities.sendServerWideMessage(WondertradeConfig.legendaryReceived.replaceAll("PLAYERNAME", username).replaceAll("POKEMONNAME", entityPixelmonToPlayer.func_70005_c_()));
        Utilities.sendServerWideMessage(WondertradeConfig.tryYourLuck);
      }
      if ((entityPixelmonToPlayer.getIsShiny()) && (PixelmonConfig.shinyRate != 1.0F))
      {
        Utilities.sendServerWideMessage(WondertradeConfig.shinyReceived.replaceAll("PLAYERNAME", username).replaceAll("POKEMONNAME", entityPixelmonToPlayer.func_70005_c_()));
        Utilities.sendServerWideMessage(WondertradeConfig.tryYourLuck);
      }
    }
    catch (Exception e)
    {
      e.printStackTrace();
    }
  }

  public void addCooldown(EntityPlayerMP player, Long time)
  {
    this.cooldowns.put(player.func_110124_au(), time);
  }

  public int getDefaultCooldown(EntityPlayerMP player)
  {
    if (this.defaultCooldowns.containsKey(player.func_110124_au())) {
      return ((Integer)this.defaultCooldowns.get(player.func_110124_au())).intValue();
    }
    return -1;
  }

  public void setDefaultCooldown(UUID uuid, int cooldown)
  {
    this.defaultCooldowns.put(uuid, Integer.valueOf(cooldown));
  }

  public void saveDefaultCooldowns()
  {
    Utilities.saveCooldowns(this.defaultCooldowns);
  }
}