/*
 * WordParser.java
 * Laboratorio #1 -- Jueves, 7 de Febrero 2001
 *
 * Universidad Galileo de Guatemala
 * Programacion III
 *
 * @author Juan Gabriel Del Cid Portillo, jdelcid@galileo.edu
 */ 

// Libreria donde se definen las clases de entrada/salida, como PrintWriter
import java.io.*;

// Libreria estandar del curso
import cs101.io.*;

// Libreria para el manejo de ventanas
import java.awt.*;

//Libreria para el manejo de eventos (click en un boton, etc)
import java.awt.event.*;

/** Esta clase evanta la ventana que interactua con el usuario
  * para leer archivos y separar sus palabras. Inicializa los
  * componentes necesarios y escucha las acciones ejecutadas
  * sobre alguno de sus botones.
  */
public class WordParser
 extends Frame
 implements ActionListener
{
   /* Los botones */
   private Button open, print;

   /* El lugar donde el usuario ingresa el nombre del archivo */
   private TextField txtFileName;

   /* Lugar donde desplegamos el contenido del archivo y
    * sus palabras ya separadas
    */
   private TextArea fileContent, tokens;

   /* Muestra el nombre del archivo actual en el frame */
   private Label currentFile;

   /** El constructor. No necesitamos hacer nada especial */
   public WordParser ()
   {
      super("Palabras y sus longitudes");
   }

   /** Se encarga de inicializar todos los componentes de la ventana */
   public void init ()
   {
      this.setLayout(new BorderLayout());
      Panel p;

      /* Agrega la parte superior de la ventana. Solo muestra el
       * nombre completo del archivo actual.
       */
      p = new Panel();
      this.currentFile = new Label("<none>                        ");
      p.add(new Label("Current File:"));
      p.add(this.currentFile);
      add(p,"North");

      /* Agrega el lugar para ingresar el nombre del archivo (txtFileName)
       * y los dos botones a la parte inferior de la ventana.
       */
      p = new Panel();
      this.open = new Button("Open");          // para abrir el archivo
      this.print = new Button("Print");        // para imprimir el archivo
      this.txtFileName = new TextField(20);    // para ingresar el nombre del arch.
      p.add(new Label("File:"));
      p.add(this.txtFileName);
      p.add(this.open);
      p.add(this.print);
      add(p,"South");

      /* Agrega las areas de texto. 'fileContent' nos sirve para mostrar el
       * archivo que cargamos, completo.  'tokens' es el area de texto donde
       * vamos a desplegar todas las palabras del archivo.
       */
      p = new Panel();
      p.setLayout(new GridLayout(1,2));
      this.fileContent = new TextArea("",30,70,TextArea.SCROLLBARS_BOTH);
      this.tokens = new TextArea("",30,70,TextArea.SCROLLBARS_BOTH);
      this.fileContent.setEditable(false);
      this.tokens.setEditable(false);
      p.add(this.fileContent);
      p.add(this.tokens);
      add(p,"Center");

      // ESTA ventana manejara los clicks sobre los botones
      open.addActionListener(this);
      print.addActionListener(this);

      // Para que se pueda cerrar la ventana
      addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent e) { dispose(); }
         public void windowClosed(WindowEvent e) { System.exit(0); }
      });
   }

   /** Metodo encargado de leer todas las lineas de un archivo y desglozar
     * sus palabras. El contenido del archivo se muestra en el area de
     * texto (TextArea) 'fileContent' y las palabras formateadas en el
     * area de texto (TextArea) 'tokens'.
     */
   public void loadFile (String fileName) throws Exception
   {
      /*
       * FALTA IMPLEMENTAR: lea el archivo especificado por 'fileName',
       * actualize las areas de texto 'fileContent' y 'tokens'
       * revise el metodo 'append(..)' de la clase TextArea.
       * Es saludable concatenar una nueva linea al agragar texto al
       * area de texto (osea "\n")
       *
       * NOTA: Las palabras que se agreguen a 'tokens' deben estar
       * formateadas de acuerdo al valor que devuelva 'formatWord(..)'
       */
   }

   /** Imprime 8 palabras por linea en el archivo especificado por 'fileName'.
     * Las palabras estan en el area de texto 'tokens'.
     */
   public void printToFile (String fileName) throws Exception
   {
      /* Puede utilizar 'p' para imprimir al archivo, mandando a llamar
       * el metodo 'p.println(..)', igual como cuando queremos imprimir
       * texto a la consola (pantalla).
       */
      PrintWriter p = new PrintWriter(new FileOutputStream(fileName), true);

      /*
       * FALTA IMPLEMENTAR: Obtenga las palabras del area de texto 'tokens'
       * utilizando 'tokens.getText()'. Esto les devuelve TODAS las palabras
       * que estan en el area de texto. El problema es que estan mezcladas
       * con el tamanio (por ejemplo "Koala" en realidad aparece como
       * "Koala -> 5". Y si esto fuera poco, estan mezcladas con caracteres
       * de nueva linea ("\n"), porque asi lo agregaron a 'tokens', remember?
       *
       * NOTA: Todo esto se resuelve con el metodo '~~~.indexOf(..)' y
       * '~~~.substring(..)' de la clase String.
       */

       // Cierra el archivo de impresion.
       p.close();
   }

   /*
    * FALTA IMPLEMENTAR: agregue un metodo 'isFileLoaded()' que devuelva
    * verdadero si hay algun archivo cargado y falso de lo contrario.
    * asuma que no hay archivo cargado si la etiqueta 'currentFile'
    * contiene la hilera "<none>" en las primeras 6 letras de su texto.
    */

   /*
    * FALTA IMPLEMENTAR: agregue un metodo 'formatWord(..)' que reciba
    * una palabra como hilera de caracteres (String) y devuelva una
    * palabra (tambien como String) igual que la primera, sin espacios
    * al principio ni al final de la palabra (vea el metodo ~~~.trim() de
    * la clase String), la primer letra en mayusculas y el resto en
    * minusculas. Concatene al final de la palabra la hilera: " -> "
    * (un espacio, guion, mayor que, espacio) y luego la longitud de la
    * palabra. Ej: si recibe la palabra "kOaLA", devolvera: "Koala -> 5"
    */

   /** Se manda a llamar cuando presionamos un boton. */
   public void actionPerformed (ActionEvent evt)
   {
      Object src = evt.getSource();
      if (src.equals(open)) {

         // El try esta aqui por si levanta una excepcion el metodo.
         try
         {
            /*
             * FALTA IMPLEMENTAR: mande a llamar el metodo loadFile(..).
             * Debe mandar como argumento el nombre del archivo que
             * ingreso el usuario en 'txtFileName'.
             *
             * OJO: No puede cargar un archivo si no hay texto en 'txtFileName'!
             * Debe verificar esto comparando el texto de 'txtFileName' con
             * la hilera vacia "", o verificando si la longitud del texto
             * es cero.
             */
         }
         catch (Exception e)
         {
            Console.println("!!! ERROR con el archivo !!!");
            Console.println(e.toString());
         }

      } else if (src.equals(print)) {

         // El try esta ahi por si levanta una excepcion el metodo.
         try
         {

            /*
             * FALTA IMPLEMENTAR: mande a llamar el metodo pritnToFile(..)
             * Debe mandar como argumento el nombre del archivo 'actual'
             * (no el que aparaece actualmente en 'txtFileName').
             * Tambien debe concatenar la extension '.wdc' al final de este
             * nombre. (ej. si el archivo actual es: "hola.txt" debe mandar
             * como argumento "hola.txt.wdc"
             *
             * OJO: No puede imprimir un archivo si no hay archivo actual!
             * Debe verificar esto mandando a llamar 'isFileLoaded()'. Este
             * ultimo metodo lo debe declarar e implementar usted mismo.
             */
         }
         catch (Exception e)
         {
            Console.println("!!! ERROR con el archivo !!!");
            Console.println(e.toString());
         }

      } else {
         System.out.println("Algo anda mal!");
         System.out.print("Se mando a llamar actionPerformed ");
         System.out.print("con ninguno de los botones!");
      }
   }

   /** El punto estandar de entrada a un programa de Java */
   public static void main (String []args)
   {
      WordParser df = new WordParser();
      df.setSize(700,200);
      df.init();
      df.show();
   }
}