/*
 * CoalitionalDef2AttackStrategy.java
 *
 * Created on May 25, 2004, 11:19 PM
 */

package simulations.core.strategy.attackStrategy;

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

import simulations.core.Player;

import simulations.core.history.PlayerTurn;

/**
 * This class describes an attack strategy that attack players that are
 * not in my coalition (definition 2) from last turn
 * @author  tom
 */
public class CoalitionalDef2AttackStrategy extends AttackStrategy {
    
    /** The coalition **/
    private ArrayList coalition;
    
    /** Creates a new instance of CoalitionalDef2AttackStrategy */
    public CoalitionalDef2AttackStrategy() {
        super();
        name="CoalitionalDef2AttackStrategy";
        negative=false;
        coalition=new ArrayList();
        memoryParam=false;
        abr="11";
    }
    
    /** return the description of this attack strategy
     * @return return the description of this attack strategy
     **/
    public String getDescription() {
        return "Attack strategy : I attack players\n"+
        "that are not in my coalition (definition 2)\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) {
        if (simulations.SimulationParameters.debug) {
            System.out.println("CoalDef2AttackStrat : coalList = "+coalition.toString());
        }
        ArrayList l = new ArrayList();
        Iterator it = coalition.iterator();
        while (it.hasNext()) {
            ArrayList l2 = (ArrayList)it.next();
            Iterator it2 = l2.iterator();
            while (it2.hasNext()) {
                Player p = (Player)it2.next();
                if (!(l.contains(p))) {
                    if (!(p.equals(player))) {
                        l.add(p);
                    }
                }
            }
        }
        if (negative) {
            return l;
        } else {
            ArrayList l2 = new ArrayList();
            for(int i=0;i<playerList.size();i++) {
                Player p = (Player)playerList.get(i);
                if (!(l.contains(p))) {
                    if (!(p.equals(player))) {
                        l2.add(p);
                    }
                }
            }
            return l2;
        }
    }
    
    /** 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 now we just consider that a coalition is a set of player
        // that have never attack directly each other
        // Construct coalition list
        ArrayList l = new ArrayList();
        for(int i=0;i<remainingPlayers.size();i++) {
            Player p1 = (Player)remainingPlayers.get(i);
            ArrayList l2 = new ArrayList();
            l2.add((Player)p1.clone());
            //System.out.println("coal candidate avec "+p1.toString());
            for(int j=0;j<remainingPlayers.size();j++) {
                Player p2 = (Player)remainingPlayers.get(j);
                if (p2.equals(p1)) {
                    continue;
                }
                if (sameCoalition(p1,p2,turn.getPlayersTurnsList())) {
                    if (!(coalitionContains(l,l2))) {
                        //System.out.println("je peux m" +"mettre "+p2.toString()+" avec "+p1.toString());
                        l2.add((Player)p2.clone());
                    }
                }
            }
            if (simulations.SimulationParameters.debug) {
                System.out.println("candidat = "+l2.toString());
            }
            if (l2.contains(player)) {
                l.add(l2);
            }
        }
        for(int i=0;i<l.size();i++) {
            ArrayList l2 = (ArrayList)l.get(i);
            if (l2.size()<=1) {
                l.remove(i);
                i--;
            }
        }
        coalition.clear();
        // l is the list all candidate coalition
        for(int i=0;i<l.size();i++) {
            ArrayList l2 = (ArrayList)l.get(i);
            if (isCoalition(l2,turn.getPlayersTurnsList())) {
                if (!(coalitionContains(coalition,l2))) {
                    if (simulations.SimulationParameters.debug) {
                        System.out.println("ajout definitif = "+l2.toString());
                    }
                    coalition.add(l2);
                }
            }
        }
        if (simulations.SimulationParameters.debug) {
            System.out.println("Coalition list = "+coalition.toString());
        }
    }
    
    /** Returns true if p1 and p2 are in the samecoalition
     * @param p1 Player 1
     * @param p2 Player 2
     * @param l The players turn list
     **/
    private boolean sameCoalition(Player p1, Player p2, ArrayList l) {
        // get player turn of each player
        //System.out.println("sameCoalition : ");
        //System.out.println(p1.toString()+" "+p2.toString()+" "+l.toString());
        PlayerTurn pt1 = null;
        PlayerTurn pt2 = null;
        Iterator it = l.iterator();
        //System.out.println("DANS SAMECOALITION2");
        while (it.hasNext()) {
            PlayerTurn pt = (PlayerTurn)it.next();
            //System.out.println("PlayerTurn de "+pt.getPlayer());
            if (pt.getPlayer().equals(p1)) {
                pt1 = pt;
            } else if (pt.getPlayer().equals(p2)) {
                pt2 = pt;
            }
        }
        // if one attack the other
        //System.out.println("DANS SAMECOALITION2______________CASE1");
        if (pt1.getAttackedPlayer().equals(p2)) {
            return false;
        }
        if (pt2.getAttackedPlayer().equals(p1)) {
            return false;
        }
        // if one support an attack on the other
        it = l.iterator();
        while (it.hasNext()) {
            PlayerTurn pt = (PlayerTurn)it.next();
            // if the attacked is one of the two we compare we look if one
            // of them has supported an attack on the other
            if (pt.getAttackedPlayer().equals(p1)) {
                Iterator it2 = pt.getPlayersAcceptingSupport().iterator();
                while (it2.hasNext()) {
                    Player p = (Player)it2.next();
                    if (p.equals(p2)) {
                        return false;
                    }
                }
            } else if (pt.getAttackedPlayer().equals(p2)) {
                Iterator it2 = pt.getPlayersAcceptingSupport().iterator();
                while (it2.hasNext()) {
                    Player p = (Player)it2.next();
                    if (p.equals(p1)) {
                        return false;
                    }
                }
            }
        }
        return true;
    }
    
    /** Returns true if p is in the coalition coal
     * @param coal The coalition
     * @param p The player
     * @param l The players turns list
     **/
    private boolean sameCoalition(ArrayList coal, Player p, ArrayList l) {
        if (simulations.SimulationParameters.debug) {
            System.out.println("sameCoalition : ");
            System.out.println(coal.toString()+" "+p.toString()+" "+l.toString());
        }
        Iterator it = coal.iterator();
        while (it.hasNext()) {
            Player p2 = (Player)it.next();
            //System.out.println("Appel a SAMECOALITION2");
            if (!(sameCoalition(p2, p, l))) {
                if (simulations.SimulationParameters.debug) {
                    System.out.println("non");
                }
                return false;
            }
        }
        if (simulations.SimulationParameters.debug) {
            System.out.println("oui");
        }
        return true;
    }
    
    /** Returns true if the players list coal is a coalition
     * @param coal the players list to test
     * @param l The players turns list
     **/
    private boolean isCoalition(ArrayList coal, ArrayList l) {
        if (simulations.SimulationParameters.debug) {
            System.out.println(coal.toString()+" coal ?");
        }
        int i=0;
        for(int j=0;j<coal.size();j++) {
            Player p = (Player)coal.remove(i);
            if (!(sameCoalition(coal,p,l))) {
                coal.add(i,p);
                if (simulations.SimulationParameters.debug) {
                    System.out.println("Non");
                }
                return false;
            }
            coal.add(i,p);
            i++;
        }
        if (simulations.SimulationParameters.debug) {
            System.out.println("Oui");
        }
        return true;
    }
    
    /** Returns true if the coalition list list contains the coalition l
     * @param list The coalition list
     * @param l The coalition
     * @return true if the coalition list list contains the coalition l
     **/
    private boolean coalitionContains(ArrayList list, ArrayList l) {
        for(int i=0;i<list.size();i++) {
            ArrayList l2 = (ArrayList)list.get(i);
            if (l2.size()!=l.size()) {
                continue;
            }
            if (l2.containsAll(l)) {
                return true;
            }
        }
        return false;
    }
}