import java.util.ArrayList;

// <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
import java.util.Iterator;
import java.util.Random;
import java.util.Scanner;
// #[regen=yes,id=DCE.89FE530E-0CE1-8738-9960-6CB9968E4852]
// </editor-fold> 
public class Jugador {

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.ADB46D97-1D82-C90A-A6A1-F4D1F1739BA7]
    // </editor-fold> 
    private Partida mJuego;    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.E5DB353A-6B8E-7792-BB6A-28AD4097E4B8]
    // </editor-fold> 
    private Territorio miCapital;    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.964FD058-A1B8-5C93-CDE4-3C2006B96801]
    // </editor-fold> 
    private CartaMision mCartaMision;    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.DE4DF99F-72B3-1E67-9BBE-D34E511286CD]
    // </editor-fold> 
    private ArrayList<CartaDeTerritorio> mCartaDeTerritorio;    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.50262C27-DD88-D8B4-53C3-C47D75BF91EF]
    // </editor-fold> 
    private ArrayList<CartaComodin> mCartaComodin;

    /*Variables creadas por nosotros*/
    private String nombre;
    private boolean objetivoCumplido;
    private boolean turnoFinalizado;
    private boolean abandonaPartida;
    private ArrayList<Territorio> TerritoriosPosee = new ArrayList<Territorio>();    //private boolean abandonarAtaque;
    private int numEjercitosParaUbicar;

    /********************************/    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.6CF75041-4622-42DB-30F3-0253643C8AB5]
    // </editor-fold> 
    public Jugador() {
        this("");
    }

    public Jugador(String nombre) 
    {
        System.out.println("Se crea el Jugador " + nombre);

        this.nombre = nombre;
        objetivoCumplido = false;
        turnoFinalizado = false;
        abandonaPartida = false;
        //abandonarAtaque = false;
    }
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.C42A72F7-B58D-440E-979E-357BC49D11C7]
    // </editor-fold> 
    public ArrayList<CartaComodin> getCartaComodin() {
        return mCartaComodin;
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.EEA89667-C255-6F4F-E2BA-A6AB2F399A9D]
    // </editor-fold> 
    public void setCartaComodin(ArrayList<CartaComodin> val) {
        this.mCartaComodin = val;
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.7178C3DA-56F1-3435-E3E6-D656B05088B5]
    // </editor-fold> 
    public ArrayList<CartaDeTerritorio> getCartaDeTerritorio() {
        return mCartaDeTerritorio;
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.219C2E17-8E47-53A9-EC2E-810B1BF3BAF0]
    // </editor-fold> 
    public void setCartaDeTerritorio(ArrayList<CartaDeTerritorio> val) {
        this.mCartaDeTerritorio = val;
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.18E3F3AD-AD04-200B-4196-104CFAB3EF93]
    // </editor-fold> 
    public CartaMision getCartaMision() {
        return mCartaMision;
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.1FC45CB5-CD68-31E8-7DBA-06CED77AAAD9]
    // </editor-fold> 
    public void setCartaMision(CartaMision val) {
        this.mCartaMision = val;
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.E2C8E837-5CFF-1B52-176E-EACDB725B1A6]
    // </editor-fold> 
    public Territorio getMiCapital() {
        return miCapital;
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.76ADAF3F-D01D-5278-A913-939C8A17FFC1]
    // </editor-fold> 
    public void setMiCapital(Territorio val) {
        this.miCapital = val;
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.2C2FB0A1-98A9-EEFF-AEB5-2852F9A09CA0]
    // </editor-fold> 
    public Partida getPartida() {
        return null;
    }

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.51EA5D13-32F4-EDCE-453B-5DB74B68EE86]
    // </editor-fold> 
    public void setPartida(Partida val) {
    }

    public boolean getObjetivoCumplido() {
        return objetivoCumplido;
    }

    public boolean getHaFinalizadoElTurno() {
        return turnoFinalizado;
    }

    public void setHaFinalizadoElTurno(Boolean val) {
        turnoFinalizado = val;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String val) {
        nombre = val;
    }

    public boolean getAbandonaPartida() {
        return abandonaPartida;
    }

    public void setAbandonaPartida(Boolean val) {
        abandonaPartida = val;
    }

    public void finalizarTurno() {
        turnoFinalizado = true;
        System.out.println("El Jugador ha finalizado el turno");

    /*Se haran las operaciones oportunas para realizar el fin de turno*/
    }

    public void setTerritorio(Territorio territorio) {
        TerritoriosPosee.add(territorio);
    }

    public ArrayList<Territorio> getTerritorios() {
        return TerritoriosPosee;
    }

    public void elimianarTerritorioDelArray(Territorio t) {
        TerritoriosPosee.remove(t);
    }

    /*
    public boolean isAbandonarAtaque() {
    return abandonarAtaque;
    }
    
    public void setAbandonarAtaque(boolean abandonarAtaque) {
    this.abandonarAtaque = abandonarAtaque;
    }
     */
    public int getNumEjercitosParaUbicar() {
        return numEjercitosParaUbicar;
    }

    public void setNumEjercitosParaUbicar(int numEjercitosParaUbicar) {
        this.numEjercitosParaUbicar = numEjercitosParaUbicar;
    }

    public void mover() 
    {
        setHaFinalizadoElTurno(false);

        while (!getHaFinalizadoElTurno()) 
        {
            Scanner teclado = new Scanner(System.in);

            /*Mostramos un menu de opciones*/
            System.out.println("Indique la opcion a realizar:\n");
            /*System.out.println("Para atacar opcion 'a'");
            System.out.println("Para transferir opcion 't'");
            System.out.println("Para ubicar opcion 'u'");
            System.out.println("Para finalizar turno opcion 'f'");
            System.out.println("Para abandonar partida opcion 'A'\n");
            System.out.println("Opcion: ");*/


            switch (teclado.nextLine().charAt(0)) 
            {
                case 'a':
                    atacar();
                    break;
                case 't':
                    transferir();
                    break;
                case 'u':
                    ubicar();
                    break;
                case 'A':
                    System.out.println("El " + nombre + " Abandona la Partida");
                    setAbandonaPartida(true);
                    return;
                case 'f':
                    finalizarTurno();
                    break;
                case 'v':
                    for (int i = 0; i < TerritoriosPosee.size(); i++) 
                        System.out.println("Territorio: " + TerritoriosPosee.get(i).getNombre() + " - " + TerritoriosPosee.get(i).getNumEjercitos());                    
                    break;
            }
        }
    }

    /*Metodo que representa al caso de uso "AcatarTerritorio"*/
    public void atacar() 
    {
        Scanner tecla = new Scanner(System.in);
        
        do
        {
            System.out.println("Territorios Origen del ataque\nSeleccione uno: \n");
            for (int i = 0; i < TerritoriosPosee.size(); i++) 
                System.out.println(TerritoriosPosee.get(i).getId() + " - " + TerritoriosPosee.get(i).getNombre());        
            System.out.println("\n");

            Territorio tOrigen = buscarTerritorioPorId(TerritoriosPosee, tecla.nextInt());

            /*Preguntamos al usuario si desea abandonar el ataque*/
            tecla = new Scanner(System.in);
            System.out.println("¿Desea abandonar el ataque?(y/n):\n");
            if (tecla.nextLine().charAt(0) == 'y') 
            {
                System.out.println("El jugador ha abandonado el ataque\n");
                return;
            }


            System.out.println("Territorios Colindantes del ataque\nSeleccione uno: \n");
            for (int i = 0; i < tOrigen.getTerritorio().size(); i++) 
            {
                /*Controlamos que el territorio colindante no sea propiedad del jugador que ataca*/
                if (tOrigen.getTerritorio().get(i).getJugador() != this)             
                    System.out.println(tOrigen.getTerritorio().get(i).getId() + " - " + tOrigen.getTerritorio().get(i).getNombre());            
            }
            System.out.println("\n");

            Territorio tDestino = buscarTerritorioPorId(tOrigen.getTerritorio(), tecla.nextInt());

            /*Preguntamos al usuario si desea abandonar el ataque*/
            tecla = new Scanner(System.in);
            System.out.println("¿Desea abandonar el ataque?(y/n):\n");
            if (tecla.nextLine().charAt(0) == 'y') 
            {
                System.out.println("El jugador ha abandonado el ataque\n");
                return;
            }


            System.out.println("Origen: " + tOrigen.getNombre() + " Destino: " + tDestino.getNombre());

            /*Realizamos el ataque*/
            int resultadoAtaque;
            int numEjercitosQuePierde = 1;  //Lo pasariamos como param E/S del simularAtaque
            resultadoAtaque = simularAtaque();

            if (resultadoAtaque == 0) /*El jugador ha ganado el enfrentamiento*/ 
            {
                System.out.println("El Jugador " + this.getNombre() + " ha Ganado");
                /*Restamos una armada al territorio que ha perdido el ataque*/
                tDestino.setNumEjercitos(tDestino.getNumEjercitos() - numEjercitosQuePierde);
                
                /*lo invadimos si no quedan ejercitos en ese territorio*/
                if (tDestino.getNumEjercitos() == 0) 
                {
                    System.out.println("Ejercitos para pasar?(de " + tOrigen.getNumEjercitos() + "/" + (tOrigen.getNumEjercitos() - 1) + "): \n");

                    int numEjercitosParaTransferir = tecla.nextInt();
                    invadir(this, tDestino, numEjercitosParaTransferir);
                    /*Restamos el numero de ejercitos que hemos movido del tOrigen al tDestino*/
                    tOrigen.setNumEjercitos(tOrigen.getNumEjercitos() - numEjercitosParaTransferir);
                }
            } 
            else if (resultadoAtaque == 1) /*El jugador ha perdido*/ 
            {
                System.out.println("El Jugador " + this.getNombre() + " ha Perdido");
                tOrigen.setNumEjercitos(tOrigen.getNumEjercitos() - numEjercitosQuePierde);

                /*TAL COMO ESTA PALNTEADO AHORA MISMO EL CODIGO, UN JUAGDOR ATACANDO NUNCA PUEDE 
                PERDER SU TERRITORIO DE ORIGEN*/

                /*if (tOrigen.getJugador().getNumEjercitosParaUbicar() == 0)
                {                
                invadir(tDestino.getJugador(), tOrigen, 1);
                }*/
            }
            tecla = new Scanner(System.in);
            System.out.println("Desea volver a atacar?(y/n):\n");
        }
        while (tecla.nextLine().charAt(0) == 'y');
    }

    /*Metodo que realiza las operaciones propias del ataque*/
    /*Decide que juagdor gana y cuántos ejercitos pierde en el enfrentamiento(de mmento no aparece)*/
    public int simularAtaque() 
    {
        Random r = new Random();
        int aleatorio = r.nextInt(2);
        return aleatorio;
    }

    
    /*Metodo que representa el caso de uso "Invadir Territorio"*/
    public void invadir(Jugador propietario, Territorio territorio, int numEjercitosTranspasar) 
    {
        /*Eliminamos el territorio del array de territorios que posee el jugador propietario*/
        territorio.getJugador().elimianarTerritorioDelArray(territorio);
        /*Le decimos que el propietario sea el otro jugador del ataque*/
        territorio.setJugador(propietario);
        /*Añadimos el territorio al array del propietario*/
        propietario.setTerritorio(territorio);

        territorio.setNumEjercitos(numEjercitosTranspasar);
    }

    
    /*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, int 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;
    }

    /*Metodo que implementa el caso de Uso "Ubicar" ejercitos en un territorio*/
    public void ubicar() 
    {
        Scanner tecla = new Scanner(System.in);
        int nEjercitos;

        while (getNumEjercitosParaUbicar() > 0) 
        {
            System.out.println("Le quedan " + getNumEjercitosParaUbicar() + " ejercitos pendientes de ubicar");
            System.out.println("Seleccione un Territorio para ubicar ejercitos");

            System.out.println("Territorios que Posee\nSeleccione uno: ");
            for (int i = 0; i < TerritoriosPosee.size(); i++)
                System.out.println(TerritoriosPosee.get(i).getId() + " - " + TerritoriosPosee.get(i).getNombre());            
            System.out.println("\n");

            Territorio territorioTemp = buscarTerritorioPorId(TerritoriosPosee, tecla.nextInt());


            System.out.println("Ejercitos que desea ubicar en " + territorioTemp.getNombre() + ": \n");

            /*Leemos cuántos ejercitos desea ubicar el jugador*/
            nEjercitos = tecla.nextInt();

            /*Comprobacion superacion limite*/
            while (nEjercitos > getNumEjercitosParaUbicar()) 
            {
                System.out.println("El numero introducido ha sido superado");
                System.out.println("Ejercitos que desea ubicar en " + territorioTemp.getNombre() + ": \n");
                nEjercitos = tecla.nextInt();
            }

            /*Incrementamos el numero de ejercitos del territorio*/
            territorioTemp.setNumEjercitos(territorioTemp.getNumEjercitos() + nEjercitos);
            /*Restamos los ejercitos ubicados de los pendientes de ubicar*/
            setNumEjercitosParaUbicar(numEjercitosParaUbicar - nEjercitos);

            /*Muestro los ejercitos de cada territorio que posee el jugador*/
            for (int i = 0; i < TerritoriosPosee.size(); i++) 
                System.out.println(TerritoriosPosee.get(i).getId() + " - " + TerritoriosPosee.get(i).getNombre() + " - " + TerritoriosPosee.get(i).getNumEjercitos());            
            System.out.println("\n");
        }

        System.out.println("No quedan ejercitos pendientes de ubicar\n");
    }

    public void transferir()
    {
        Scanner tecla = new Scanner(System.in);
        int numEjercitosParaTransferir;

        System.out.println("Territorios Origen de la Transferencia\nSeleccione uno: \n");
        for (int i = 0; i < TerritoriosPosee.size(); i++) 
            System.out.println(TerritoriosPosee.get(i).getId() + " - " + TerritoriosPosee.get(i).getNombre()+" - "+TerritoriosPosee.get(i).getNumEjercitos());        
        System.out.println("\n");

        Territorio tOrigen = buscarTerritorioPorId(TerritoriosPosee, tecla.nextInt());

        System.out.println("Territorios Colindantes de la Transferencia\nSeleccione uno: \n");
        for (int i = 0; i < tOrigen.getTerritorio().size(); i++) 
        {
            /*Controlamos que el territorio colindante no sea propiedad del jugador que ataca*/
            if (tOrigen.getTerritorio().get(i).getJugador() == this)             
                System.out.println(tOrigen.getTerritorio().get(i).getId() + " - " + tOrigen.getTerritorio().get(i).getNombre()+" - "+TerritoriosPosee.get(i).getNumEjercitos());            
        }
        System.out.println("\n");

        Territorio tDestino = buscarTerritorioPorId(tOrigen.getTerritorio(), tecla.nextInt());

        System.out.println("Origen: " + tOrigen.getNombre() + " Destino: " + tDestino.getNombre());
        
        /*Realizamos el movimiento de ejercitos entre los territorios*/
        System.out.println("Ejercitos que desea Transferir a "+tDestino.getNombre()+"\n");           
        numEjercitosParaTransferir = tecla.nextInt();
        
        /*Restamos ejercitos al origen y los sumamos al destino*/
        tOrigen.setNumEjercitos(tOrigen.getNumEjercitos()-numEjercitosParaTransferir);
        tDestino.setNumEjercitos(tDestino.getNumEjercitos()+numEjercitosParaTransferir);       
    }
}
