package drake.aepvp.l2event;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.concurrent.atomic.AtomicInteger;

import drake.aepvp.drivers.PlayerDriver;
import drake.aepvp.model.EventReward;
import drake.aepvp.model.EventTeam;
import drake.aepvp.model.enums.EventResult;
import drake.aepvp.model.enums.PlayerRelation;
import drake.aepvp.model.enums.WorldState;
import drake.aepvp.model.template.event.TeamTemplate;
import drake.aepvp.model.template.world.EventTemplate;
import l2.ae.pvp.gameserver.model.L2Object;
import l2.ae.pvp.gameserver.model.Location;
import l2.ae.pvp.gameserver.model.actor.instance.L2PcInstance;

public abstract class TeamEvent extends AbstractEvent
{
    protected final EventTeam[] _teams;

    private final AtomicInteger addPosition = new AtomicInteger(0);

    @Override
    public boolean isInHealZone(final L2PcInstance player)
    {
        final EventTeam team = getTeam(player);
        if (team == null)
            return false;
        final Location teamSpawn = team.getSpawn();
        if (teamSpawn == null)
            return false;
        return player.isInsideRadius(teamSpawn.getX(), teamSpawn.getY(), 666, false);
    }

    public TeamEvent(EventTemplate eventTemplate)
    {
        super(eventTemplate);
        final TeamTemplate[] _teamTemplates = eventTemplate.getTeamTemplates();
        _teams = new EventTeam[_teamTemplates.length];
        for (int i = 0; i < _teams.length; i++)
            _teams[i] = new EventTeam(_teamTemplates[i]);
    }

    protected EventTeam getTeam(final L2Object object)
    {
        final PlayerDriver playerDriver = getPlayerDriver(object);
        if (playerDriver == null)
            return null;
        return playerDriver.getEventTeam();
    }

    @Override
    public EventTeam getNextTeam()
    {
        return _teams[addPosition.getAndIncrement() % _teams.length];
    }

    @Override
    public void processRewards()
    {
        System.out.println("Process Re");
        Arrays.sort(_teams, (t1, t2) -> t2.getScore() - t1.getScore());
        final EventTeam winner = _teams[0];
        final ArrayList<EventTeam> _winners = new ArrayList<>();
        final ArrayList<EventTeam> _loosers = new ArrayList<>();
        for (final EventTeam team : _teams)
            if (team.getScore() == winner.getScore())
                _winners.add(team);
            else
                _loosers.add(team);
        final boolean isTie = _winners.size() > 1;
        if (isTie)
        {   String str = "";
            for (int i = 0; i != _winners.size(); i++)
                if (i == _winners.size() - 1)
                    str += " and " + _winners.get(i).getName() + "!";
                else
                    str += (i == 0 ? "" : ", ") + _winners.get(i).getName();
            announceInside("The game resulted into a tie between " + str);
        }
        else
            announceInside(winner.getName() + " team won the Event, scoring the most " + _template.getEventGoal() + "!");
        for (final EventTeam winnerTeam : _winners)
        {   winnerTeam.setTeamResult(isTie ? EventResult.TIE : EventResult.WIN);
            announceInside(winnerTeam.getName() + " team scored  " + winnerTeam.getScore() + " " + _template.getEventGoal() + "!");
        }
        for (final EventTeam looserTeam : _loosers)
        {   looserTeam.setTeamResult(EventResult.LOSE);
            announceInside(looserTeam.getName() + " team scored  " + looserTeam.getScore() + " " + _template.getEventGoal() + "!");
        }
        forEachParticipant((player) ->
        {
            tryReward(player);
        });
    }

    private void tryReward(final L2PcInstance player)
    {
        final PlayerDriver playerDriver = getPlayerDriver(player);
        final EventResult teamResult = playerDriver.getTeamResult();
        if (teamResult == EventResult.WIN || teamResult == EventResult.TIE)
            player.victory();
        else
            player.cry();
        for (EventReward reward : _template.getEventRewards())
            reward.tryReward(teamResult, playerDriver);
        for (final EventReward reward : _template.getEventRewards())
            reward.tryReward(EventResult.ANY, getPlayerDriver(player));
    }

    @Override
    public boolean onReconnect(final L2PcInstance player)
    {
        if (!super.onReconnect(player))
            return false;
        return true;
    }

    @Override
    public boolean playerSpawn(L2PcInstance player)
    {
        if (_worldState == WorldState.INACTIVE)
            player.teleToLocation(_leaveLoc, 50);
        else
        {
            player.teleToLocation(getTeam(player).getSpawn(), 50);
            return super.playerSpawn(player);
        }
        return true;
    }

    @Override
    public boolean isInSpawnProtection(final L2PcInstance player)
    {   if (!super.isInSpawnProtection(player))
            return false;
        final Location loc = getTeam(player).getSpawn();
        return player.isInsideRadius(loc.getX(), loc.getY(), loc.getZ(), 400, false, false);
    }

    @Override
    public int getNameColor(L2PcInstance player, L2PcInstance viewer)
    {
        final EventTeam team = getTeam(player);
        if (team == null)
            return super.getNameColor(player, viewer);
        return team.getNameColor();
    }

    @Override
    public PlayerRelation getPlayerRelation(final L2Object obj0, final L2Object obj1)
    {
        if (obj0 == null || obj1 == null)
            return PlayerRelation.NONE;
        return getPlayerRelation(getPlayerDriver(obj0), getPlayerDriver(obj1));
    }

    @Override
    public PlayerRelation getPlayerRelation(final PlayerDriver driver0, final PlayerDriver driver1)
    {
        if (driver0 == null || driver1 == null)
            return PlayerRelation.NONE;
        final EventTeam team0 = driver0.getEventTeam();
        final EventTeam team1 = driver1.getEventTeam();
        if (team0 == null || team1 == null)
            return PlayerRelation.NONE;
        if (team0 != team1)
            return team0.isAlliedWith(team1) ? PlayerRelation.ALLY : PlayerRelation.ENEMY;
        return PlayerRelation.SAME;
    }
}