import java.util.ArrayList; 

// <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
import java.util.Iterator;
// #[regen=yes,id=DCE.10E066DE-012A-25DC-3A9F-0C55197BB506]
import java.util.Random;
// </editor-fold> 
public class Partida {

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.291F6FB3-F705-DF82-8D00-502E3DD0EBE6]
    // </editor-fold> 
    private ArrayList<Jugador> mJugador;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.839314DD-F39A-7312-62BE-556C3367D2F4]
    // </editor-fold> 
    private Tablero mTablero;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.D4F79F6A-5E7C-D212-8B8F-F9DC2186DDBB]
    // </editor-fold> 
    private Turno mTurno;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.6BFC800C-3DDA-C12A-4D8A-0775215238DB]
    // </editor-fold> 
    public Partida () 
    {
        /*Aunque no hace falta, definimos un tamaño maximo de capacidad*/
        mJugador = new ArrayList<Jugador>(6);         
        
        /*Creamos los jugadores*/
        Jugador j1 = new Jugador("Jugador 1"); mJugador.add(j1);       
        Jugador j2 = new Jugador("Jugador 2"); mJugador.add(j2);        
        Jugador j3 = new Jugador("Jugador 3"); mJugador.add(j3);
        
        /*En funcion del numero de jugadores asignamos ejercitos para que se puedan ubicar*/
        j1.setNumEjercitosParaUbicar(20);
        j2.setNumEjercitosParaUbicar(20);
        j3.setNumEjercitosParaUbicar(20);
        
        //setJugador(mJugador); 
        
        /*Inicializacion del mapa*/
        inicializarMapa();              
    }
    
    public void inicializarMapa()
    {
        Tablero tablero;
        try
        {
            tablero = new Tablero();
                        
            /*Repartimos los Territorios entre los jugadores*/
            Iterator<Territorio> itTerritorios = tablero.getTerritorio().iterator();        
            Territorio tPivote = new Territorio();
             
            
            /*********************CODIGO PROVISIONAL*******************/
            Random nAleatorio = new Random();
            int valorAleatorio;    
            
            /*Creamos un array tipo int de identificadores de territorio*/
            
            ArrayList idTerritorio= new ArrayList(); 
            
            for (int i=0; i<tablero.getTerritorio().size(); i++) /*inicializamos el array con los id*/
                idTerritorio.add (itTerritorios.next().getId());
          
           int territoriosARepartir = tablero.getTerritorio().size() /  mJugador.size();
           
            for (int j=0; j<mJugador.size(); j++)
            {
                for (int i=0; i<territoriosARepartir; i++)
                {            
                                   
                    valorAleatorio = nAleatorio.nextInt(idTerritorio.size())+1; //coge la posición de un id aleatoriamente                
                    Object id = idTerritorio.get(valorAleatorio-1);
                    
                    idTerritorio.remove(valorAleatorio-1);
                    tPivote = buscarTerritorioPorId(tablero.getTerritorio(), id); //Tenemos el territorio a asignar al jugador
                    
                    tPivote.setJugador(mJugador.get(j));
                    
                    mJugador.get(j).setTerritorio(tPivote);
                    System.out.println("  Territorio: " + tPivote.getNombre() + " de " + tPivote.getJugador().getNombre());            
                }
            }
           /*Si sobran territorios se les asignará aleatoriamente a los jugadores*/
          Iterator itId = idTerritorio.iterator(); //iterador para movernos por el arrayList de id que queadan por asignar
          
          while(itId.hasNext())
          {                                                         
              Object id = itId.next();              
               
              valorAleatorio = nAleatorio.nextInt(mJugador.size())+1; //generamosun numero aleatorio para coger un jugador
              tPivote = buscarTerritorioPorId(tablero.getTerritorio(), id); //devuelve el territorio que coincide con el id pasado
              tPivote.setJugador(mJugador.get(valorAleatorio-1));
              mJugador.get(valorAleatorio-1).setTerritorio(tPivote);
              System.out.println("  Territorio: " + tPivote.getNombre() + " de " + tPivote.getJugador().getNombre());                                                         
          }
           
           
           
            /*********************FIN CODIGO PROVISIONAL***************/
        }         
        catch(Exception error)
        {
            System.out.println(error.getMessage());
        }                
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.5ADB86F9-744D-7AB7-999C-C74E02720B9A]
    // </editor-fold> 
    public ArrayList<Jugador> getJugador () {
        return mJugador;
    }
    
    public void setJugador (ArrayList<Jugador> val) 
    {
        this.mJugador = val;
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.10D517E4-59B8-1C2D-C444-AB97566D6DB1]
    // </editor-fold> 
    public Tablero getTablero () {
        return mTablero;
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.F3EDD95A-A934-B013-AEE6-89772EBD8E53]
    // </editor-fold> 
    public void setTablero (Tablero val) {
        this.mTablero = val;
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.D310CE34-E98D-3DB6-206F-51F9AFC63F8E]
    // </editor-fold> 
    public Turno getTurno () {
        return mTurno;
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.C4B6F8A8-A7AD-6595-E9D1-FDF6ACC6D21F]
    // </editor-fold> 
    public void setTurno (Turno val) {
        this.mTurno = val;
    }
    
    public void jugar ()
    {        
        /*Jugador pivote de la aplicacion*/
        Jugador jActivo = new Jugador();                                                                                                       
        /*Con la lista llena de jugadores, inicializamos el iterador, ya que antes daria fallo*/
        Iterator <Jugador> it = mJugador.iterator();                                        
            
        
        jActivo = it.next();
        while (!jActivo.getObjetivoCumplido())
        {                 
            System.out.println("El jugador " + jActivo.getNombre() + " tiene el turno");
            jActivo.mover();            
            
            /*Si el jugador se ha dado por vencido, lo eliminamos del array*/
            if (jActivo.getAbandonaPartida())                            
                it.remove();                
            
            /*Al quedar solo un jugador, lo consideramos como ganador*/
            if (mJugador.size() == 1)                
                break;             
                        
            /*Por ultimo cambiar el turno*/            
            if (!it.hasNext())
                it = mJugador.iterator();   /*Pone el iterador de nuevo al principio*/               
            jActivo = it.next();
        }
        
        System.out.println("\n!!!El jugador " + mJugador.get(0).getNombre() + " ha GANADO la partida!!!\n");
    }
    
    /*Metodo que devuelve un territorio de un arraList pasado por parametro en 
    funcion del identificador de territorio que pasamos por parametro tambien*/
    public Territorio buscarTerritorioPorId(ArrayList<Territorio> arrayTerritorios, Object id) 
    {
        /*Recorremos el array buscando un territorio cuyo "identificador" sea el indicado*/
        for (int i = 0; i < arrayTerritorios.size(); i++) 
        {
            if (arrayTerritorios.get(i).getId() == id)
                return arrayTerritorios.get(i);           
        }
        return null;
    }


}

