package me.illusion.customshields.shields.impl;

import de.tr7zw.nbtapi.NBTItem;
import me.illusion.customshields.CustomShieldsPlugin;
import me.illusion.customshields.shields.CustomShield;
import me.illusion.customshields.util.KnockbackUtil;
import me.illusion.utilities.item.ItemBuilder;
import me.illusion.utilities.schedulerutil.builders.ScheduleBuilder;
import org.bukkit.Material;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.util.Vector;

import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

public class ShieldShield implements CustomShield, Listener, Runnable {

    private static final double KNOCKBACK_MULTIPLIER = 2.3D;
    private static ItemStack ITEM =
            new ItemBuilder(Material.SHIELD)
                    .name("&fShield shield")
                    .lore("&7A shield that can be used to deflect damage",
                            "&7and &fpushes enemies &7very far.")
                    .model(2)
                    .build();

    private final CustomShieldsPlugin main;
    private final Map<UUID, Vector> flyingEntities = new HashMap<>();

    public ShieldShield(CustomShieldsPlugin main) {
        this.main = main;

        NBTItem nbt = new NBTItem(ITEM);
        nbt.setBoolean(getName(), true);
        ITEM = nbt.getItem();

        new ScheduleBuilder(main)
                .every(1).ticks()
                .run(this)
                .sync().start();
        main.getServer().getPluginManager().registerEvents(this, main);
    }

    @Override
    public String getName() {
        return "shield-shield";
    }

    @Override
    public Material getMaterial() {
        return Material.SHIELD;
    }

    @Override
    public ItemStack getItem() {
        return ITEM;
    }

    @EventHandler
    private void onDamage(EntityDamageByEntityEvent event) {
        Entity damager = event.getDamager();
        Entity target = event.getEntity();

        if (!(target instanceof Player player))
            return;

        if (!isBlocking(player))
            return;

        event.setDamage(0);
        Vector velocity = KnockbackUtil.getKnockback(damager.getLocation(), player).multiply(KNOCKBACK_MULTIPLIER);

        damager.setVelocity(velocity);
        flyingEntities.put(damager.getUniqueId(), velocity);

        new ScheduleBuilder(main)
                .in(10).seconds()
                .run(() -> {
                    synchronized (flyingEntities) {
                        flyingEntities.remove(damager.getUniqueId());
                    }
                }).sync().start();
    }

    @Override
    public void run() {
        for (Map.Entry<UUID, Vector> entry : flyingEntities.entrySet()) {
            Entity entity = main.getServer().getEntity(entry.getKey());
            if (entity == null)
                continue;

            entity.setVelocity(entry.getValue());
        }
    }
}