/*
    * Created on 05/10/2004
    *
    */
   package comum.util;
   
   import java.lang.reflect.Field;
   import java.lang.reflect.InvocationTargetException;
   import java.lang.reflect.Method;
  import java.net.URLEncoder;
  import java.security.cert.CertificateException;
  import java.security.cert.X509Certificate;
  import java.text.DecimalFormat;
  import java.text.NumberFormat;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Date;
  import java.util.List;
  import java.util.Properties;
  
  import javax.mail.Message;
  import javax.mail.MessagingException;
  import javax.mail.Session;
  import javax.mail.Transport;
  import javax.mail.internet.AddressException;
  import javax.mail.internet.InternetAddress;
  import javax.mail.internet.MimeMessage;
  import javax.net.ssl.HostnameVerifier;
  import javax.net.ssl.HttpsURLConnection;
  import javax.net.ssl.SSLContext;
  import javax.net.ssl.SSLSession;
  import javax.net.ssl.TrustManager;
  import javax.net.ssl.X509TrustManager;
  import javax.servlet.http.HttpServletRequest;
  
  import ecar.dao.ConfiguracaoDao;
  import ecar.dao.CorDao;
  import ecar.dao.EmailDao;
  import ecar.exception.ECARException;
  import ecar.pojo.ConfiguracaoCfg;
  import ecar.pojo.Cor;
  import ecar.pojo.Email;
  import ecar.pojo.TipoFuncAcompTpfa;
  import ecar.pojo.UsuarioUsu;
  import ecar.util.Dominios;
  
  
  /**
   * @author garten
   */
  public class Util {
  
  	/**
  	 * Lista os métodos get de um objeto passado como parâmetro.<br>
  	 * 
  	 * @author N/C
  	 * @since N/C
  	 * @version N/C
  	 * @param Object o - objeto a ser verificado
  	 * @return List - lista de métodos da classe Method 
  	 */
  	public static List<Method> listaMetodosGet(Object o) {
  		return listaMetodos(o, Dominios.REGEXP_METODOS_GET);
      }
          
  	/**
  	 * Lista os métodos set de um objeto passado como parâmetro.<br>
  	 * 
  	 * @author N/C
  	 * @since N/C
  	 * @version N/C
  	 * @param Object o - objeto a ser verificado
  	 * @return List - lista de métodos da classe Method 
  	 */
  	public static List<Method> listaMetodosSet(Object o) {
  		return listaMetodos(o, Dominios.REGEXP_METODOS_SET);
  	}
  
  	/**
  	 * Lista todos os métodos declarados de um objeto passado como parâmetro.<br>
  	 * 
  	 * @author N/C
  	 * @since N/C
  	 * @version N/C
  	 * @param Object o - objeto a ser verificado
  	 * @return List - lista de métodos da classe Method 
  	 */
  	public static List<Method> listaMetodos(Object o) {
  		return listaMetodos(o, Dominios.REGEXP_TODOS);
  	}
  	
  	
  	/**
  	 * Devolve uma lista de métodos declarados pelo programador em um objeto.<br>
  	 * 
  	 * @author N/C
  	 * @since N/C
  	 * @version N/C
  	 * @param Object o - objeto a ser verificado
 	 * @param String pattern - uma expressao regular dos métodos que desejam ser listados
 	 * @return List - lista de métodos da classe Method<br>
 	 * <p>
 	 * Exemplo de utilização:<br>
 	 * List l = new ArrayList();<br>
 	 * l = Util.listaMetodos(new Object(), ".*");  // todos os metodos da classe Object<br>
 	 * for (int i = 0; i < l.size(); i++)<br>
 	 * 		System.out.println(((Method)l.get(i)).getName());<br>
 	 */
 	public static List<Method> listaMetodos(Object o, String pattern) {
 		List<Method> l = new ArrayList<Method>();
     		
 		try {
 			Method[] m = o.getClass().getDeclaredMethods();
     		    
 			for (int i = 0; i < m.length; i++)
 				if (m[i].getName().matches(pattern))
 					l.add(m[i]);
     		    
 		} catch (SecurityException s) {
 			
 		}
     	
 		return l;
 	}
 
 	/**
 	 * Lista os todos os atributos declarados de um objeto passado como parâmetro.<br>
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @param Object o - objeto a ser verificado
 	 * @return List - lista de atributos da classe Method 
 	 */
 	
 	public static List<Field> listaAtributos(Object o) {
 		return listaAtributos(o, Dominios.REGEXP_TODOS);
 	}
 	
 	
 	/**
 	 * Devolve uma lista de atributos declarados pelo programador em um objeto.<br>
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @param Object o - objeto a ser verificado
 	 * @param String pattern - uma expressao regular dos atributos que desejam ser listados
 	 * @return List - lista de atributos da classe Field<br>
 	 * <p>
 	 * Exemplo de utilização:<br>
 	 * List l = new ArrayList();<br>
 	 * l = Util.listaAtributos(new Object(), ".*");  // todos os atributos da classe Object<br>
 	 * for (int i = 0; i < l.size(); i++)<br>
 	 * 		System.out.println(((Field)l.get(i)).getName());<br>
 	 */
 	public static List<Field> listaAtributos(Object o, String pattern) {
 		List<Field> l = new ArrayList<Field>();
     		
 		try {
 			Field[] f = o.getClass().getDeclaredFields();
     		    
 			for (int i = 0; i < f.length; i++)
 				if (f[i].getName().matches(pattern))
 					l.add(f[i]);
     		    
 		} catch (SecurityException s) {
 			
 		}
     	
 		return l;
 	}
 	
 	/**
 	 * Invoca um metodo getXxxxx() para o objeto e o atributo informado.<br>
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @param Object o - o objeto cujo metodo get será chamado
 	 * @param String atributo - o nome do atributo que identifica qual getter chamar
 	 * @param Object[] objParams - os parametros que devem ser passados para a invocação do método - geralmente null
 	 * @return Object
 	 * @throws ECARException
 	 */
 	public static Object invocaGet(Object o, String atributo, Object[] objParams) throws ECARException {
 	    String nomeGetter = "get" + primeiraLetraToUpperCase(atributo);
         try {
             /* supoe que existe apenas um unico metodo com esse nome, portanto passa null no array
              * de classes do getMethod
              */
             return o.getClass().getMethod(nomeGetter, new Class[]{}).invoke(o, objParams);
         } catch (IllegalArgumentException e) {
             throw new ECARException("erro.exception");
         } catch (SecurityException e) {
            throw new ECARException("erro.exception");
         } catch (IllegalAccessException e) {
             throw new ECARException("erro.exception");
         } catch (InvocationTargetException e) {
             throw new ECARException("erro.exception");
         } catch (NoSuchMethodException e) {
             throw new ECARException("erro.exception");
         }
 	}
 
 	/**
 	 * InvocaGet Simplificado, não recebe os parâmetros de invocação de um objeto.<br>
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @param Object o
 	 * @param String atributo
 	 * @return Object
 	 * @throws ECARException
 	 */
 	public static Object invocaGet(Object o, String atributo) throws ECARException {
 	    return invocaGet(o, atributo, null);
 	}
 
 	/**
 	 * Invoca o metodo setXxxx para o objeto e atributo informados.<br>
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @param Object o - o objeto a invocar o metodo set
 	 * @param String atributo - o atributo cujo metodo set será invocado
 	 * @param Object[] objParams - um array de objetos com os parametros do setter
 	 * @return Object
 	 * @throws ECARException
 	 */
 	public static Object invocaSet(Object o, String atributo, Object[] objParams) throws ECARException {
 	    String nomeSetter = "set" + primeiraLetraToUpperCase(atributo);
         try {
             /* supoe que existe apenas um unico metodo com esse nome, portanto passa null no array
              * de classes do getMethod
              */
             return o.getClass().getMethod(nomeSetter, new Class[]{}).invoke(o, objParams);
         } catch (IllegalArgumentException e) {
             throw new ECARException("erro.exception");
         } catch (SecurityException e) {
             throw new ECARException("erro.exception");
         } catch (IllegalAccessException e) {
             throw new ECARException("erro.exception");
         } catch (InvocationTargetException e) {
            throw new ECARException("erro.exception");
         } catch (NoSuchMethodException e) {
             throw new ECARException("erro.exception");
         }
 	}
 		
 	/**
 	 * Retorna a String informada como parâmetro modificando sua primeira letra pra letra maiúscula.<br>
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @param String string  - a String a ser modificada
 	 * @return String - a string modificada
 	 */
 	public static String primeiraLetraToUpperCase(String string){
 	    return string.substring(0,1).toUpperCase().concat(string.substring(1));
 	}
 
 	/**
 	 * Retorna a String informada como parâmetro com a primeira letra em maiúscula e o restante minúscula.<br>
 	 * 
 	 * @author aleixo
 	 * @since 12/07/2007
 	 * @param string
 	 * @return String
 	 */
 	public static String soPrimeiraLetraToUpperCase(String string){
 		return primeiraLetraToUpperCase(string.toLowerCase());
 	}
 	
 	/**
 	 * Troca todas as primeiras letras de uma string para maíscula.<br>
 	 * Exemplos:<br>
 	 * String - Retorno<br>
 	 * "TEXTO DE TESTE" - Texto de Teste<br>
 	 * "texto de teste" - Texto de Teste<br>
 	 * 
 	 * @author aleixo
 	 * @since 17/07/2007
 	 * @param string
 	 * @return String
 	 */
     public static String todasPrimeirasLetrasToUpperCase(String string){
     	if(string == null || (string != null && "".equals(string.trim()))){
     		return "";
     	}
     	
     	string = string.trim().toLowerCase().replaceAll("\"", "");
 	    	
     	StringBuilder stringModificada = new StringBuilder();
     	String[] temp = string.split(" ");
     	
     	for(int i = 0; i < temp.length; i++){
     		String aux = temp[i].trim();
     		if("".equals(aux))
     			continue;
     		
     		if(!"de".equals(temp[i]) &&
     		   !"da".equals(temp[i]) &&		
     		   !"das".equals(temp[i]) &&		
     		   !"do".equals(temp[i]) &&		
     		   !"dos".equals(temp[i]) &&		
     		   !"em".equals(temp[i]) &&		
     		   !"no".equals(temp[i]) &&		
     		   !"na".equals(temp[i]) && 		
     		   !"nos".equals(temp[i]) &&
     		   !"nas".equals(temp[i]) &&		
     		   !"a".equals(temp[i]) &&		
     		   !"e".equals(temp[i]) &&		
     		   !"i".equals(temp[i]) &&		
     		   !"o".equals(temp[i]) &&		
     		   !"u".equals(temp[i]) &&		
     		   !"com".equals(temp[i]) &&		
     		   !"sem".equals(temp[i])		
     		){
     			aux = primeiraLetraToUpperCase(aux);
     		}
     		
     		stringModificada.append(aux).append(" ");
     	}
     	return stringModificada.toString();
     }
 
     /**
      * Remove os espaços que estão sobrando em uma string.<br>
      * 
      * @author aleixo
      * @since 30/08/2007
      * @param string
      * @return
      */
     public static String removeEspacosDuplicados(String string){
     	if(string == null || (string != null && "".equals(string.trim()))){
     		return "";
     	}
     	
     	StringBuilder stringModificada = new StringBuilder();
     	String[] temp = string.split(" ");
     	
     	for(int i = 0; i < temp.length; i++){
     		String aux = temp[i].trim();
     		if("".equals(aux))
     			continue;
     		
     		stringModificada.append(aux).append(" ");
     	}
     	
     	return stringModificada.toString().trim();
     }
 	
 	/**
 	 * Retorna se um determinado valorReferência está contido no intervalo entre
 	 * outros dois valores (valor1 e valor2).<br>
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @param int valorReferencia
 	 * @param int valor1
 	 * @param int valor2
 	 * @return boolean
 	 */
 
 	public static boolean entre(int valorReferencia, int valor1, int valor2) 
 	{
 		try{
 			if ((valor1 > valor2) 
 			  && (valorReferencia < valor1)	 
 			  && (valorReferencia > valor2))
 				return true;
 			if ((valor2 > valor1)
 			 && (valorReferencia < valor2)	 
 			 && (valorReferencia > valor1))
 				return true;		
 			return false;
 			}catch (NumberFormatException e){
 				return false;
 		}
 		
 	}
 	
 	/**
 	 * Retorna se um determinado valorReferência está contido no intervalo entre
 	 * outros dois valores (valor1 e valor2).<br>
 	 * Foi implementado para receber strings, pois existe a comparação com "inf" e "sup"
 	 * que indicam se um valor limite são todos os menores que o outro, ou todos os
 	 * maiores, respectivamente.<br>
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @param String valorReferencia
 	 * @param String valor1
 	 * @param String valor2
 	 * @return boolean
 	 */
 
 	public static boolean entre(String valorReferencia, String valor1, String valor2) 
 	{
 		try{
 			return (entre(Integer.parseInt(valorReferencia), valor1, valor2));
 		}catch (NumberFormatException e){
 			return false;
 		}
 		
 	}
 	
 	/**
 	 * Retorna se um determinado valorReferência está contido no intervalo entre
 	 * outros dois valores (valor1 e valor2).<br>
 	 * Foi implementado para receber strings, pois existe a comparação com "inf" e "sup"
 	 * que indicam se um valor limite são todos os menores que o outro, ou todos os
 	 * maiores, respectivamente.<br>
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @param int valorReferencia
 	 * @param String valor1
 	 * @param String valor2
 	 * @return boolean
 	 */
 
 	public static boolean entre(int valorReferencia, String valor1, String valor2)
 	{
 		try{
 			if (("sup".equals(valor1) && "inf".equals(valor2))
 			 || ("sup".equals(valor2) && "inf".equals(valor1)))
 				 	return true;			
 			if ("sup".equals(valor1))
 				if (valorReferencia > Integer.parseInt(valor2))
 					return true;
 			if ("inf".equals(valor1))
 				if (valorReferencia < Integer.parseInt(valor2))
 					return true;
 			if ("sup".equals(valor2))
 				if (valorReferencia > Integer.parseInt(valor1))
 					return true;
 			if ("inf".equals(valor2))
 				if (valorReferencia < Integer.parseInt(valor1))
 					return true;
 			if ((Integer.parseInt(valor1) > Integer.parseInt(valor2))
 			 && (valorReferencia < Integer.parseInt(valor1))	 
 			 && (valorReferencia > Integer.parseInt(valor2)))
 				return true;
 			if ((Integer.parseInt(valor2) > Integer.parseInt(valor1))
 			 && (valorReferencia < Integer.parseInt(valor2))	 
 			 && (valorReferencia > Integer.parseInt(valor1)))
 				return true;
 			return false;
 		} catch(NumberFormatException e) {
 			return false;
 		}
 	}
 	
 	
 	/**
 	 * Retorna uma substring  da posicao inicio até a posicao fim ou até o comprimento maximo da string.<br>
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @param String string
 	 * @param int inicio
 	 * @param int fim
 	 * @return String
 	 */
 	public static String substring(String string, int inicio, int fim) {
 	    return string.substring(inicio, Math.min(fim, string.length()));
 	}
 	
 	/**
 	 * Retorna um número com formatação Monetária.<br>
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @param double number
 	 * @return String
 	 */
 	public static String formataMoeda(double number){
 	    NumberFormat formatter = new DecimalFormat("###,###,##0.00");	    
 	    //NumberFormat fn = NumberFormat.getInstance(new Locale("pt", "BR"));	    
 	    return formatter.format(number);
 	}
 	
 	/**
 	 * Retorna um número com formatação de unidades de milhar e casas decimais.<br>
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @param double number
 	 * @return String
 	 */
 	public static String formataNumeroDecimal(double number){
 	    NumberFormat formatter = new DecimalFormat("###,###,##0.##");	    
 	    //NumberFormat fn = NumberFormat.getInstance(new Locale("pt", "BR"));	    
 	    return formatter.format(number);
 	}
 
 	public static String formataNumeroDecimal(Double number){
 	    NumberFormat formatter = new DecimalFormat("###,###,##0.##");	    
 	    //NumberFormat fn = NumberFormat.getInstance(new Locale("pt", "BR"));	    
 	    return formatter.format(number);
 	}
 	
 	/**
 	 * Retorna um número com formatação de unidades de milhar e 
 	 * casas decimais mas sem pontos e vírgulas, para valores de exportação.<br>
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @param double number
 	 * @param int tamanho
 	 * @return String
 	 */
 	public static String formataNumeroDecimalParaExportacao(double number, int tamanho){
 		String temp = formataMoeda(number);
 		String retorno = "";
 		for(int i = 0; i < temp.length(); i++){
 			if(temp.charAt(i) != '.' && temp.charAt(i) != ','){
 				retorno += temp.charAt(i);
 			}
 		}
 		int tam = retorno.length();
 		for(int i = tam; i < tamanho; i++){
 			retorno = " " + retorno;
 		}
 		return retorno;
 	}
 	
 	/**
 	 * Retorna um número com formatação sem casas decimais.<br>
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @param double number
 	 * @return String
 	 */
 	public static String formataNumeroSemDecimal(double number){
 	    NumberFormat formatter = new DecimalFormat("###,###,##0");	    
 	    //NumberFormat fn = NumberFormat.getInstance(new Locale("pt", "BR"));	    
 	    return formatter.format(number);
 	}
 
 	/**
 	 * Retorna um número com formatação das casas decimais (sem unidades de milhar).<br>
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @param double number
 	 * @return String
 	 */
 	public static String formataNumeroDecimalSemMilhar(double number){
 	    NumberFormat formatter = new DecimalFormat("#0.00");
 	    return formatter.format(number);
 	}
 	
 	/**
 	 * Retorna um número com formatação sem casas decimais <br>
 	 * 
 	 * @author luanaoliveira
 	 * @since N/C
 	 * @version N/C
 	 * @param double number
 	 * @return String
 	 */
 	public static String formataNumeroInteiroSemMilhar(double number){
 	    NumberFormat formatter = new DecimalFormat("#0");	    
 	    //NumberFormat fn = NumberFormat.getInstance(new Locale("pt", "BR"));	    
 	    return formatter.format(number);
 	}
 	
 	/**
 	 * formata o numero de acordo com o indQtd<br>
 	 * se for qtd: #000
 	 * se for valor: #0.00
 	 * 
 	 * @author luanaoliveira
 	 * @param number
 	 * @param indQtd
 	 * @return String com o numero formatado
 	 */
 	public static String formataQtdValor(double number, String indQtd){
 //		if(Dominios.IETTR_QUANTIDADE.equals(indQtd)){
 //			return(formataNumeroInteiroSemMilhar(number));
 //		}else{
 			return formataMoeda(number);
 //		}
 	}
 	
     /**
      * Função que retorna um número formatado com '.' para separação decimal e sem vírgulas.<br>
      * 
      * @author N/C
 	 * @since N/C
 	 * @version N/C
      * @param String original
      * @return String
      */
     public static String formataNumero(String original){       
         original = original.replaceAll("\\.","");
         original = original.replaceAll(",",".");
         return original;        
     }
     
     /**
      * Retorna formatado a String do tamanho do arquivo em KB ou MB.<br>  
      * 
      * @author N/C
 	 * @since N/C
 	 * @version N/C
      * @param Long bytes
      * @return String
      */
     public static String formataByte(Long bytes){
         double kb = converteParaKb(bytes.doubleValue());
         if(kb > 1000){
             return formataNumeroDecimal(converteParaMb(kb)) + " MB";
         } else
             return formataNumeroDecimal(kb) + " KB";
     }
     
     /**
      * Converte para KB.<br>
      * 
      * @author N/C
 	 * @since N/C
 	 * @version N/C
      * @param double bytes
      * @return double
      */
     public static double converteParaKb(double bytes){
         return bytes / new Double(1024).doubleValue();
     }
 
     /**
      * Converte para MB.<br>
      * 
      * @author N/C
 	 * @since N/C
 	 * @version N/C
      * @param double kBytes
      * @return double
      */
     public static double converteParaMb(double kBytes){
         return kBytes / new Double(1024).doubleValue();
     }
     
     
     /**
      * Retorna uma coleção com os elementos de col1 que estão em col2
      * (col1 e col2 devem ser listas de objetos da mesma classe).<br>
      * 
      * @author N/C
 	 * @since N/C
 	 * @version N/C
      * @param Collection col1
      * @param Collection col2
      * @return Collection
      */
     public static Collection intersecao(Collection col1, Collection col2){
         Collection a = new ArrayList(col1);
         Collection b = new ArrayList(col2);
         a.retainAll(b);
         return a;
     }
     
     /**
      * Retorna uma coleção com os elementos de col1 que não estão em col2 ( col1 - col2)
      * (col1 e col2 devem ser listas de objetos da mesma classe).<br>
      * 
      * @author N/C
 	 * @since N/C
 	 * @version N/C
      * @param Collection col1
      * @param Collection col2
      * @return Collection
      */
     public static Collection<Object> diferenca(Collection<Object> col1, Collection<Object> col2){
         Collection<Object> a = new ArrayList<Object>(col1);
         Collection<Object> b = new ArrayList<Object>(col2);
         a.removeAll(b);
         return a;
     } 
 	
     /**
      * Retira acentuacao.<br>
      * 
      * @author N/C
 	 * @since N/C
 	 * @version N/C
      * @param String string
      * @return String
      */
 	public static String retiraAcentuacao(String string){
 		return string.replace('à','a').
 					  replace('á','a').
 					  replace('é','e').					  
 					  replace('í','i').
 					  replace('ó','o').
 					  replace('ú','u').
 					  replace('ü','u');
 	}
 	
 	/**
 	 * Substitui espacos numa string por um caracter especificado.<br>
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @param String string
 	 * @param String caracter
 	 * @return String
 	 */
 	public static String trocarEspacoPorCaracter(String string, String caracter){
 		return string.replaceAll(" ", caracter);
 	}
 	
 	/**
 	 * Método para substituir na variável uma barra "\" e colocar "\\"<br>
 	 * 		Utilizado para passar para JavaScript<br>
 	 * Funcionamento: o java interpreta uma string "\\\\" como sendo "\",<br>
 	 * 			por isso a necessidade de tantas barras.<br>
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @param String texto
 	 * @return String
 	 */
 	public static String trocaBarraParaDuasBarras(String texto){
 		return texto.replaceAll("\\\\", "\\\\\\\\");
 	}
 	
 	/**
 	 * Calcula a média de valores Double contidos em uma lista.<br>
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @param Collection valores
 	 * @return double
 	 */
 	public static double calculaMediaValores(Collection<Double> valores){
 		double total = 0;
 		for (Double valor: valores) {
           total += valor.doubleValue();
 		}
 		return total / valores.size();
 	}
 
 	/**
 	 * Calcula a média de valores Integer contidos em uma lista.<br>
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @param Collection valores
 	 * @return double
 	 */
 	public static double calculaMediaValoresInteger(Collection<Double> valores){
 		double total = 0;
 		for (Double valor: valores) {
 			total += valor.intValue();
 		}
 		return total / valores.size();
 	}
     
 	/**
 	 * ????????
 	 * 
 	 * @author N/C
 	 * @since N/C 
 	 * @version N/C
 	 * @param String palavra
 	 * @param String original
 	 * @param String novo
 	 * @return String
 	 */
 	public static String trocar(String palavra, String original, String novo){
 		String retorno = "";
 		for(int i = 0; i< palavra.length(); i++){
 			if(palavra.charAt(i) == original.charAt(0)){
 				retorno += novo;
 			} else {
 				retorno += palavra.charAt(i);
 			}
 		}
 		return retorno;
 			
 	}
     
 	/**
 	* Enviar um e-mail no formato texto ou html.<br>
 	* 
 	* @author Cristiano
 	* @since 16/09/05
 	* @version N/C
 	* @param String assunto - Descrição do assunto para o e-mail
 	* @param String nomeRemetente - Nome do remetente
 	* @param String remetente - Remetente do e-mail
 	* @param String texto - Texto do conteúdo do e-mail
 	* @param String destinatarioPara - Destinatário(s) do e-mail (se tiver mais de um endereço separar entre vírgula)
 	* @param String destinatarioCc - Destinatário(s) que receberão cópia do e-mail (se tiver mais de um endereço separar entre vírgula)
 	* @param String destinatarioBcc - Destinatário(s) que receberão cópia oculta do e-mail (se tiver mais de um endereço separar entre vírgula)
 	* @throws AddressException - Endereço de e-mail inválido
 	* @throws MessagingException - Não foi possível enviar e-mail
 	* @throws Exception
 	*/
 	
 	public static void enviarEmail(String assunto, String nomeRemetente, String remetente,
 		String texto, String destinatarioPara, String destinatarioCc, String destinatarioBcc, UsuarioUsu usuario)
 		throws AddressException, MessagingException, Exception, ECARException {
 			ConfiguracaoCfg config = new ConfiguracaoDao(null).getConfiguracao();
     		if(config.getEmailServer() == null || "".equals(config.getEmailServer().trim())) {
     			throw new ECARException("erro.servidor.email.invalido");
     		}
     		
             Properties mailProps = new Properties();
             mailProps.put("mail.smtp.host", config.getEmailServer());
 
             Session mailSession = Session.getInstance(mailProps, null);
             mailSession.setDebug(false);
             Message email = new MimeMessage(mailSession);
             email.setRecipients( Message.RecipientType.TO, InternetAddress.parse(destinatarioPara));
             if (destinatarioCc != null && !"".equals(destinatarioCc.trim())) {
                 email.setRecipients( Message.RecipientType.CC, InternetAddress.parse(destinatarioCc));
             }
             if (destinatarioBcc != null && !"".equals(destinatarioBcc.trim())) {
                 email.setRecipients( Message.RecipientType.BCC, InternetAddress.parse(destinatarioBcc));
             }
             InternetAddress iAdd = new InternetAddress();
          
             if (remetente != null) iAdd.setAddress(remetente);
             if (nomeRemetente != null) iAdd.setPersonal(nomeRemetente);
             
             email.setFrom(iAdd);
             email.setSubject(assunto);
             email.setContent(texto, "text/html");
             
             Transport.send(email);
             
             if (usuario != null){
 				Email mailUsu = new Email(nomeRemetente, new Date(), assunto, destinatarioPara, destinatarioCc, destinatarioBcc, texto,"", usuario);
 				EmailDao emailDao = new EmailDao();
 				emailDao.salvar(mailUsu);
             }
     }
 	
 	/**
 	 * Normaliza Chars:<br>
 	 * Ex.:<br>
 	 * de '<' para "&lt;"<br>
 	 * 
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @param String s
 	 * @param StringBuffer str
 	 * @param int i
 	 */
 	public static void normalizeChars(String s, StringBuffer str, int i) {
 		final char ch = s.charAt(i);
 		switch (ch) {
 			case 60: // '<'
 				str.append("&lt;"); 
 				break;
 			case 62: // '>'
 				str.append("&gt;"); 
 				break;
 			case 38: // '&'
 				str.append("&amp;"); 
 				break;
 			case 34: // '"'
 				str.append("&quot;"); 
 				break;
 			case 39: // '''
 				str.append("&apos;"); 
 				break;
 			default:
 				str.append(ch);
 				break;
 		}
 	}
 
 	/**
 	 * Normaliza Enter.<br>
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @param String s
 	 * @param StringBuffer str
 	 * @param int i
 	 */
 	public static void normalizeEnter(String s, StringBuffer str, int i) {
 		final char ch = s.charAt(i);
 		switch (ch) {
 			case 10: // '\n'
 			case 13: // '\r'
 				//if(canonical) {
 				str.append("&#"); 
 				str.append(Integer.toString(ch));
 				str.append(';');
 		}
 	}
 
 	/** Normaliza o String para apresenta-lo em HTML sem retirar o retorno de linha.<br>
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @param String s
 	 * @return String
 	 */
 	public static String normalize(String s) {
 		StringBuffer str = new StringBuffer();
 		final int len = (s == null) ? 0 : s.length();
 		for (int i = 0; i < len; i++) {
 			normalizeChars(s, str, i);
 			normalizeEnter(s, str, i);
 		}
 		return str.toString();
 	}
 
 	/** Normaliza a quantidade de caracteres da quebra de linha.<br>
 	 * Ex.: o conteúdo de um texto tem 4060 caracteres.<br>
      *   	  A validação da pagina (permitir textos até 4000 caracteres) estava funcionando.<br>
      *   	  Quando entrava nesta função, toda quebra de linha era representada por 2 caracteres ("\r" e "\n"),
      *   		então um texto que tivesse 5 Enters, na validação em javascript seria cortado com 4000 caracteres,
      *   		mas teria 5 caracteres a mais daqueles que foram validados no javascript (5 "\r" a mais).<br>
      *   	  Como no java, o "\n" já representa uma quebra de linha, foi ignorado um eventual 
      *   		"\r\n" (retorno de linha, quebra de linha)<br>
      *   
      * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @param String s
 	 * @return String
      */
 	public static String normalizaQuebraDeLinha(String s) {
 		return s.replaceAll("\r\n","\n");
 	}
 	
 	/**
 	 * Normaliza uma string para apresentação em HTML.<br>
 	 * Troca "\n" por tag "&lt;br&gt;";
 	 * @param s
 	 * @return
 	 */
 	public static String normalizaQuebraDeLinhaHTML(String s){
 		return (s != null) ? (normalizaQuebraDeLinha(s.trim())).replaceAll("\n", "<br>") : "";
 	}
 	
 	/**
 	 * Normaliza caracter Marcador.<br>
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @param String s
 	 * @return String
 	 */
 	public static String normalizaCaracterMarcador(String s){
 		if(s != null && !"".equals(s))
 			return s.replace(Dominios.CARACTER_ESTRANHO_MARCADOR, "-").
 					 replace(Dominios.CARACTER_ESTRANHO_MARCADOR2, "-").
 					 replace(Dominios.CARACTER_ESTRANHO_ABREASPAS, "\"").
 					 replace(Dominios.CARACTER_ESTRANHO_FECHAASPAS, "\"").
 					 replace(Dominios.CARACTER_ESTRANHO_ABREASPAS_SIMPLES, "'").
 					 replace(Dominios.CARACTER_ESTRANHO_FECHAASPAS_SIMPLES, "'");
 		
 		return "";
 	}
 	
 	/**
 	 * Completa um número com zeros à esquerda.<br>
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @param Long numero
 	 * @param int tamanho
 	 * @return String
 	 */
 	public static String completarZerosEsquerda(Long numero, int tamanho){
 		
 		String mascara = "";
 		for(int i = 0; i < tamanho; i++){
 			mascara = "0" + mascara;
 		}
 
 		NumberFormat nf = new DecimalFormat(mascara);
 		
 		if(numero != null)
 			return nf.format(numero.longValue());
 		else
 			return mascara;
 	}
 	
 	/**
 	 * Completa uma string com caracteres até o tamanho, seguindo uma direcao.<br>
 	 *
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @param String string - string a ser completada
 	 * @param String caracter - Caracter para completar a string
 	 * @param int tamanho - Tamanho para completar a string com caracteres
 	 * @param String direcao - "D": Completa caracteres à direita, "E": Completa Caracteres à esquerda.
 	 * @return String
 	 */
 	public static String completarCaracteres(String string, String caracter, int tamanho, String direcao){
 		String retorno = string;
 		if(string.length() < tamanho){
 			if("E".equalsIgnoreCase(direcao)){
 				int tam = string.length();
 				for(int i = tam; i < tamanho; i++){
 					retorno = caracter + retorno;
 				}
 			}
 			if("D".equalsIgnoreCase(direcao)){
 				int tam = string.length();
 				for(int i = tam; i < tamanho; i++){
 					retorno = retorno + caracter;
 				}
 			}
 		}
 		return retorno;
 	}
 
 	/**
 	 * Retorna apenas o nome do arquivo, de acordo com a string do caminho completo ou relativo
 	 * informado como parâmetro do método.<br>
 	 * 
 	 * @author rogerio
 	 * @since 0.1, 06/03/2007
 	 * @version 0.1, 06/03/2007
 	 * @param String path
 	 * @return String
 	 */
 	public static String getNomeArquivo(String path) {
 		String nome = null;
 		
 		if( path != null ) {
 			if( path.lastIndexOf("/") != -1 ) 
 				nome = path.substring(path.lastIndexOf("/")+1);  // windows
 			else if( path.lastIndexOf("\\") != -1 )
 				nome = path.substring(path.lastIndexOf("\\")+1); // linux
 			else
 				nome = path;
 		}
 		
 		return nome;
 	} // fim getNomeArquivo
 	
 	/**
 	 * Retorna a tag usada para mostrar a imagem e a dica para a estrutura de telas do sistema. <br>
 	 * @author rogerio
 	 * @since 0.1, 22/03/2007
 	 * @version 0.1, 22/03/2007
 	 * @param nome - nome do atributo
 	 * @param contexto - conexto da aplicação
 	 * @param dica - texto usado no tooltip
 	 * @return String
 	 */
 	public static String getTagDica(String nome, String contexto, String dica) {
 		StringBuffer s = new StringBuffer("&nbsp;&nbsp;") ;
 
 		// Por Rogério. (05/04/2007. Mantis #9612.
 		// Bloco colocado dentro do TRY para tratar um possível retorno de erro na codificação da dica para ASCII.
 		// Na realidade nenhum erro é retornado para evitar problemas na compilação com o JSP.
 		try {
 	    	s.append("<label class=\"dica\" onmouseover=\"javascript:viewFieldTip(this, '"+nome+"SPAN');\"  onmouseout=\"javascript:noViewFieldTip('"+nome+"SPAN');\" >");
 	    	s.append("<img src=\""+contexto+"/images/dica.png\" align=\"absmiddle\" border=\"0\" onclick=\"javascript:viewFieldTipPopUp(\'" + URLEncoder.encode(dica, "ISO-8859-1") + "\')\" >" );
 	    	s.append("<span id=\""+nome+"SPAN\">" + dica + "</span></label>");
 		} catch (Exception e) {
 			// Ignora um retorno de erro, evitando problemas de compilação com a JSP.
 		}
 	
     	return s.toString();
 	} // fim getTagDica
 	
 	/**
 	 * 
 	 * @param nome - nome do atributo
 	 * @param contexto - 
 	 * @param urlImagem
 	 * @param dica
 	 * @return
 	 */
 	public static String getTagDicaComImagemParecer(String nome, String contexto, String urlImagem, String dica) {
 		StringBuffer s = new StringBuffer("&nbsp;&nbsp;") ;
 
 		// Por Rogério. (05/04/2007. Mantis #9612.
 		// Bloco colocado dentro do TRY para tratar um possível retorno de erro na codificação da dica para ASCII.
 		// Na realidade nenhum erro é retornado para evitar problemas na compilação com o JSP.
 		try {
 	    	s.append("<label class=\"dica\" onmouseover=\"javascript:viewFieldTip(this, '"+nome+"SPAN');\"  onmouseout=\"javascript:noViewFieldTip('"+nome+"SPAN');\" >");
 	    	if(urlImagem.equals(contexto))
 	    		s.append("<img src=\""+urlImagem+"/images/dica.png\" align=\"absmiddle\" border=\"0\"  onclick=\"javascript:viewFieldTipPopUp(\'" + URLEncoder.encode(dica, "ISO-8859-1") + "\')\" >" );
 	    	else 
 	    		s.append("<img src=\""+urlImagem+"\" align=\"absmiddle\" border=\"0\" style=\"width:16px;height:16px;\" onclick=\"javascript:viewFieldTipPopUp(\'" + URLEncoder.encode(dica, "ISO-8859-1") + "\')\" >" );
 	    	
 	    	s.append("<span id=\""+nome+"SPAN\">" + dica + "</span></label>");
 		} catch (Exception e) {
 			// Ignora um retorno de erro, evitando problemas de compilação com a JSP.
 		}
 	
     	return s.toString();
 	} // fim getTagDica
 
 	
 	
 	
 	/**
 	 * Retorna a tag usada para mostrar a imagem e a dica para a estrutura de telas do sistema. <br>
 	 * @author rogerio
 	 * @since 0.1, 22/03/2007
 	 * @version 0.1, 22/03/2007
 	 * @param nome - nome do atributo
 	 * @param contexto - conexto da aplicação
 	 * @param dica - texto usado no tooltip
 	 * @return String
 	 */
 	public static String getTagDica(String nome, String contexto, String urlImagem, String dica) {
 		StringBuffer s = new StringBuffer("&nbsp;&nbsp;") ;
 
 		// Por Rogério. (05/04/2007. Mantis #9612.
 		// Bloco colocado dentro do TRY para tratar um possível retorno de erro na codificação da dica para ASCII.
 		// Na realidade nenhum erro é retornado para evitar problemas na compilação com o JSP.
 		try {
 	    	s.append("<label class=\"dica\" onmouseover=\"javascript:viewFieldTip(this, '"+nome+"SPAN');\"  onmouseout=\"javascript:noViewFieldTip('"+nome+"SPAN');\" >");
 	    	if(contexto==null ||contexto.equals("") )
 	    		s.append("<img src=\""+urlImagem+"\" align=\"absmiddle\" border=\"0\" onclick=\"javascript:viewFieldTipPopUp(\'" + URLEncoder.encode(dica, "ISO-8859-1") + "\')\" >" );
 	    	else
 	    		s.append("<img src=\""+contexto+"/images/dica.png\" align=\"absmiddle\" border=\"0\" onclick=\"javascript:viewFieldTipPopUp(\'" + URLEncoder.encode(dica, "ISO-8859-1") + "\')\" >" );
 	    	s.append("<span id=\""+nome+"SPAN\">" + dica + "</span></label>");
 		} catch (Exception e) {
 			// Ignora um retorno de erro, evitando problemas de compilação com a JSP.
 		}
 	
     	return s.toString();
 	} // fim getTagDica
 
 	/* -- 
 	 * Métodos utilizados para contornar o problema com o https no e-CAR.
 	 * Dentro dos servlets dos relatórios, em cada local onde é realizada uma chamada a uma imagem, faz-se necessário chamar 
 	 *  o método "Util.liberarImagem(String imagePath);". Dessa forma a imagem será exibida no relatório quando o e-CAR estiver 
 	 *  sendo utilizado sob o protocolo SSL.
 	 * Estes métodos foram testados com a geração de relatórios em FOP.
 	 * -- */
 	
 	/**
 	 * Método para liberar as imagens utilizadas em relatórios sob protocolo SSL.<Br>
 	 * (Obtido em pesquisas na Internet).<br>
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @throws ECARException
 	 */
 	public static void liberarImagem() throws ECARException {
 		try {
 			trustAllHttpsCertificates();
 			
 			HostnameVerifier hv = new HostnameVerifier() {
 		        public boolean verify(String urlHostName, SSLSession session) {
 		            //System.out.println("Warning: URL Host: " + urlHostName + " vs. " + session.getPeerHost());
 		            return true;
 		        }
 		    };
 			
 			HttpsURLConnection.setDefaultHostnameVerifier(hv);
 			
 			//URL url = new URL("");
 			//BufferedReader in = new BufferedReader(new InputStreamReader(url.openStream()));
 
 	        //int buff;
 	        //while( (buff = in.read()) != -1 ) {}
 	        //in.close();
 
 		} catch (Exception e) {
             new ECARException("erro.liberar.imagem.ssl");
         }
 	}
 	
 	/**
 	 * Método para liberar as imagens utilizadas em relatórios sob protocolo SSL.<Br>
 	 * (Obtido em pesquisas na Internet).<br>
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 * @throws Exception
 	 */    
     private static void trustAllHttpsCertificates() throws Exception {
         //  Create a trust manager that does not validate certificate chains:
     	TrustManager[] trustAllCerts = new TrustManager[1];
         TrustManager tm = new miTM();
         trustAllCerts[0] = tm;
         SSLContext sc = SSLContext.getInstance("SSL");
         sc.init(null, trustAllCerts, null);
         HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
     }
 
 	/**
 	 * Método para liberar as imagens utilizadas em relatórios sob protocolo SSL.<br>
 	 * (Obtido em pesquisas na Internet).<br>
 	 * 
 	 * @author N/C
 	 * @since N/C
 	 * @version N/C
 	 */
     public static class miTM implements TrustManager, X509TrustManager {
 		public X509Certificate[] getAcceptedIssuers() { return null; }
 		public boolean isServerTrusted(X509Certificate[] certs) { return true; }	
 		public boolean isClientTrusted(X509Certificate[] certs) { return true; }
 		public void checkServerTrusted(X509Certificate[] certs, String authType) throws CertificateException { return; }
 		public void checkClientTrusted(X509Certificate[] certs, String authType) throws java.security.cert.CertificateException { return; }
 	}
     
     
 	/**
 	 * = (TipoFuncAcompTpfa) tipoFuncAcompDao.buscar(TipoFuncAcompTpfa.class, codTpfa);
 	 * 
 	 * @param cor
 	 * @param request
 	 * @return
 	 * @throws ECARException 
 	 */
 	public static String getURLImagemAcompanhamento(Cor cor, HttpServletRequest request , TipoFuncAcompTpfa funcao ) throws ECARException{
 		String url=null;
 		CorDao corDao = new CorDao(request);
 				
 		if(cor.getIndPosicoesGeraisCor().equals("S")){ 
 			cor.getCodCor();
 			
 		url = corDao.getImagemPersonalizada(cor, funcao, "D");
 		if( url != null ) { 
 			url=request.getContextPath()+"/DownloadFile?tipo=open&RemoteFile="+ url ;
 		} else {
 			if( cor.getCodCor() != null ) { 
 				url =request.getContextPath() + "/images/" + corDao.getImagemSinal(cor,funcao)+ "" ;
 			}
 		} 
 	}
 		
 		return url;
 	}
     
 	/**
 	 * Retira os códigos html do texto passado e retorna somente o texto
 	 * substituindo o <br> por " " e &nbps; por " "
 	 * 
 	 * @param strHtml
 	 * @return newString 
 	 */
 	public static String stripHTML(String strHtml){
 		String newString = new String();
 		if (strHtml != null){
 			newString = strHtml.replaceAll("<br>", " ").replaceAll("&nbsp;", " ").replaceAll("<.*?>", "").trim();
 		} 
 						
 		return newString;
 	}
 	
 	/**
 	 * Verifica se a string é um valor numérico
 	 */ 
 
 	public static boolean ehValor( String str) {
 		try {
 			Float.parseFloat(str);
 			return true;
 		} catch (NumberFormatException e) {
 			return false;
 		}
 	}
 	
 	/**
 	 * Faz a divisão entre os argumentos
 	 * 
 	 * @param dividendo
 	 * @param divisor
 	 * @return
 	 */
 	public static double trataDivisaoPorZero(double dividendo, double divisor){
 		if (divisor  == 0)
 			return 0;
 		else {
 			return dividendo/divisor;
 		}
 	}
 	
 
 } // fim class