/*
    * Utilities.java
    *
    * Created on 28 de Março de 2007, 16:10
    *
    * To change this template, choose Tools | Template Manager
    * and open the template in the editor.
    */
   
  package tempcontroller.base;
  
  import java.io.BufferedInputStream;
  import java.io.BufferedOutputStream;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.ObjectInputStream;
  import java.io.ObjectOutputStream;
  import java.io.Serializable;
  import java.text.DecimalFormat;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  /**
   * Classe utilitária.
   */
  public class Utilities {
      /**
       * Um segundo em milisegundos.
       */
      public static final long SEGUNDO = 1000;
  
      /**
       * Um minuto em milisegundos.
       */
      public static final long MINUTO = SEGUNDO * 60;
      
      /**
       * Uma hora em milisegundos.
       */
      public static final long HORA = MINUTO * 60;
      
      
      /**
       * A instância atual desta classe.
       */
      private static Utilities singleton;
      
      /**
       * Grava um objeto serializável em um arquivo.
       * @param f Arquivo que será gravado.
       * @param obj Objeto serializável.
       * @throws IOException Caso haja algum erro de IO.
       */
      public void gravaSerializable(final File f, final Serializable obj)
      throws IOException {
          ObjectOutputStream oos = null;
          try {
              oos = new ObjectOutputStream(
                      new BufferedOutputStream(new FileOutputStream(f)));
              oos.writeObject(obj);
          } finally {
              if (oos != null) {
                  oos.close();
              }
          }
      }
      
      /**
       * Lê os objetos serializados dentro de um arquivo.
       * @param f Arquivo com o objeto gravado.
       * @return Objeto lido do arquivo.
       * @throws IOException Caso haja algum erro de IO.
       * @throws ClassNotFoundException Caso o arquivo não tenha
       * nenhuma classe gravada, ou a classe gravada não esteja no Classpath.
       */
      public Serializable leSerializable(final File f)
      throws IOException, ClassNotFoundException {
          ObjectInputStream ois = null;
          Serializable toReturn = null;
          try {
              ois = new ObjectInputStream(
                      new BufferedInputStream(new FileInputStream(f)));
              toReturn = (Serializable) ois.readObject();
              ois.close();
          } finally {
              if (ois != null) {
                  ois.close();
              }
          }
          
          return toReturn;
      }
      
      /**
       * Obtém uma instância desta classe.
       * Por padrão, esta instância é única.
       * @return Uma instância desta classe.
      */
     public static Utilities getUtilities() {
         synchronized (Utilities.class) {
             if (singleton == null) {
                 singleton = new Utilities();
             }
         }
         
         return singleton;
     }
     
     private static Pattern patternTemperatura = 
             Pattern.compile("(-?\\d*\\.?,?\\d*)?( +)?([CKF])?");
     private static DecimalFormat decimalFormat = 
             new DecimalFormat("###,###.#");
     public static final int KELVIN_DELTA = 273;
     public static final int KELVIN_LIMIAR = 200;
     
     public double parseTemperatura(String s) {
         double toReturn = Double.NaN;
         
         try {
             Matcher m = patternTemperatura.matcher(s);
             
             if(m.matches()) {
                 String parteDecimal = m.group(1);
                 
                 toReturn = decimalFormat.parse(s).doubleValue();
                 String indicadorEscala = m.group(3);
                 
                 if("C".equals(indicadorEscala)) {
                     toReturn = toReturn + KELVIN_DELTA;
                 }
             }
         } catch(Exception e) {}
         
         return toReturn;
     }
     
     public String formatTemperatura(final double temperatura) {
         if(Double.isNaN(temperatura)) {
             return "Ambiente";
         }
         
         StringBuilder builder = new StringBuilder();
         double auxTemperatura = temperatura;
         String indicadorEscala = " K";
         
         if(temperatura > KELVIN_LIMIAR) {
             auxTemperatura = temperatura - KELVIN_DELTA;
             indicadorEscala = " C";
         }
         
         builder.append(decimalFormat.format(auxTemperatura));
         builder.append(indicadorEscala);
         
         return builder.toString();
     }
     
     private static Pattern patternTempo = 
             Pattern.compile("(\\d\\d):(\\d\\d):(\\d\\d)");
     
     public long parseTempo(String s) {
         long toReturn = 0L;
         
         try {
             Matcher m = patternTempo.matcher(s);
             
             if(m.matches()) {
                 String horasStr = m.group(1);
                 String minutosStr = m.group(2);
                 String segundosStr = m.group(3);
                 int horas = Integer.parseInt(horasStr);
                 int minutos = Integer.parseInt(minutosStr);
                 int segundos = Integer.parseInt(segundosStr);
                 
                 toReturn = SEGUNDO * segundos + MINUTO * minutos + HORA * horas;
             }
         } catch(Exception e) {}
         
         return toReturn;
     }
     
     public String formatTempo(final long tempo) {
         if(tempo <= SEGUNDO) {
             return "00:00:00";
         }
         
         long tempoAux = tempo;
         long horas = tempoAux / HORA;
         tempoAux = tempoAux % HORA;
         long minutos = tempoAux / MINUTO;
         tempoAux = tempoAux % MINUTO;
         long segundos = tempoAux / SEGUNDO;
         
         StringBuilder builder = new StringBuilder();
         
         if(horas >= 10) {
             builder.append(horas);
         } else {
             builder.append('0');
             builder.append(horas);
         }
         
         builder.append(':');
         
         if(minutos >= 10) {
             builder.append(minutos);
         } else {
             builder.append('0');
             builder.append(minutos);
         }
         
         builder.append(':');
         
         if(segundos >= 10) {
             builder.append(segundos);
         } else {
             builder.append(0);
             builder.append(segundos);
         }
         
         return builder.toString();
     }
     
     public double fromCelsiusToKelvin(double celsius) {
         return celsius + KELVIN_DELTA;
     }
     
     public double fromKelvinToCelsius(double kelvin) {
         return kelvin - KELVIN_DELTA;
     }
 }