import java.util.Scanner;


public class Diccionario {

	//Estas son variables globales ya que estarían fuera de los métodos. El Main también es un método.
	//Al declarar variables fuera de los métodos son variables globales para esta clase.

	public static int contador = 0;
	public static String [] palabras = new String[5];
	public static String [] definiciones = new String[5];
    public static Scanner sc = new Scanner (System.in);//Scanner importado

     public static void main(String[] args) {

    	 int opcion = 0;
 		do{
 			System.out.println("===================================");
 			System.out.println("1)Listar el diccionario");
 			System.out.println("2)Añadir una palabra");
 			System.out.println("3)Eliminar una palabra");
 			System.out.println("4)Estadísticas");
 			System.out.println("5)SALIR");//Puedo usar while o for. Pero algo tan simple como mostrar el MENU
 			                              //podemos usar un DO WHILE. Si es posible que los datos iniciales sean
 			                              //incorrectos mejor un WHILE
 			System.out.println("Escoja una opción");



 			opcion = sc.nextInt();//Así le digo que junte lo que escriba el usuario
 			                         // y lo transforme en un número. y lo guarda en opción,que
 			                        // es una variable. Le asigna como valor lo escrito por el usuario.

 			sc.nextLine(); //Desechamos el resto del buffer. Despues de leer un entero hay que vaciar el buffer.

 			switch (opcion){

	 			case 1: listarDiccionario();
	 			break;
	 			case 2: addPalabra();
	 			break;
	 			case 3: borrarPalabra();
	 			break;
	 			case 4: mostrarSubmenuEstadisticas();
	 			break;
	 			case 5: System.out.println("Hasta luego");
	 			break;
	 			default: System.out.println("Escoja una opción entre 1 y 4");
 			}
 		}while(opcion != 5);
     }

 			//}
 			//if(opcion == 1){
 				//listarDiccionario();
 			//else if(opcion == 2){
 				//addPalabra();
 			//}else if(opcion == 3){
 				//borrarPalabra();
 			//}else if(opcion == 4){
 			//	mostrarSubmenuEstadisticas();
 			//}
 		//}while(opcion != 5);

     public static void addPalabra(){



    	 System.out.println("===================================");

    	 if(contador < palabras.length){//Solo podremos insertar si hay hueco. Contador me dice dónde insertar.


			 System.out.println("Introduzca la palabra");
			 String palabra = sc.nextLine(); //con nextLine obtenemos un strng con lo que
			 System.out.println("Introduzca la definición");
			 String definicion = sc.nextLine();

			 palabras[contador] = palabra;


		     definiciones[contador] = definicion;
		     contador++;
    	 }else{
    		 System.out.println("El diccionario está lleno");
    	 }
     }

     public static void listarDiccionario(){

    	 for(int a=0; a<contador; a++){ //Si lo quiero recorrer entero sin saber el tamaño del array uso length

    		 String palabra = palabras[a];
    		 String definicion = definiciones[a];
    		 System.out.println(palabra+": "+definicion);

    		 //o también
    		 //System.out.println(palabras[a]+": "+definiciones[a]);
    	 }
     }
     //public static void borrarPalabra(){//Le pedimos que escriba la palabra a borrar y averiguamos si son iguales

    	 //System.out.println("============================================");

    	 //System.out.println("Introduzca la palabra a borrar:");
    	 //String palabra = sc.nextLine();

    	 //Primero buscamos en qué posición se encuentra la palabra
    	 //int a=0;
    	 //for (a=0; a<contador; a++){//Desde la posición a=0 hasta contador.

    		 //if(palabra.equalsIgnoreCase( palabras[a] )){
    			 //break;
    		 //}
    	 //}
    	 //Y luego nos traemos todos los elementos una posición hacia atrás y dejar el hueco al final.
    	 //Si le resto 1 al contador me ahorro poner -1

    	 //contador--;
    	 //for (int b=a; b<contador; b++){
    		 //palabras[b] =palabras[b+1];
    		 //definiciones[b]=definiciones[b+1];
    	 //}
    	 //palabras[contador] = null;
    	 //definiciones[contador] = null;

    	 //}


     public static void borrarPalabra(){
    	    System.out.println("===================================");
    	    System.out.println("Introduzca la palabra a borrar:");
    	    String palabra = sc.nextLine();

    	    //Primero buscamos en que posición se encuentra la palabra
    	    int a=0;
    	    for(a=0; a<contador; a++){
    	      if(palabra.equalsIgnoreCase( palabras[a] )){
    	        break;
    	      }
    	    }

    	    if( a != contador ) {
    	      //Y luego nos traemos todos los elementos una posición hacia atras
    	      contador--;
    	      for(int b=a; b<contador; b++){
    	        palabras[b] = palabras[b+1];
    	        definiciones[b] = definiciones[b+1];
    	      }
    	      palabras[contador] = null;
    	      definiciones[contador] = null;
    	    } else {
    	      System.out.println("La palabra no existe en le diccionario.");
    	    }

    	  }
     public static void mostrarSubmenuEstadisticas(){

    	 int opcion = 0;
    	 do{
	    	 System.out.println("=================================================");
	    	 System.out.println("ESTADÍSTICAS");
	    	 System.out.println("1) Encontrar la palabra más corta del diccionario");
	    	 System.out.println("2) Encontrar la palabra más larga del diccionario");
	    	 System.out.println("3) Distribución de longitudes");
	    	 System.out.println("4) Volver");

	    	 opcion = sc.nextInt();
	    	 sc.nextLine(); //Para eliminar el 'enter'

	    	 switch (opcion){

	 			case 1: encontrarPalabraMasCorta();
	 			break;
	 			case 2: encontrarPalabraMaslarga();
	 			break;
	 			case 3: distribucionLongitudes();
	 			break;
	 			case 4: break;
	 			default: System.out.println("Como estamos....");
			}

    	 }while(opcion!=4);
     }

     public static void encontrarPalabraMasCorta(){

    	 //String txt = "Bo que pasa";
    	 //int longitud = txt.length(); //para averiguar la longitud de un string.


    	 int posicionMasCorta = 0;
    	 int longitudMasCorta = Integer.MAX_VALUE;//Declaro estas variables para que almacene la palabra
    	 										  //más corta que vaya encontrando

    	 for(int a=0; a<contador; a++){
    		 String palabra = palabras[a];//Cojo cada palabra de 1 en 1 y veo su longitud.
    		 int longitud = palabra.length();//Qué posición ocupa la palabra más corta hasta el momento.
    		                                 //Necesito almacenar la posición y la longitud de la más corta que
    		                                 //vaya encontrando

    		 if(longitud<longitudMasCorta){
    			 							//Ahora voy a comparar con la siguiente
    			 longitudMasCorta = longitud; //Si es menor, longitud de la nueva sera menor que longmascorta
    			 posicionMasCorta = a; //Y la posición de la nueva palabra será la de la anterior que tenía.

    		 }

    	 }
    	 System.out.println("=================================================");
    	 System.out.println("Palabra más corta del diccionario:");
    	 System.out.println(palabras[posicionMasCorta]+". Longitud:"+longitudMasCorta);


     }


     public static void encontrarPalabraMaslarga(){

    	 int posicionMasLarga = 0;
    	 int longitudMasLarga = 0;

    	 for(int a=0; a<contador; a++){
    		 String palabra = palabras[a];
    		 int longitud = palabra.length();

    		 if(longitud>longitudMasLarga){
    			 posicionMasLarga = a;
    			 longitudMasLarga = longitud;
    		 }
    	 }
    	 System.out.println("========================================================================");
    	 System.out.println("Palabra más larga del diccionario:");
    	 System.out.println(palabras[posicionMasLarga]+". Longitud:"+longitudMasLarga);
     }

     public static void distribucionLongitudes(){//Cuando declaras un array tienes todo ceros.

    	 int [] distribucion = new int[20];

    	 for (int a=0; a<contador; a++){


    		 String palabra = palabras[a];
    		 int longitud = palabra.length();


    		 distribucion[longitud-1] = distribucion[longitud-1]+1;

    	 }

    	 for(int a=0; a<20; a++){
    		 System.out.println("Palabras de longitud "+(a+1)+": "+distribucion[a]);

    	 }
     }

}







		 //Cuando borro una palabra queda un hueco y puedo recorrer el array buscando ese hueco.
		 //Con el contador voy directo al hueco y cuando borro se desplaza todo a la izquierda.
		 //Si mi aplicación lo que hace es añadir sobre todo y borrar a veces, me conviene el contador.
		 //No me conviene el contador, si mi aplicación inserta y borra continuamente. Usamos el contador para
		 //saber en qué posición hay que insertar.