/*
 * CoalitionalDef5DecisionStrategy.java
 *
 * Created on May 26, 2004, 1:24 AM
 */

package simulations.core.strategy.decisionSupportStrategy;

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

import simulations.core.Player;

import simulations.core.history.PlayerTurn;

/**
 * This class describes a decison support strategy that ack players that accept
 * attack from players in my coalition vs players that are not in my coalition 
 * (definition 5) from last turn
 * @author  tom
 */
public class CoalitionalDef5DecisionStrategy extends DecisionSupportStrategy {
    
    /** The coalition **/
    private ArrayList lastTurnCoalition;
    
    /** Creates a new instance of CoalitionalDef5DecisionStrategy */
    public CoalitionalDef5DecisionStrategy() {
        super();
        name="CoalitionalDef5DecisionStrategy";
        negative=false;
        lastTurnCoalition=new ArrayList();
        memoryParam=false;
        abr="14";
    }
    
    /** return the description of this decision support strategy
     * @return return the description of this decision support strategy
     **/
    public String getDescription() {
        return "Asking strategy : I accept to help players\n"+
        "that are in my coalition and attack a player that is\n"+
        "not in my coalition (definition 5)\n";
    }
    
    /**
     * 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(Player player, Player attackingPlayer, Player attackedPlayer, ArrayList playerList) {
        if (simulations.SimulationParameters.debug) {
            System.out.println("CoalDef5DecisionStrat : coalList = "+lastTurnCoalition.toString());
            System.out.println("player = "+player.toString());
            System.out.println("attackingPlayer = "+attackingPlayer.toString());
            System.out.println("attackedPlayer = "+attackedPlayer.toString());
        }
        if (player.equals(attackedPlayer)) {
            return false;
        }
        ArrayList l = new ArrayList();
        Iterator it = lastTurnCoalition.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 (!(l.contains(attackingPlayer))) {
            if (simulations.SimulationParameters.debug) {
                System.out.println("false car j attaquant pas ds ma coal");
            }
            if (negative) {
                return true;
            } else {
                return false;
            }
        }
        if (l.contains(attackedPlayer)) {
            if (simulations.SimulationParameters.debug) {
                System.out.println("false car j attaque ds ma coal");
            }
            if (negative) {
                return true;
            } else {
                return false;
            }
        }
        if (simulations.SimulationParameters.debug) {
            System.out.println("true");
        }
        if (negative) {
            return true;
        } 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, Player player, ArrayList remainingPlayers) {
        // 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--;
            }
        }
        lastTurnCoalition.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(lastTurnCoalition,l2))) {
                    if (simulations.SimulationParameters.debug) {
                        System.out.println("ajout definitif = "+l2.toString());
                    }
                    lastTurnCoalition.add(l2);
                }
            }
        }
        if (simulations.SimulationParameters.debug) {
            System.out.println("Coalition list = "+lastTurnCoalition.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;
            }
        }
        // 2 + Attack same player
        //System.out.println("DANS SAMECOALITION2______________CASE2");
        if (pt1.getAttackedPlayer().equals(p2)) {
            return false;
        }
        if (pt2.getAttackedPlayer().equals(p1)) {
            return false;
        }
        if (!(pt1.getAttackedPlayer().equals(pt2.getAttackedPlayer()))) {
            return false;
        }
        // if they help each others
        if (!(pt1.getPlayersAcceptingSupport().contains(p2))) {
            return false;
        }
        if (!(pt2.getPlayersAcceptingSupport().contains(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;
    }
    
}