// Scanner <- java.util
// Archivos -> nombre (String),
//			File, BufferedReader, FileReader
// 			PrintWriter, FileWriter <- java.io
// LinkedList <- java.util
// Buscar y reemplazar -> Pendiente

import java.util.*;
import java.util.regex.*;
import java.io.*;

/**
 * Proyecto extra: Mini Editor
 * Fecha entrega: Final de semestre
 *
 * Programa que simula un editor de texto a traves de una lista
 * doblemente ligada
 * Con este proyecto reforzaremos los conocimientos de:
 * - Tomar informacion por teclado.
 * - Lectura y Escritura de archivos.
 * - Manejo de listas.
 * - Manejo de expresiones regulares para la busqueda y reemplazo.
 *
 * El editor sera capaz de:
 * 0) Salir
 * 1) Insertar
 * 2) Editar
 * 3) Borrar
 * 4) Seleccionar
 * 5) Copiar
 * 6) Pegar
 * 7) Cortar
 * 8) Buscar
 * 9) Reemplazar
 * 10) Leer/Mostrar
 * 11) Guardar
 *
 * Prof. Antonio Carrillo Ledesma.
 * Ayudante 1: Diego Alberto Magallanes Ramirez.
 * Ayudante 2: Adriana Esmeralda Corona Mundo.
 *
 * @version 1.0.0
*/
public class Editor {

   // Atributos:

   // Nombre del archivo que vamos a leer.
   private String nombreArchivo;
   // Lista donde almacenaremos el texto.
   private List<String> lista;
   // Lista auxiliar para copiar.
   private List<String> copia;

   // Constructores:

   /**
    * Construye una lista vacia e inicializa el nombre del archivo.
   */
   public Editor() {
      nombreArchivo = "SinNombre";
      lista = new LinkedList<String>();
      copia = null;
   }

   /**
    * Construye una lista vacia e inicializa el nombre del archivo con
    * la cadena pasada como parametro.
    *
    * @param nombreArchivo El nombre del archivo que vamos a leer.
   */
   public Editor(String nombreArchivo) {
      this.nombreArchivo = nombreArchivo;
      lista = new LinkedList<String>();
      copia = null;
   }

   // Metodos:

   /**
    * Muestra el menu de opciones disponibles para trabajar.
   */
   public void visualizaMenu() {
      System.out.println("");
      System.out.println("Elige una opcion:");
      System.out.println("0) Salir");
      System.out.println("1) Insertar");
      System.out.println("2) Editar");
      System.out.println("3) Borrar");
      System.out.println("4) Seleccionar");
      System.out.println("5) Copiar");
      System.out.println("6) Pegar");
      System.out.println("7) Cortar");
      System.out.println("8) Buscar");
      System.out.println("9) Reemplazar");
      System.out.println("10) Leer/Mostrar");
      System.out.println("11) Guardar");
      System.out.println("");
   }

   /**
    * Regresa el numero total de lineas dentro de la lista.
    * @return El numero de lineas.
   */
   public int totalLineas() {
      return lista.size();
   }

   /**
    * Lee el archivo deseado, ademas de mostrar el texto, lo va guardando
    * dentro de la lista.
   */
   public void leerArchivo() {
      // Archivo
      File file = null;
      // Lector
      FileReader fr = null;
      // Canal de informacion
      BufferedReader br = null;

      try {
         // Apertura del fichero y creacion de BufferedReader para poder
         // hacer una lectura comoda (disponer del metodo readLine()).
         file = new File(nombreArchivo);
         fr = new FileReader(file);
         br = new BufferedReader(fr);

         System.out.println("\nAbriendo... " + nombreArchivo + "\n");

         // Empezamos a leer el archivo:
         String linea = br.readLine();
         // Contador para el numero de lineas:
         int i = 1;

         System.out.println("---------------------------------------------------------------------------------------");

         while(linea != null) {
            // Agrega el texto a la lista:
            lista.add(linea);
            // Muestra el texto con numeracion:
            System.out.println(i + "\t" + linea);
            // Actualizamos la linea y el contador.
            linea = br.readLine();
            i++; // i = i + 1;
         }

         System.out.println("---------------------------------------------------------------------------------------");

      } catch(Exception e) {

         // ***********************************************************************************
         // ************************ QUE PASA SI NO EXISTE EL ARCHIVO. ************************
         // ********************************* DEBE CREARLO ************************************
         // ***********************************************************************************

         e.printStackTrace();

      } finally {
         // En el finally cerramos el fichero, para asegurarnos
         // que se cierra tanto si todo va bien como si salta
         // una excepcion.
         try {

            if(fr != null) {
               fr.close();
            }

         } catch (Exception e2) {

            e2.printStackTrace();

         }

      }
   }

   /**
    * Se encarga de agregar una nueva linea a la lista.
    * @param pos Indice donde se va a insertar la cadena.
    * @param cad Cadena que se va a insertar.
   */
   public void insertar(int pos, String cad) {
      // Si la posicion dada es mayor que el total de lineas del archivo, ent.
      // agregamos el texto al final del archivo.
      if(pos > totalLineas()) {
         lista.add(cad);
      } else {
         // E.O.C. Agregamos la cadena en la posicion dada. Disminuimos en una unidad
         // a la posicion porque el editor comienza la numeracion a partir de 1.
         lista.add(pos - 1, cad);
      }

      System.out.println("\n*** Se agrego el texto correctamente. ***");
   }

   /**
    " Se encarga de copiar las lineas de texto seleccionadas.
    * @param ini Indice del inicio de la copia.
    * @param fin Indice del fin de la copia.
   */
   public void copiar(int ini, int fin) {
      // Creamos una lista auxiliar que nos permitira guardar el texto copiado.
      copia = new LinkedList<String>();

      // Agregamos las lineas de texto seleccionadas a la lista copia.
      for(int i = ini - 1; i < fin; i++) {
         copia.add(lista.get(i));
      }

      System.out.println("\n*** Texto Copiado. ***");
   }

   /**
    * Pega el texto copiado en la linea indicada.
    * @param pos Linea donde se pegara el texto.
   */
   public void pegar(int pos) {
      // Verificamos que haya algo que copiar.
      if(copia != null) {
         int i;
         // Si da una posicion mayor al numero de lineas, entonces el texto
         // se pegara despues de la ultima linea.
         if(pos > totalLineas())
            i = totalLineas();
         else
            i = pos - 1;

         // Vamos agregando las lineas de texto copiadas a la lista original.
         for(String linea : copia) {
            lista.add(i, linea);
            i++;
         }

         System.out.println("\n*** Texto Pegado. ***");
      } else {
         System.out.println("\n*** No hay nada que pegar. ***");
      }
   }

   /**
    * Se encarga de mostrar el contenido de la lista NO del archivo.
    * Al mostrar el contenido tambien se muestra la numeracion comenzando desde 1 hasta N.
   */
   public void visualiza() {
      System.out.println("---------------------------------------------------------------------------------------");
      for(int i = 0; i < lista.size(); i++) {
         System.out.println((i + 1) + "\t" + lista.get(i));
      }
      System.out.println("---------------------------------------------------------------------------------------");
   }

   // ******************* MAIN *******************
   public static void main(String[] args) {

      Scanner teclado = new Scanner(System.in);
      Editor e = null;

      // Tendremos 2 opciones para pasar el archivo:
      // 1. Como argumento al ejecutar nuestro programa.
      // 2. Durante la ejecucion del programa.
      if(args.length > 0) {
         e = new Editor(args[0]);
      } else {
         System.out.println("Nombre del Archivo? ");
         String nombre = teclado.nextLine();
         // Creamos nuestro editor.
         e = new Editor(nombre);
      }

      // Abrimos, leemos y mostramos nuestro archivo.
      e.leerArchivo();

      // op - La opcion que escoga el usuario.
      // pos - Variable que usaremos para guardar el indice para insertar, editar o borrar una linea.
      // select_ i - Indice para empezar a seleccionar.
      // select_f - Indice para terminar de seleccionar.
      int op = 0, pos = 0;
      int select_i = 0, select_f = 0;

      do {
         e.visualizaMenu();
         op = Integer.parseInt(teclado.nextLine());

         switch(op) {
         // SALIR:
         case 0:
            System.out.println("\nBye!! :D");
            break;

         // INSERTAR:
         case 1:
            do {
               System.out.println("\nEn que linea quieres escribir? ");
               pos = Integer.parseInt(teclado.nextLine());

               // Si da una posicion mayor al numero total de lineas, el texto se
               // Agregara despues de la ultima linea.
               if(pos < 1)
                  System.out.println("\n*** Linea no encontrada. La numeracion inicia en 1. ***");
            } while(pos < 1);

            System.out.println("\nEscribe el texto a insertar:");
            String cad = teclado.nextLine();

            e.insertar(pos, cad);

            break;

         // EDITAR:
         case 2:
            // LES TOCA A USTEDES
            System.out.println("\n*** No disponible. ***");
            break;

         // BORRAR:
         case 3:
            // LES TOCA A USTEDES
            System.out.println("\n*** No disponible. ***");
            break;

         // SELECCIONAR:
         case 4:
            do {
               System.out.println("\nSeleccionar desde: ");
               select_i = Integer.parseInt(teclado.nextLine());

               if(select_i < 1 || select_i > e.totalLineas())
                  System.out.println("\n*** Linea no encontrada. El rango de seleccion es de 1 a " + e.totalLineas() + ". ***");
            } while(select_i < 1 || select_i > e.totalLineas());

            do {
               System.out.println("\nHasta: ");
               select_f = Integer.parseInt(teclado.nextLine());

               if(select_f <= 0 || select_f > e.totalLineas())
                  System.out.println("\n*** Linea no encontrada. El rango de seleccion es de 1 a " + e.totalLineas() + ". ***");
            } while(select_f <= 0 || select_f > e.totalLineas());

            // Si la linea donde termina la seccion es menor que la linea
            //  de inicio. Entonces hacemos un intercambio de valores.
            if(select_f < select_i) {
               int temp = select_i;
               select_i = select_f;
               select_f = temp;
            }

            break;

         // COPIAR:
         case 5:
            // Verificamos que ya haya seleccionado el texto.
            if(select_i == 0)
               System.out.println("\n*** Primero debes seleccionar el texto. ***");
            else
               e.copiar(select_i, select_f);

            break;

         // PEGAR:
         case 6:
            do {
               System.out.println("\nEn que linea quieres pegarlo?");
               pos = Integer.parseInt(teclado.nextLine());

               if(pos < 1)
                  System.out.println("\n*** Linea no encontrada. La numeracion inicia en 1. ***");
            } while(pos < 1);

            e.pegar(pos);

            break;

         // CORTAR:
         case 7:
            // LES TOCA A USTEDES
            System.out.println("\n*** No disponible. ***");
            break;

         // BUSCAR:
         case 8:
            System.out.println("\n*** No disponible. ***");
            break;

         // REEMPLAZAR:
         case 9:
            System.out.println("\n*** No disponible. ***");
            break;

         // LEER/MOSTRAR:
         case 10:
            e.visualiza();
            break;

         // GUARDAR:
         case 11:
            // LES TOCA A USTEDES.
            System.out.println("\n*** No disponible. ***");
            break;

         default:
            System.out.println("\n*** Opcion no valida. Vuelve a intentar. ***");
         }
      } while(op != 0);
   }
}