/*
 * AttackTheMostAttackedPlayerStrategy.java
 *
 * Created on April 24, 2004, 2:58 AM
 */

package simulations.core.strategy.attackStrategy;

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

import simulations.core.strategy.PlayerIntElement;
import simulations.core.strategy.PlayerObjectElement;
import simulations.core.strategy.ObjectIntElement;
import simulations.core.Player;

import simulations.core.history.PlayerTurn;

/**
 * This class describes an attack strategy that attack the player
 * the most attacked in the game
 * @author  tom
 */
public class AttackTheMostAttackedPlayerStrategy extends AttackStrategy {
    
    /** This list store the players an the number of time
     * they have been attacked **/
    private ArrayList playersStatList;
    
    /** Creates a new instance of AttackTheMostAttackedPlayerStrategy */
    public AttackTheMostAttackedPlayerStrategy() {
        super();
        name="AttackTheMostAttackedPlayerStrategy";
        playersStatList=new ArrayList();
        memoryParam=true;
        abr="6";
    }
    
    /** 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 have been\n"+
            "the most attacked memory="+memory+"\n"+
            "COMPLEMENTARY";
        } else {
            return "Attack strategy \n"+
            "I attack the player that have been\n"+
            "the most attacked memory="+memory+"\n";
        }
    }
    
    /** 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 java.util.ArrayList getPlayerToAttack(simulations.core.Player player, java.util.ArrayList playerList) {
        Iterator it = playersStatList.iterator();
        // This list will store
        if (simulations.SimulationParameters.debug) {
            System.out.println("PlayersStatList : ");
        }
        ArrayList l = new ArrayList();
        int max=-1;
        while (it.hasNext()) {
            ObjectIntElement obj = (ObjectIntElement)it.next();
            PlayerIntElement elt = (PlayerIntElement)obj.getObject();
            if (simulations.SimulationParameters.debug) {
                System.out.println(elt.getPlayer()+" "+elt.getNb()+" "+obj.getNb());
            }
            if (elt.getPlayer().equals(player)) {
                continue;
            }
            if (elt.getNb()==max) {
                l.add(elt.getPlayer());
            } else if (elt.getNb()>max) {
                max=elt.getNb();
                l.clear();
                l.add(elt.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 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<playersStatList.size();i++) {
            ObjectIntElement elt = (ObjectIntElement)playersStatList.get(i);
            if (((PlayerIntElement)elt.getObject()).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<playersStatList.size();i++) {
            ObjectIntElement elt = (ObjectIntElement)playersStatList.get(i);
            PlayerIntElement elt2 = (PlayerIntElement)elt.getObject();
            if (elt2.getPlayer().equals(p)) {
                elt.setNb(memory);
                break;
            }
        }
    }
    
    /** 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) {
        // remove dead players
        for(int i=0;i<playersStatList.size();i++) {
            ObjectIntElement elt = (ObjectIntElement)playersStatList.get(i);
            elt.setNb(elt.getNb()-1);
        }
        Iterator it = turn.getPlayersTurnsList().iterator();
        while (it.hasNext()) {
            PlayerTurn pt = (PlayerTurn)it.next();
            if (containsPlayer(pt.getAttackedPlayer())) {
                updatePlayerMemory(pt.getAttackedPlayer());
                increment(pt.getAttackedPlayer());
            } else {
                playersStatList.add(new ObjectIntElement(new PlayerIntElement(pt.getAttackedPlayer(),1),memory));
            }
        }
        for(int i=0;i<playersStatList.size();i++) {
            ObjectIntElement elt = null;
            try {
                elt = (ObjectIntElement)playersStatList.get(i);
            }catch(IndexOutOfBoundsException e) {
                continue;
            }
            // memory turns have passed so I forget
            if (elt.getNb()==0) {
                playersStatList.remove(i);
                i--;
                continue;
            }
            PlayerIntElement elt2 = (PlayerIntElement)elt.getObject();
            if (!(remainingPlayers.contains(elt2.getPlayer()))) {
                // This player no longer in remaining players list so I remove him
                if (simulations.SimulationParameters.debug) {
                    System.out.println("remove "+elt2.getPlayer().toString());
                }
                playersStatList.remove(i);
                i--;
                continue;
            }
        }
    }
    
    private void increment(Player p) {
        Iterator it = playersStatList.iterator();
        while (it.hasNext()) {
            ObjectIntElement elt = (ObjectIntElement)it.next();
            PlayerIntElement elt2 = (PlayerIntElement)elt.getObject();
            if (elt2.getPlayer().equals(p)) {
                elt2.setNb(elt2.getNb()+1);
                break;
            }
        }
    }
    
}