import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.util.StringTokenizer;
 
public class FileTools {
 
 
	/** Metodo que remove letras de um texto
	 * 
	 * @param orders Ficheiro que contem as letras a remover
	 * @param in Ficheiro a ser editado
	 * @param out Ficheiro de Saida
	 * @throws IOException File not Found se o ficheiro de entrada nao existir
	 */
	static void removeLetters( BufferedReader orders, BufferedReader in, 
			BufferedWriter out ) throws IOException{
 
		String orderRemove, input;	//Vao guardar respectivamente as letras a remover, a frase actual
		StringBuilder sb = new StringBuilder();	//Vai permitir transpor as letras todas a remover do ficheiro
												//Para uma string
		StringBuilder sbout = new StringBuilder();	//Vai conter o texto final para ser escrito em ficheiro
 
		while((orderRemove = orders.readLine()) != null){
 
			sb.append(orderRemove);
 
		}	
 
		orderRemove = sb.toString();		
 
		//Este ciclo corre o ficheiro de entrada ate ao fim
		while((input = in.readLine()) != null){
			//Este ciclo corre todos os carateres da linha actual do ficheiro de entrada	
			for(int i = 0; i < input.length(); i++){
 
				int flag = 0;
				//Corre o ficheiro de ordens para cada letra do de entrada
				for(int j = 0; j < orderRemove.length() ; j++){
					//Se a letra do ficheiro de entrada na posicao j 
                                        //corresponder a uma letra existente no ficheiro
					//de orders incrementa-se a flag
					if(input.charAt(i) == orderRemove.charAt(j) ){             
 
						flag++;
					}
				}
				//Se a flag for zero, significa que a letra nao estava no 
                                //ficheiro, logo adiciona-se ao SB
				if(flag == 0){
					sbout.append(input.charAt(i));
				}
			}
			sbout.append("\n");	//Dá o paragrafo
 
		}
		//Escreve tudo para o ficheiro
		out.write(sbout.toString());
		//System.out.print(sbout.toString());
 
	}
 
	/** Metodo que capitaliza o texto de entrada de acordo com as ordens fornecidas num ficheiro orders
	 * 
	 * @param orders Ficheiro que contem a ordem de capitalizacao
	 * @param in Ficheiro de entrada
	 * @param out Ficheiro editado
	 * @throws IOException File not Found se não existir o ficheiro de entrada pedido
	 */
	static void capitalize( BufferedReader orders, BufferedReader in, 
			BufferedWriter out ) throws IOException{
 
		String input,output = "";
		int orderCapitalize;
 
		StringBuilder sb = new StringBuilder();
		StringBuilder sbout = new StringBuilder();
 
		sb.append(orders.readLine());
		orderCapitalize = Integer.parseInt(sb.toString());
 
		if(orderCapitalize == 0){
			//Tudo em minusculas
			while((input = in.readLine()) != null){
 
				//System.out.print(output.concat(input.toLowerCase()+"\n"));
				out.write(output.concat(input.toLowerCase()+"\n"));
			}
		}
 
		if(orderCapitalize == 1){
			//Tudo em maiusculas
			while((input = in.readLine()) != null){
 
				//System.out.print(output.concat(input.toUpperCase()+"\n"));
				out.write(output.concat(input.toUpperCase()+"\n"));
 
			}
		}
 
		if(orderCapitalize == 2){
			//A primeira letra de Cada frase e maiuscula
			while((input = in.readLine()) != null){
				//ciclo que percorre cada caracter por linha
 
				int posix=0;
				for(int i = 0; i < input.length(); i++){
 
					//Se o caracter nao for um .
					if(input.charAt(i) != '.'){
 
						//Se diferente de posix manter a capitalizacao minuscula
						if(i != posix)
							sbout.append(input.charAt(i));
						//Adiciona a primeira letra da linha
						if(i==0)
							sbout.append(input.toUpperCase().charAt(i));
 
						//Se for um ponto
					}else{
						//Guarda a posicao da letra certa a capitalizar
						posix = i+2;
 
						//Adicioma o espaço
						sbout.append(input.charAt(i));
 
					}
 
					//Quando o i chega a posicao posix capitaliza a letra
					if( i == posix && i != 0){
 
						sbout.append(input.toUpperCase().charAt(i));
					}
 
				}
				//Dá o pararagrafo a cada linha do ficheiro (senao fica tdo em frente)
				sbout.append("\n");
			}
 
		}
		//System.out.println(sbout.toString()); //Linha de codigo para debugging
		out.write(sbout.toString());
	}
 
	/** Metodo que conta o numero de ocorrencias de todas as palavras e ordena-as por ordem decrescente
	 * 
	 * @param in Ficheiro de entrada
	 * @param out Ficheiro com o histograma
	 * @throws IOException File not Found se o ficheiro de entrada não existir
	 */
	static void histogram( BufferedReader in, BufferedWriter out ) throws IOException{
 
 
		int[]frequencia = new int[1000];	//Conta a frequencia das palavras
		String[]linha = new String[1000];	//Stores the words already without repetition (filtered)
		String input, temp;			//input recebe linha do ficheiro, temp serve para analise de length
 
		StringBuilder sb = new StringBuilder();
 
		//Coloca as frases do ficheironum stringbuilder formatadas para n ter maisculas
		while((input = in.readLine()) != null){
 
			sb.append(input.toLowerCase().replaceAll("[^a-z]", "\n"));
 
		}
		//Permite contar com facilidade o numero de palavras por linha [xx.countTokens();]
		StringTokenizer st = new StringTokenizer(sb.toString());
 
		//Cria um array de strings com a quantidade de palavras certa por linha
		String[]inputText = new String[st.countTokens()];
 
		//Coloca as palavras do ficheiro num vector
		for(int i = 0; i < inputText.length; i++){
 
			//guarda o token corrente para se poder efectuar ops sobre ele caso contrario st.nextToken()
			//invoca o promixo e nao se pode retirar por exemplo o tamanho do actual
			temp = st.nextToken();
 
			//Se essa palavra tiver comprimento maior que um agrega ao array
			if(temp.length() > 1){
				inputText[i] = temp;
			//Caso contrario Guarda NODATA no array para nao ficar null
			}else{
				inputText[i] = "NODATA";
			}
		}
 
		//Este ciclo corre o vector onde vao ser armazenadas as palavras
		for(int j=0; j < linha.length; j++){			
 
			//Este ciclo percorre o vector de TODAS AS PALAVRAS
			for (int i = 0; i < inputText.length; i++) {
 
				//Procura a proxima pos no vector que nao esteja a branco
				if(inputText[i]!="NODATA"){
 
					//Atribui a proxima palavra localizada a posicao actual do vector
					linha[j]= inputText[i];
 
					break;
				}
 
			}
 
			if(linha[j] != null){
 
				//Guarda a frequencia da palavra no respectivo lugar
				frequencia[j] = contaPalavra(inputText, linha[j]);
 
				//Apaga essa palavra do array
				apagaPalavra(inputText, linha[j]);
			}
		}
 
		//Imprime no ficheiro as cenas todas ordenadinhas
		out.write(buildHistogram(frequencia, linha).toString());
 
	}
 
	/** Metodo que conta a ocorrencia de uma determinada palavra
	 * 
	 * @param arrayString Array de Strings
	 * @param palavra Palavra a verificar ocorrencia
	 * @return Quantidade de vezes que ocorre a palavra no vector
	 */
	private static int contaPalavra(String[] arrayString, String palavra){
 
		int quantidade=0;
 
		for (int k = 0; k < arrayString.length; k++) {
 
			if(palavra.contentEquals(arrayString[k])){
				quantidade++;
			}
		}
 
		return quantidade;
	}
 
	/** Metodo que apaga todas as ocorrencias de uma palavra num vector
	 * 
	 * @param arrayString Array com todas as palavras
	 * @param palavra Palavra a eliminar
	 */
	private static void apagaPalavra(String[] arrayString, String palavra){
 
		for (int l = 0; l < arrayString.length; l++) {
 
			if(palavra.contentEquals(arrayString[l])){
				arrayString[l]="NODATA";
			}
 
		}
	}
 
	/** Metodo que imprime que constroi o histograma ordenado
	 * 
	 * @param array Array de inteiros correspondente às frequencias
	 * @param linha Array que contem as palavras
	 * @return Um objecto do tipo StringBuilder com o histograma ordenado e pronto a imprimir
	 */
	public static StringBuilder buildHistogram(int[] array, String[] linha){
 
		StringBuilder sbout = new StringBuilder();
		int[]pos = new int [array.length];		//Guarda  a posicao relativa do valor da freq de uma certa palavra 
		int temp, posTemp;
 
		for (int k = 0; k < pos.length; k++) {
 
			pos[k]=k;
		}
 
		for (int j = 0; j < array.length; j++) {
 
			for (int i = 1; i < array.length; i++){
 
				if(array[i] > array[i-1]){
 
					//Ordena as frequencias por ordem decrescente
					temp = array[i-1];
					array[i-1] = array[i];
					array[i] = temp;
 
					//Mantém o valor do index ordenado para que a frequencia certa 
					//condiga com a palavra certa
					posTemp = pos[i-1];
					pos[i-1] = pos[i];
					pos[i] = posTemp;
				}
 
			}
		}
 
		//Ciclo que imprime as palavras + a sua frequencia
		for (int i = 0; i < pos.length; i++) {
 
			//Impede que apareca escrito null no ficheiro e zeros
			if(linha [i] != null && array[i] != 0){
 
				sbout.append(linha[pos[i]]+":"+array[i]+"\n");
				//System.out.println(linha[pos[i]]+":"+array[i]);
				//out.write(linha[pos[i]]+":"+array[i]+"\n");
			}
		}
		return sbout;
 
 
 
	}
 
}