/*
 * AttackAttackedPlayersStrategy2.java
 *
 * Created on April 21, 2004, 2:33 AM
 */

package simulations.core.strategy.attackStrategy;

import simulations.core.Player;
import simulations.core.Attack;
import simulations.core.history.PlayerTurn;
import simulations.core.strategy.PlayerIntElement;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * This class describes a strategy that attack only the players that I have already attacked
 * or that I support an attack versus them
 * @author  tom
 */
public class AttackAttackedPlayersStrategy2 extends AttackStrategy {
    
    /** This list store the player that I have already attack me and are
     * still in the game **/
    private ArrayList attackList;
    
    /** Creates a new instance of AttackAttackedPlayersStrategy */
    public AttackAttackedPlayersStrategy2() {
        super();
        attackList = new ArrayList();
        name="AttackAttackedPlayersStrategy2";
        memoryParam=true;
        abr="2";
    }
    
    /** return the description of this attack strategy
     * @return return the description of this attack strategy
     **/
    public String getDescription() {
        if (negative) {
            return "Attack strategy \n"+
            "I attack the player that I have already attacked\n"+
            "directly or indirectly memory="+memory+"\n"+
            "COMPLEMENTARY";
        } else {
            return "Attack strategy \n"+
            "I attack the player that I have already attacked\n"+
            "directly or indirectly 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<attackList.size();i++) {
            if (((PlayerIntElement)attackList.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<attackList.size();i++) {
            PlayerIntElement elt = (PlayerIntElement)attackList.get(i);
            if (elt.getPlayer().equals(p)) {
                elt.setNb(memory);
                break;
            }
        }
    }
    
    /** return the player to attack
     * @param player The attacking player
     * @param playerList The list of <B>avalaible</B> player
     * @return The player to attack
     */    
    public ArrayList getPlayerToAttack(Player player, ArrayList playerList) {
        ArrayList l = new ArrayList();
        Iterator it = attackList.iterator();
        while (it.hasNext()) {
            l.add(((PlayerIntElement)it.next()).getPlayer());
        }
        if (negative) {
            ArrayList l2 = new ArrayList();
            it = playerList.iterator();
            while (it.hasNext()) {
                Player p = (Player)it.next();
                if (p.equals(player)) {
                    continue;
                }
                if (!(l.contains(p))) {
                    l2.add(p);
                }
            }
            return l2;
        } else {
            return l;
        }
    }
    
    /** 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, Player player, ArrayList remainingPlayers) {
        for(int i=0;i<attackList.size();i++) {
            PlayerIntElement elt = (PlayerIntElement)attackList.get(i);
            elt.setNb(elt.getNb()-1);
        }
        Iterator it = turn.getPlayersTurnsList().iterator();
        while (it.hasNext()) {
            PlayerTurn pt = (PlayerTurn)it.next();
            if (pt.getPlayer().equals(player)) {
                if (containsPlayer(pt.getPlayer())) {
                    updatePlayerMemory(pt.getAttackedPlayer());
                } else {
                    attackList.add(new PlayerIntElement(pt.getAttackedPlayer(),memory));
                }
            } else {
                Iterator it2 = pt.getPlayersAcceptingSupport().iterator();
                while (it2.hasNext()) {
                    Player p = (Player)it2.next();
                    if (p.equals(player)) {
                        if (containsPlayer(pt.getPlayer())) {
                            updatePlayerMemory(pt.getAttackedPlayer());
                        } else {
                            attackList.add(new PlayerIntElement(pt.getAttackedPlayer(),memory));
                        }
                    }
                }
            }
        }
        for(int i=0;i<attackList.size();i++) {
            PlayerIntElement elt = null;
            try {
                elt = (PlayerIntElement)attackList.get(i);
            }catch(IndexOutOfBoundsException e) {
                continue;
            }
            // memory turns have passed so I forget
            if (elt.getNb()==0) {
                attackList.remove(i);
                i--;
                continue;
            }
            if (!(remainingPlayers.contains(elt.getPlayer()))) {
                // This player no longer in remaining players list so I remove him
                if (simulations.SimulationParameters.debug) {
                    System.out.println("remove "+elt.getPlayer().toString());
                }
                attackList.remove(i);
                i--;
                continue;
            }
        }
        while (it.hasNext()) {
            PlayerTurn pt = (PlayerTurn)it.next();
            if (pt.getPlayer().equals(player)) {
                if (!(attackList.contains(pt.getAttackedPlayer()))) {
                    attackList.add(pt.getAttackedPlayer());
                }
            }
            Iterator it2 = pt.getPlayersAcceptingSupport().iterator();
            while (it2.hasNext()) {
                Player p = (Player)it2.next();
                if (p.equals(player)) {
                    if (!(attackList.contains(pt.getPlayer()))) {
                        attackList.add(pt.getPlayer());
                    }
                }
            }
        }
    }
    
}