/*
 * AcceptPlayersDontAttackMe2.java
 *
 * Created on April 23, 2004, 2:09 AM
 */

package simulations.core.strategy.decisionSupportStrategy;


import simulations.core.Player;
import java.util.ArrayList;
import java.util.Iterator;
import simulations.core.history.Turn;
import simulations.core.history.PlayerTurn;
import simulations.core.strategy.PlayerIntElement;

/**
 * This class describes a decision support strategy that accept only
 * if the asking player never attacked me directly and indirectly
 * @author  tom
 */
public class AcceptPlayersDontAttackMeStrategy2 extends DecisionSupportStrategy {
    
    private ArrayList notAcceptList;
    
    private boolean first;
    
    /** Creates a new instance of AcceptPlayersDontAttackMe */
    public AcceptPlayersDontAttackMeStrategy2() {
        super();
        name="AcceptPlayersDontAttackMeStrategy2";
        notAcceptList = new ArrayList();
        memoryParam=true;
        abr="7";
    }
    
    /** return the description of this decision support strategy
     * @return return the description of this decision support strategy
     **/
    public String getDescription() {
        return "Decision support strategy :\n"+
        "I accept if asking player have never\n"+
        "attacked me directly and indirectly\n"+
        "memory="+memory+"\n";
    }
    
    /** This method returns true if the player p is already in notAskingList
     * @return true if the player p is already in notAskingList false otherwise
     **/
    private boolean containsPlayer(Player p) {
        for(int i=0;i<notAcceptList.size();i++) {
            if (((PlayerIntElement)notAcceptList.get(i)).getPlayer().equals(p)) {
                return true;
            }
        }
        return false;
    }
    
    /** This method put the nb of p at memory in the list
     * @param p The player to update
     **/
    private void updatePlayerMemory(Player p) {
        for(int i=0;i<notAcceptList.size();i++) {
            PlayerIntElement elt = (PlayerIntElement)notAcceptList.get(i);
            if (elt.getPlayer().equals(p)) {
                elt.setNb(memory);
                break;
            }
        }
    }
    
    /**
     * return true if the player will support the attack.
     * @return return true if the player will support the attack.
     * @param playerList The list of remaining players
     * @param player The owner of the strategy
     * @param attackingPlayer The attacking player
     * @param attackedPlayer The attacked player
     */    
    public boolean supportAttack(simulations.core.Player player, simulations.core.Player attackingPlayer, simulations.core.Player attackedPlayer, ArrayList playerList) {
        if (simulations.SimulationParameters.debug) {
            System.out.println("notAcceptList = "+notAcceptList.toString());
        }
        if (attackedPlayer.equals(player)) {
            return false;
        }
        if (containsPlayer(attackingPlayer)) {
            if (negative) {
                return true;
            } else {
                return false;
            }
        } else {
            if (negative) {
                return false;
            } else {
                return true;
            }
        }
    }
    
    /**
     * This method is called by the judge after the decision of players to attack and to ask supports
     * to inform the strategy
     * @param player The owner of the strategy
     * @param attacksList The list of attacks
     **/
    public void updateAttacksInfos(Player player, ArrayList attacksList) {
        
    }
    
    /** This method is called by the judge to inform players of the last turn
     * @param turn The turn
     * @param player The owner of the strategy
     * @param remainingPlayers The list of the remaining players
     */    
    public void updateLastTurn(simulations.core.history.Turn turn, simulations.core.Player player, java.util.ArrayList remainingPlayers) {
        for(int i=0;i<notAcceptList.size();i++) {
            PlayerIntElement elt = (PlayerIntElement)notAcceptList.get(i);
            elt.setNb(elt.getNb()-1);
        }
        Iterator it = turn.getPlayersTurnsList().iterator();
        while (it.hasNext()) {
            PlayerTurn pt = (PlayerTurn)it.next();
            if (pt.getAttackedPlayer().equals(player)) {
                // If he attack me I add him in my black list
                if (containsPlayer(pt.getPlayer())) {
                    updatePlayerMemory(pt.getPlayer());
                } else {
                    notAcceptList.add(new PlayerIntElement(pt.getPlayer(),memory));
                }
                Iterator it2 = pt.getPlayersAcceptingSupport().iterator();
                while (it2.hasNext()) {
                    Player p = (Player)it2.next();
                    if (containsPlayer(p)) {
                        updatePlayerMemory(p);
                    } else {
                        notAcceptList.add(new PlayerIntElement(p,memory));
                    }
                }
            }
        }
        for(int i=0;i<notAcceptList.size();i++) {
            PlayerIntElement elt = null;
            try {
                elt = (PlayerIntElement)notAcceptList.get(i);
            }catch(IndexOutOfBoundsException e) {
                continue;
            }
            // memory turns have passed so I forget
            if (elt.getNb()==0) {
                notAcceptList.remove(i);
                i--;
                continue;
            }
            if (!(remainingPlayers.contains(elt.getPlayer()))) {
                // This player no longer in remaining players list so I remove him
                notAcceptList.remove(i);
                i--;
                continue;
            }
        }
    }
    
}