/*
entradas:
	blocos
	andares por  bloco
	unidades por andar
	consumo
	opção

saídas:
	Média do consumo de cada bloco
	Bloco com maior consumo médio
	Porcentagem do bloco anterior em relação ao total

	Média de consumo de cada andar
	Unidade com maior consumo de cada andar
	Andar do bloco com maior consumo diário
		Porcentagem em relação ao condomínio
		Porcentagem em relação ao bloco ao qual pertence

	Unidade com maior consumo do bloco

	Identificação (unidade, andar e bloco) da unidade que apresentou maior consumo
*/
package controlehidrico;
import java.util.*;
import java.io.*;
import java.lang.ArithmeticException;

public class ControleHidrico{

	public static final int blocos = 3;
	public static final int andares = 20;
	public static final int unidades = 6;

	public static void main(String[] args){

		boolean finExec=false;
		boolean dadosInseridos = false;
		boolean relatorio = false;


		int opcao;
		Scanner in = new Scanner(System.in);

		double[][][] condominio = new double[blocos][andares][unidades];

		while(finExec==false){

			System.out.println("\n\t--------- Sistema Controle de Consumo Hidrico Diario ---------\n");
			System.out.println("\tEscolha uma das opcoes a seguir:");
			System.out.println("\t1 - Entrada do Consumo do Dia");
			System.out.println("\t2 - Análise do Consumo Diario");
			System.out.println("\t3 - Entrada do Consumo do Dia (Arquivo)");
			System.out.println("\t4 - Relatorio do Consumo Diario (Arquivo)");
			System.out.println("\t5 - Sair");
			System.out.print("\tOpcao escolhida ==> ");
			opcao = in.nextInt();
			System.out.println("\n\t--------------------------------------------------------------\n");

			in.nextLine();	//limpa buffer
			switch(opcao){

				case 1:
					System.out.println("\t1 - Entrada do Consumo do Dia");
					dadosInseridos = LeMatriz(condominio);
					break;

				case 2:
					//chamada de funções que fazem análise do consumo diário
					System.out.println("\t2 - Análise do Consumo Diario");
					analise(condominio, relatorio);
					break;

				case 3:
					//chamada de função que pede arquivo
					System.out.println("\t3 - Entrada do Consumo do Dia (Arquivo)");
					System.out.print("\tCertifique-se que inseriu os valores de todos as unidades do condominio na ordem crescente de bloco, andar e apartamento.\n\tUtilize duas casas decimais para melhorar a precisão, mesmo que sejam 0.\n\tDigite o caminho completo do arquivo: ");
					String caminho = in.nextLine();

					dadosInseridos = leArquivo(caminho, condominio);
					break;

				case 4:
					//chamada de função que gera relatorio em arquivo
					System.out.println("\t4 - Relatorio do Consumo Diario (Arquivo)");
					gerarTXT(condominio, dadosInseridos, relatorio);
					break;

				case 5:
					finExec=encerra();
					break;

				default:
					System.out.println("\tComando Inválido!");	;
					break;
			}
		}
	}

// OPCAO1 - Entrada dos dados a um a um
	public static boolean LeMatriz(double m[][][]) {

		Scanner in = new Scanner(System.in);

		for (int i = 0; i < blocos; i++) {
			for (int j = 0; j < andares; j++) {
				for (int k = 0; k < unidades; k++) {
					System.out.print("\n\tBloco: " + (i + 1) + ", Andar: " + (j + 1) + ", Unidade: " + (j + 1) + "" + 0 + (k + 1) + ": ");
					m[i][j][k] = in.nextDouble();
				}
			}
		}
		return true;
	}


//	OPCAO2 - Analise

	public static void analise(double condominio[][][], boolean omiteContinua, String... caminho){

		double[][] somaAndar = new double[blocos][andares];
		double[] somaBloco = new double[blocos];
		int[][] idUniMaiorConsumoAndar = new int[blocos][andares];
		int[] idUniMaiorConsumoBloco = new int[blocos];
		int[] idAndarMaiorConsumoMedio = new int[blocos];


		double mediaBloco[] = new double[blocos];
		double mediaAndar[][] = new double[blocos][andares];

		double somaDasMedias=0;

		double porcenBlocoMaiorMedia;
		double porcenAndarCond;
		double porcenAndarBloco;

		double maior = 0;
		double totalBlocos = 0;
		Scanner in = new Scanner(System.in);

		int idDoMaior=0;

		double maiorglobal = 0;
		int maioru = 0;
		int maiora = 0;
		int maiorb = 0;

		maioresConsumos(condominio, idUniMaiorConsumoAndar, idUniMaiorConsumoBloco, idAndarMaiorConsumoMedio, somaAndar);

		System.out.println("\t******************************************************");
		System.out.println("\t*            Análise do Consumo Diário               *");
		System.out.println("\t******************************************************");

		System.out.println("\tMédia do Consumo diário e total por bloco: ");
		for (int l = 0; l < blocos; l++) {

			somaBloco[l] = soma(condominio, 'b', l);

			mediaBloco[l] = somaBloco[l]/(andares*unidades);
			somaDasMedias=somaDasMedias + mediaBloco[l];

			System.out.println("\tBloco " + (l + 1) + ": " + arredonda(mediaBloco[l]) + " litros");
			System.out.println("\tTotal do Bloco " + (l + 1) + ": " + arredonda(somaBloco[l]) + " litros\n");
			totalBlocos = totalBlocos + somaBloco[l];
			if (maior < mediaBloco[l]) {
				 maior = mediaBloco[l];
				 idDoMaior = l;

			}
		}

		porcenBlocoMaiorMedia = arredonda(100.0*mediaBloco[idDoMaior]/somaDasMedias);

		System.out.println("\n\tConsumo total: " + somaBloco[0] + "L + " + somaBloco[1] + "L + " + somaBloco[2] + "L = " + totalBlocos + "L");
		System.out.println("\n\tO Bloco " + (idDoMaior+1) + " obteve o maior consumo médio diário (" + arredonda(porcenBlocoMaiorMedia) +"% do total).");

		if(omiteContinua==false)
			continua();

			maior = 0;
			for(int i=0; i<blocos; i++){
				System.out.println("\tBloco " + (i + 1) + " : Média de consumo e unidade com maior consumo por Andar");
				for(int j=0; j<andares; j++){

					somaAndar[i][j]=soma(condominio, 'a', i, j);

					mediaAndar[i][j]=somaAndar[i][j]/unidades;


					System.out.println("\r\t" +(j + 1) + "º Andar:"+arredonda(mediaAndar[i][j])+" litros (unidade "+(j + 1)+"0"+(idUniMaiorConsumoAndar[i][j] + 1)+" teve maior consumo)");

					for(int k=0 ; k < unidades ; k++){
						if( condominio[i][j][k] > maiorglobal){
							maiorglobal = condominio[i][j][k];

							maioru = k+1;
							maiora = j+1;
							maiorb = i+1;
						}
					}
				}

				porcenAndarCond = arredonda(100.0*(somaAndar[i][idAndarMaiorConsumoMedio[i]]/totalBlocos));

				System.out.println("\n\tO " + (idAndarMaiorConsumoMedio[i]+1) + "º andar obteve o maior consumo médio diário");

				System.out.println("\t" + porcenAndarCond + " % em relação ao Condomínio");

				porcenAndarBloco=arredonda((somaAndar[i][idAndarMaiorConsumoMedio[i]]/somaBloco[i])*100);

				System.out.println("\t" + porcenAndarBloco + " % em relação ao bloco " + (i+1) + ".");

				System.out.println("\tA unidade " + idUniMaiorConsumoBloco[i] + " obteve o maior consumo do bloco " + (i+1));

				if(omiteContinua==false)
					continua();

			}
                        // maior consumo de todas as unidades
			System.out.println("\tA unidade "+maiora+"0"+maioru+ " do "+maiora+"º Andar do Bloco "+maiorb+" teve o maior consumo do condominio");
			System.out.println("\n\t--------------------------------------------------------------");


	}

//	OPCAO3 - ENTRADA DE ARQUIVO
	public static boolean leArquivo(String caminho, double condominio[][][]){

		int contador=0;
		int totalDeUnidades = unidades*andares*blocos;
		try{

			Scanner in = new Scanner(new FileReader(caminho)).useDelimiter(";|\n");

			while(in.hasNext()){
				String campo1 = in.next();
				String campo2 = in.next();
				String campo3 = in.next();
				String campo4 = in.next();

				int bloco = Integer.parseInt(campo1) - 1 ;
				int andar = Integer.parseInt(campo2) - 1 ;
				int uni = Integer.parseInt(campo3) - 1 ;
				double consumo = Double.parseDouble(campo4);

				int tratamento=(uni/100);
				uni = uni - tratamento*100;
				condominio[bloco][andar][uni] = consumo;

				contador++;
			}

			if(contador < (totalDeUnidades)){

				System.out.println("\tATENÇÃO! Existe(m) " + (totalDeUnidades - contador) + " unidade(s) sem dados de consumo. Nesta versão do programa podem ocorrer erros nessas condições...\n");
			}

			return true;

		} catch (IOException ioe){
			System.out.println("\tErro ao ler o arquivo: " + ioe.getMessage());
		}

		return false;

	}

	public static void gerarTXT(double cond[][][], boolean dadosInseridos, boolean omiteContinua){

		try{
					if(dadosInseridos==true){

					Scanner entrada = new Scanner(System.in);
					String nome;
                                        String local;
					String relatorio;

					System.out.print("\tEscolha um nome para o arquivo: ");
                                        nome = entrada.nextLine();

                                        System.out.print("\tEscolha um local para salvar o arquivo - formato [C:\\Users\\Nome Usuario\\Desktop\\ ]: ");
                                        local = entrada.nextLine();

					nome = local + nome + ".txt";
					System.out.print("\tArquivo gerado : " + nome);
					PrintStream stdout = System.out;
					PrintStream out = new PrintStream(new FileOutputStream(nome));

					System.setOut(out);
					omiteContinua=true;
					analise(cond, omiteContinua);
					System.setOut(stdout);
				}
				else{
					System.out.println("\tNão é possível gerar o relatório. Dados de consumo não inseridos!\n");
					continua();
				}
			} 	catch (IOException geratxt){
				System.out.println("\tErro ao escrever o arquivo: " + geratxt.getMessage());
			}
	}


		/****************************************/
		/*													 */
		/*				FUNÇÕES AUXILIARES			 */
		/*													 */
		/****************************************/


	public static boolean encerra(){

		Scanner in = new Scanner(System.in);
		char sairNouS;
		boolean saida;

		System.out.println("\tDeseja abandonar o sistema? [s]im ou [n]ao");
		System.out.print("\tResposta ==> ");
		sairNouS = in.next().charAt(0);

		switch(sairNouS){

			case 'n':
				saida = false;
				break;

			case 's':
				System.out.println("\tObrigado por usar o sistema e poupar agua.");
				System.out.println("\tAinda precisa chover muito para sair do volume morto e cada gota conta.\n");
				saida = true;
				break;

			default:
				System.out.println(sairNouS);
				System.out.println("\tComando inválido!");
				encerra();
				saida = false;
				break;
		}

		return saida;
	}

	public static void continua(){
		System.out.println("\t--------------------------------------------------------------");
		System.out.println("\tPressione enter para continua.");
		System.out.println("\t--------------------------------------------------------------");
		try{
			System.in.read();
		} catch(IOException error) {
			System.out.println("\tErro. Pressione enter para continuar.");
			System.out.println("\t--------------------------------------------------------------");
		}
	}


	public static void maioresConsumos (double m[][][], int idUniComMaiorConsumoAndar[][], int idUniComMaiorConsumoBloco[], int idAndarComMaiorConsumoMedio[], double somaDoAndar[][]){
		double maiorConsumoUniAndar=0;
		double maiorConsumoMedioAndar=0;
		double maiorConsumoUniBloco=0;

		for (int i = 0; i < blocos; i++) {
			maiorConsumoMedioAndar=0;
			for (int j = 0; j < andares; j++) {
				maiorConsumoUniAndar=0;
				for (int k = 0; k < unidades; k++) {

					if(maiorConsumoUniAndar < m[i][j][k]){
						maiorConsumoUniAndar = m[i][j][k];
						idUniComMaiorConsumoAndar[i][j] = k;
					}

					if(maiorConsumoUniBloco < m[i][j][k]){
						maiorConsumoUniBloco = m[i][j][k];
						idUniComMaiorConsumoBloco[i] = ((j+1)*100 + (k + 1));
					}

					somaDoAndar[i][j] = soma(m, 'a', i, j);

					if(maiorConsumoMedioAndar < (somaDoAndar[i][j]/unidades)){
						maiorConsumoMedioAndar = (somaDoAndar[i][j]/unidades);
						idAndarComMaiorConsumoMedio[i]=j;
					}
				}
			}
			maiorConsumoUniBloco=0;
		}
	}


	public static double mediaDoBloco(double baseDeDados[][][], int IdBloco) {
        double soma = 0;
        double contador = 0;
        for (int i = 0; i < andares; i++) {
            for (int j = 0; j < unidades; j++) {

                soma = soma + baseDeDados[IdBloco][i][j];
                contador++;
            }
        }
        return (soma / contador);

    }

	public static double soma(double m[][][], char escolha, Integer... id){
		double somaAndar=0;
		double somaBloco=0;
		double somaCond=0;

		for (int i=0; i<blocos; i++) {

			somaBloco = 0;

			if( escolha=='b' ) //i = idBloco;
				i=id[0];

				for (int j=0; j<andares; j++) {
					somaAndar=0;

					if(escolha=='a') //j=idAndar;
						j=id[1];

					for (int k=0; k<unidades; k++) {
						somaAndar = somaAndar + m[i][j][k];
					}
					if( escolha=='a') return somaAndar;

					somaBloco = somaBloco + somaAndar;
				}
				if( escolha=='b') return somaBloco;
				somaCond = somaCond + somaBloco;
		}

		return somaCond;

	}

	public static double arredonda(double entrada){
		double rounded;
		double resto;

		entrada=entrada*1000;
		resto=entrada%5;

		entrada=(entrada - resto);

		if( entrada%10 == 5 ){
			rounded=(entrada+5)/1000;
		}
		else{
			rounded=(entrada)/1000;
		}
		return rounded;
	}
}