package drake.aepvp.l2event;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Consumer;

import drake.aepvp.authentication.Passport;
import drake.aepvp.drivers.PlayerDriver;
import drake.aepvp.instance.world.AbstractWorld;
import drake.aepvp.instance.world.StaticWorld;
import drake.aepvp.model.enums.PlayerAction;
import drake.aepvp.model.enums.PlayerRelation;
import drake.aepvp.model.enums.WorldTrigger;
import drake.aepvp.model.interfaces.IConditional;
import drake.aepvp.model.template.world.WorldTemplate;
import l2.ae.pvp.gameserver.model.L2Object;
import l2.ae.pvp.gameserver.model.actor.L2Character;
import l2.ae.pvp.gameserver.model.actor.L2Playable;
import l2.ae.pvp.gameserver.model.actor.instance.L2PcInstance;

public class EventWorld<E extends WorldTemplate> extends AbstractWorld<E>
{
    protected final ConcurrentHashMap<Passport, PlayerDriver> _playerDrivers = new ConcurrentHashMap<>();

    @Override
    public void worldInit()
    {
        super.worldInit();
    }

    public EventWorld(E template)
    {
        super(template);
    }

    public void forEachParticipant(final Consumer<L2PcInstance> consumer)
    {
        for (Map.Entry<Passport, PlayerDriver> playerData : _playerDrivers.entrySet())
        {
            final L2PcInstance player = playerData.getKey().getPlayer();
            if (playerData.getValue() != null && player.isOnline())
                consumer.accept(player);
        }
    }

    public void forEachParticipant(final Consumer<L2PcInstance> consumer, final IConditional<L2PcInstance> cond)
    {
        for (Map.Entry<Passport, PlayerDriver> playerData : _playerDrivers.entrySet())
        {
            final L2PcInstance player = playerData.getKey().getPlayer();
            if (playerData.getValue() != null && player.isOnline() && cond.isValid(player))
                consumer.accept(player);
        }
    }

    public void register(L2PcInstance player)
    {
        final int playersTotal = _playerDrivers.size();
        if (_template.getMaxPlayers() <= playersTotal)
            player.sendMessage(_template.getName() + " is already full!");
        else
        {
            final PlayerDriver playerDriver = new PlayerDriver(player);
            playerDriver.setRegistrationPosition(playersTotal + 1);
            if (playersTotal < 10)
                player.sendMessage("You are one of the first 10 registers! You may get a bonus...");
            _playerDrivers.put(player.getPassport(), new PlayerDriver(player));
        }
    }

    public void unregist(L2PcInstance player)
    {
        _playerDrivers.remove(player.getPassport());
    }

    public boolean isRegistered(L2PcInstance player)
    {
        return _playerDrivers.contains(player.getPassport());
    }

    protected PlayerDriver getPlayerDriver(final L2Object obj)
    {
        if (obj instanceof L2Playable)
            return _playerDrivers.get(obj.getPassport());
        return null;
    }

    protected PlayerDriver getPlayerDriver(final Passport passport)
    {
        return _playerDrivers.get(passport);
    }

    public PlayerDriver playerEject(L2PcInstance player)
    {
        player.setInstanceWorld(StaticWorld.REAL);
        player.teleToLocation(_template.getLeaveLoc(), 50);
        return _playerDrivers.remove(player.getPassport());
    }

    public PlayerDriver playerInject(L2PcInstance player)
    {
        final Passport playerPassport = player.getPassport();
        PlayerDriver playerDriver = getPlayerDriver(playerPassport);
        if (playerDriver == null)
            _playerDrivers.put(playerPassport, playerDriver = new PlayerDriver(player));
        return playerDriver;
    }

    public PlayerRelation getPlayerRelation(final L2Object obj0, final L2Object obj1)
    {
        return PlayerRelation.NONE;
    }

    public PlayerRelation getPlayerRelation(final PlayerDriver driver0, final PlayerDriver driver1)
    {
        return PlayerRelation.NONE;
    }

    /*
     *  public boolean handleDamage(final L2Character damager, final L2Character victim, final int damage)
    {
        final L2PcInstance damagerPlayer = damager.getActingPlayer();
        final L2PcInstance victimPlayer = victim.getActingPlayer();
        if (damagerPlayer == null || victimPlayer == null)
            return false;
        final PlayerRelation teamRelation = getPlayerRelation(damagerPlayer, victimPlayer);
        if (teamRelation == PlayerRelation.ENEMY)
        {   final PlayerDriver damagerDriver = getPlayerDriver(damagerPlayer), victimDriver = getPlayerDriver(victimPlayer);
            if (damagerDriver != null && victimDriver != null)
            {   damagerDriver.increaseDamageDealt(damage);
                victimDriver.increaseDamageTaken(damage);
            }
        }
        return false;
    }
     */

    @Override
    public boolean processAction(PlayerAction action, L2Character activeChar, L2Character targetChar, int value)
    {
        final PlayerDriver charDriver = getPlayerDriver(activeChar);
        final PlayerDriver targDriver = getPlayerDriver(targetChar);
        final PlayerRelation relation = getPlayerRelation(charDriver, targDriver);
        switch (action)
        {
            case DAMAGE_DEALT:
                if (relation.isAllied())
                    return false;
                charDriver.increaseDamageDealt(value);
                targDriver.increaseDamageTaken(value);
                return true;
            case HEALING_DONE:
                if (!relation.isAllied())
                    return false;
                charDriver.increaseHealingDone(value);
                return true;
            case REVIVES_MADE:
                if (!relation.isAllied())
                    return false;
                charDriver.increaseRevivesDone(value);
                return true;
        }
        return false;
    }

    @Override
    public boolean processTrigger(L2Character activeChar, WorldTrigger eventTrigger)
    {
        switch (eventTrigger)
        {
            case ANTIBOT:
            {

            }
            default:
                super.processTrigger(activeChar, eventTrigger);
        }
        return false;
    }
}