package me.unurled.sacredrealms.sr.utils;

import static me.unurled.sacredrealms.sr.utils.Component.comp;
import static me.unurled.sacredrealms.sr.utils.Component.textComp;
import static me.unurled.sacredrealms.sr.utils.SRPlayerUtils.syncSRToPlayer;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;
import me.unurled.sacredrealms.sr.components.attributes.Attribute;
import me.unurled.sacredrealms.sr.components.item.Item;
import me.unurled.sacredrealms.sr.components.item.ItemManager;
import me.unurled.sacredrealms.sr.components.player.PlayerManager;
import me.unurled.sacredrealms.sr.components.player.SRPlayer;
import me.unurled.sacredrealms.sr.managers.Manager;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.EntityEquipment;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.persistence.PersistentDataContainer;
import org.bukkit.persistence.PersistentDataType;
import org.jetbrains.annotations.NotNull;

@SuppressWarnings("UnusedReturnValue")
public class Items {

  private Items() {}

  public static @NotNull ItemStack cancelItem() {
    ItemStack cancel = new ItemStack(Material.BARRIER);
    ItemMeta cancelMeta = cancel.getItemMeta();
    cancelMeta.displayName(textComp("<b><red>Cancel</red></b>"));
    cancel.setItemMeta(cancelMeta);
    return cancel;
  }

  public static @NotNull ItemStack glassPane() {
    ItemStack itemStack = new ItemStack(Material.GRAY_STAINED_GLASS_PANE);
    ItemMeta itemMeta = itemStack.getItemMeta();
    itemMeta.displayName(textComp(""));
    itemStack.setItemMeta(itemMeta);
    return itemStack;
  }

  public static @NotNull Double getTotalAttribute(@NotNull Player player, Attribute attribute) {
    return getTotalAttribute(player.getEquipment(), attribute);
  }

  public static @NotNull Double getTotalAttribute(EntityEquipment inv, Attribute attribute) {
    ItemManager im = Manager.getInstance(ItemManager.class);
    if (im == null) return 0.0;

    AtomicReference<Double> total = new AtomicReference<>(0.0);

    Arrays.stream(inv.getArmorContents())
        .toList()
        .forEach(item -> total.updateAndGet(v -> (v + getAttribute(item, attribute))));

    total.updateAndGet(v -> (v + getAttribute(inv.getItemInMainHand(), attribute)));
    total.updateAndGet(v -> (v + getAttribute(inv.getItemInOffHand(), attribute)));

    return total.get();
  }

  public static Double getAttribute(ItemStack item, Attribute attribute) {
    ItemManager im = Manager.getInstance(ItemManager.class);
    if (im == null) return 0.0;
    if (item == null) return 0.0;
    if (item.getType().equals(Material.AIR)) return 0.0;
    PersistentDataContainer p = item.getItemMeta().getPersistentDataContainer();
    if (p.has(ItemManager.ID, PersistentDataType.STRING)) {
      Item i = im.getItem(p.get(ItemManager.ID, PersistentDataType.STRING));
      if (i != null) {
        return i.getAttribute(attribute);
      }
    }
    if (p.has(attribute.getKey(), PersistentDataType.DOUBLE)) {
      try {
        return p.get(attribute.getKey(), PersistentDataType.DOUBLE);
      } catch (Exception e) {
        return 0.0;
      }
    }
    return 0.0;
  }

  /**
   * @param stack the itemstack
   * @return the itemstack with lore
   */
  public static ItemStack lore(ItemStack stack) {
    ItemManager im = Manager.getInstance(ItemManager.class);
    if (im == null) return stack;
    if (stack == null) return stack;
    if (stack.getType().equals(Material.AIR)) return stack;
    PersistentDataContainer p = stack.getItemMeta().getPersistentDataContainer();
    if (!p.has(ItemManager.ID, PersistentDataType.STRING)) return stack;
    Item item = im.getItem(p.get(ItemManager.ID, PersistentDataType.STRING));

    List<net.kyori.adventure.text.Component> lore = new ArrayList<>();

    lore.add(comp("<b>" + item.getRarity().getName()));
    lore.add(comp("<dark_gray>" + item.getDescription()));
    if (!item.getAttributes().isEmpty()) {
      lore.add(comp("<gray>Attributes:"));
      item.getAttributes()
          .forEach(
              (k, v) ->
                  lore.add(
                      comp(
                          "  <gray>➤ "
                              + k.getName()
                              + ": "
                              + (v < 0 ? "<red>" : "<green>")
                              + "+"
                              + v)));
    }
    if (!item.getAbilities().isEmpty()) {
      lore.add(comp("<gray>Abilities:"));
      item.getAbilities()
          .forEach(
              a -> {
                lore.add(comp("  <gray>➤ " + a.name() + ",<yellow> " + a.getDescription()));
                lore.add(comp("              <dark_gray>cooldown: " + a.getCooldown() + "s,"));
                lore.add(comp("              <dark_gray>damage: " + a.getDamage() + ","));
                lore.add(comp("              <dark_gray>mana cost: <dark_aqua>" + a.getManaCost()));
              });
    }
    if (!item.getEnchantments().isEmpty()) {
      lore.add(comp("<dark_purple>Enchantments:"));
      item.getEnchantments()
          .forEach(
              (k, v) -> lore.add(comp("  <blue>➤ " + k.name() + " <if " + "max level gold>" + v)));
    }

    stack.lore(lore);

    return stack;
  }

  public static void updatePlayer(@NotNull Player player, ItemStack oldItem, ItemStack newItem) {
    PlayerManager pm = Manager.getInstance(PlayerManager.class);
    if (pm == null) {
      return;
    }
    SRPlayer p = pm.getPlayer(player.getUniqueId());
    if (p == null) {
      return;
    }

    ItemManager im = Manager.getInstance(ItemManager.class);
    if (im == null) {
      return;
    }

    // remove status of old Item
    if (oldItem != null && !oldItem.getType().equals(Material.AIR)) {
      for (Attribute a : Attribute.values()) {
        p.removeItemAttributes(a, oldItem);
      }
    }

    // add status of new Item
    if (newItem != null && !newItem.getType().equals(Material.AIR)) {
      for (Attribute a : Attribute.values()) {
        p.setItemAttributes(a, newItem, getAttribute(newItem, a));
      }
    }

    syncSRToPlayer(p, player);
  }
}