import java.util.*;

public class Maquina extends Jugador{
    private FitxaMap map;
    private boolean color;
    private int lastTorn;

    //Conte un hashMap que guarda entrades amb: el moviment que es podria fer aquell torn + FitxaMap
    private class PositionMap {
        int numVictoriesPossibles;
        private HashMap<String,FitxaMap> map;

        public  PositionMap(){
            this.map=new HashMap<>();
            this.numVictoriesPossibles=0;
        }

        public int getNumVictoriesPossibles() {
            return this.numVictoriesPossibles;
        }

        public void setNumVictoriesPossibles(int numVictoriesPossibles) {
            this.numVictoriesPossibles = numVictoriesPossibles;
        }

        public HashMap<String,FitxaMap> getMap() {
            return this.map;
        }
        public void addHashMap(HashMap<String,FitxaMap> input){
            this.map = input;
        }

        public void addToHashMap(String s,FitxaMap input) {
            this.map.put(s,input);
            if(input!=null)this.numVictoriesPossibles+=input.getNumVictoriesPossibles();
        }

        public boolean mapIsEmpty() {
          return(this.map.size() == 0);
        }
    }

    //Conte un hashmap que guarda la fitxa que es podria moure aquell torn + PositionMap
    private class FitxaMap {
        private HashMap<String,PositionMap> map;
        private int numVictoriesPossibles;
        public FitxaMap() {
            this.map=new HashMap<>();
            this.numVictoriesPossibles=0;
        }

        public FitxaMap(int numVictoriesPossibles) {
            this.map = new HashMap<>();
            this.numVictoriesPossibles=numVictoriesPossibles;
        }

        public int getNumVictoriesPossibles() {
            return this.numVictoriesPossibles;
        }

        public HashMap<String,PositionMap> getMap() {
            return this.map;
        }

        public boolean mapIsEmpty() {
            return(this.map.size() == 0);
        }

        public void addToHashMap(String s,PositionMap input) {
            this.map.put(s,input);
            this.numVictoriesPossibles+=input.getNumVictoriesPossibles();
        }
    }


    public Maquina(String nom) {
        super(nom);
        this.map = new FitxaMap();
        this.lastTorn=0;
    }

    public String[] juga(Taulell taulell,boolean color){
        //Necessita que es passi com a parametre el torn de la partida i el numero maxim de torns per a la profunditat
        int torn=0;
        //si es fa servir per una nova partida(N partides en Maquina vs. Maquina) aixo vol dir que el torn no sera l'esperat
        if(this.lastTorn+2!=torn) {
            this.color = color;
            this.lastTorn=torn;
            int maxDepth = 2;
            ArrayList<Fitxa> fitxes = taulell.fitxesJugador(color);
            for (int i = 0; i < fitxes.size(); ++i) {
                Fitxa fitxa = fitxes.get(i);
                PositionMap ret = new PositionMap();
                if (possibleMovimentFitxa(fitxa, new Taulell(taulell), ret, this.lastTorn, maxDepth))
                    this.map.addToHashMap(fitxa.getPosicio(), ret);
            }
        }
        String[] moviment = highestChance();
        if(moviment.length == 2) return moviment;
        else return movimentRandom(taulell);
    }

    /**
     * Retorna el moviment amb mes possibilitats de guanyar si n'hi ha. Si no retorna null
     * @return Array que conte origen i desti de la fitxa que s'hauria de moure en aquell torn.
     */
    private String[] highestChance() {
        Iterator itFitxaMap = this.map.getMap().entrySet().iterator();
        Map.Entry maxFitxa=null;
        Map.Entry maxPos=null;
        int highestVictories = 0;
        //Fitxa a moure amb mes victories posibles
        while(itFitxaMap.hasNext()){
            Map.Entry pair = (Map.Entry)itFitxaMap.next();
            PositionMap auxPM = (PositionMap)pair.getValue();
            Iterator itPositionMap = auxPM.getMap().entrySet().iterator();
            while(itPositionMap.hasNext()) {
                Map.Entry pairIntern = (Map.Entry)itPositionMap.next();
                FitxaMap auxFM = (FitxaMap)pairIntern.getValue();
                if(highestVictories<auxFM.getNumVictoriesPossibles()) {
                    highestVictories = auxFM.getNumVictoriesPossibles();
                    maxFitxa = pair;
                    maxPos = pairIntern;
                }
            }
        }
        if(highestVictories!=0){
            String[] moviment = new String[2];
            moviment[0] = (String)maxFitxa.getKey();
            moviment[0] = (String)maxPos.getKey();
            this.map= (FitxaMap)maxPos.getValue();
            return moviment;
        }
        return new String[0];
    }


    /**
     * Retorna els moviments possibles que te la fitxa que la portin a la victoria de Maquina
     * @param f Fitxa que es consulta
     * @param taulell Taulell on esta la fitxa
     * @param map Objecte que conte un hashMap on s'han d'afegir els moviments que portin a la victoria
     * @param torn Profunditat de la cerca
     * @param maxDepth Maxima profunditat
     * @return Retorna true si s'ha trobat cap moviment que porti ala victoria
     */
    public boolean possibleMovimentFitxa(Fitxa f,Taulell taulell,PositionMap map,int torn, int maxDepth) {
        if(torn==maxDepth) {
            return false;
        }
        ArrayList<String> movimentsPossibles = taulell.movimentsPossibles(f.getPosicio());
        //hasmap has an entry for every possible movement
        for(int i=0; i<movimentsPossibles.size();++i) {
            Taulell aux = new Taulell(taulell);
            //if(torn==0)System.out.println(" to " + movimentsPossibles.get(i));
            aux.moviment(f.getPosicio(),movimentsPossibles.get(i));
            boolean endGame = estatJoc(aux,f.getColor());
            if(endGame) {
                if(this.color==f.getColor()) {
                    //System.out.println("A PATH! Depth: "+torn+" Fitxa: "+f.getClass()+" "+f.getPosicio()+" Movement: "+movimentsPossibles.get(i));
                    FitxaMap res = new FitxaMap(1);
                    map.addToHashMap(movimentsPossibles.get(i),res);
                    map.setNumVictoriesPossibles(1);
                    return true;
                }
                else return false;
            }
            //hasmap has an entry for every possible movement of the contesting player
            FitxaMap novesFitxes= new FitxaMap();
            ArrayList<Fitxa> fitxesContrincant = aux.fitxesJugador(!color);
            boolean pathFound=false;
            for(int j = 0;j < fitxesContrincant.size();++j) {
                Fitxa fitxaContrincant=fitxesContrincant.get(j);
                //for(int x=0;x<torn+1;++x) System.out.print("->");
                //System.out.print(fitxaContrincant.getClass() + ":"+fitxaContrincant.getPosicio());
                PositionMap ret=new PositionMap();
                if(possibleMovimentFitxa(fitxaContrincant,aux,ret,torn + 1,maxDepth)) {
                    pathFound=true;
                    //System.out.println(movimentsPossibles.get(i));
                    novesFitxes.addToHashMap(fitxaContrincant.getPosicio(),ret);
                }
            }
            if(pathFound) {
                map.addToHashMap(movimentsPossibles.get(i),novesFitxes);
            }
        }
        if(map.mapIsEmpty()) return false;
        else return true;

    }

    /**
     * Consulta si la partida s'hauria acabat en l'escenari del taulell passat com a parametre
     * @param taulell Taulell de l'escenari que s'esta explorant
     * @param colorTorn Color del jugador que tira en aquell torn
     * @return True si l'altre jugador no te un Rei o si el Rei esta en escac i mat
     */
    private boolean estatJoc(Taulell taulell,boolean colorTorn) {
        //taulell.printTaulell();
        ArrayList<Fitxa> Fitxes_jugador= taulell.fitxesJugador(!colorTorn);
        //System.out.println(Fitxes_jugador.size());
        for(int i=0; i<Fitxes_jugador.size() ;++i) {
            Fitxa f = Fitxes_jugador.get(i);
            //System.out.println("INSTANCE OF:" +f.getClass() +" "+f.getPosicio() + " " + taulell.getFitxa(f.getPosicio()));
            if(f instanceof  Rei) {
                return taulell.escacMat(f.getPosicio());
            }
        }
        return true;
    }

    /**
     * Retorna el primer moviment possible que pugui fer maquina amb una de les seves fitxes
     * @param taulell Taulell del torn actual
     * @return Retorna un array amb un moviment aleatori.
     */
    private String[] movimentRandom(Taulell taulell) {
        ArrayList<Fitxa> fitxes = taulell.fitxesJugador(this.color);
        for (int i=0;i<fitxes.size();++i) {
            if(taulell.movimentsPossibles(fitxes.get(i).getPosicio()).size()!=0) return new String[]{fitxes.get(i).getPosicio(),taulell.movimentsPossibles(fitxes.get(i).getPosicio()).get(0)};
        }
        return null;
    }
    /*
    public void printMap(){
        System.out.println();
        if(this.map != null) {
            HashMap<String,PositionMap> aux = this.map;
            boolean end = aux.isEmpty();
            int i =0;
            while (!end) {
                Iterator it = aux.entrySet().iterator();
                Map.Entry pair = (Map.Entry)it.next();
                if(i%2==1) System.out.println(" to "+pair.getKey());
                else System.out.print(pair.getKey());
                PositionMap positionMap = (PositionMap)pair.getValue();
                if(positionMap==null){
                    end=true;
                }
                else aux = positionMap.getMap();
                ++i;
            }
        }
    }
    */
}