//Title:        gramatica.java
//Version:      1.0
//Copyright:
//Author:       ELENA ARREGUI
//              MARIANO MEDIAVILLA
//              RAQUEL MIGUEL
//Asignatura:   ISBC
//Description:  realiza el analisis de la frase que le pasa ventana.java



package isbc;

import java.util.Hashtable;
import java.io.*;
import java.util.*;

public class gramatica {

  public final static int NOM=1;
  public final static int ADJ=2;
  public final static int ART=3;
  public final static int PREP=4;
  public final static int VB=5;
  public final static int ADV=6;
  public final static int CONJ=7;
  public final static int PRON=8;

  private  String v_palabras[] = null;
  private  Integer v_tipos[] = null;
  private java.util.Hashtable tabla = null;



  public gramatica() {
         tabla = new java.util.Hashtable(500);
  }

  public java.util.Hashtable gettabla() {
    return tabla;
  }


  public void cargar_palabras() {
  //Carga las palabras posibles con el tipo correspondiente en la tabla hash
     for (int i=0; i<p_count; i++) {
            tabla.put(p_words[i].toLowerCase(),new Integer(p_type[i]));
     }
  }

  private int palabras(String s){
    int num_palabra = 0;

   v_palabras = new String[20];
   v_palabras[num_palabra] = new String("");

    for(int i = 0; i < s.length(); i++){
       if ( s.charAt(i) == ' ' ){
        num_palabra ++;
        v_palabras[num_palabra] = new String("");
       }
       else{
        v_palabras[num_palabra] = v_palabras[num_palabra].concat(new Character(s.charAt(i)).toString());
        if (i==s.length()-1)  num_palabra++;
       }
    }
    return (num_palabra);
  }

  private int tipos(int num_pal){
  // cargar en el vector v_tipos los tipos de las palabras a almacenar
    v_tipos = new Integer[20];

    for(int i = 0; i < num_pal; i++){
          if (tabla.get(v_palabras[i])!= null)
            v_tipos[i] = new Integer(tabla.get(v_palabras[i]).toString());
          else
            return(-1);
    }
    return (1);
  }


  private parser parseV(int indice, int num_pal){
   //funcion que comprueba si es un verbo y devuelve la palabra clave
  //que identifica al verbo y el indice hasta el analizado

    parser p = new parser();
    if(indice<num_pal){

      if ( !v_tipos[indice].equals(new Integer(5)) ) // 5 => VERBO
      {    //Si no es un verbo devolvemos -1
        p.indice = -1;
        p.clave = "";
        return(p);
      }
      else{
        p.indice = indice + 1;
        p.clave = v_palabras[indice] ;
        return(p);

      }
    }
    p.indice = -1;
    p.clave = "";
    return(p);
}
/***************************************************/
  private parser parseN(int indice, int num_pal)
  {
  // Analiza la parte del CD correspodiente a: (ART bloque)* NOMBRE
  parser p = new parser();
  p.indice = -1;
  p.clave = "";

    if (indice  < num_pal){
      if (v_tipos[indice].equals(new Integer(3))&&((indice+1)<=num_pal))
      { // 3 => ARTICULO
        if (( v_palabras[indice+1].equals("bloque")&&(indice+2)<= num_pal))
        {
          if ((v_palabras[indice+2].equals("a"))||
              (v_palabras[indice+2].equals("b"))||
              (v_palabras[indice+2].equals("c")))
          {
            p.indice = indice +3;
            p.clave = v_palabras[indice+2];
            return(p);
          }//del if a,b,c,d
          else{  //no es el bloque a,b,c,d
            p.indice = -1;
            p.clave = "";
            return(p);
          } //del else que no es bloque a,b,c,d
        }//del if de bloque
        else{ //no es bloque
          if( ((indice+1)<=num_pal)&&
              (v_palabras[indice+1].equals("suelo")||v_palabras[indice+1].equals("mesa")))
          {
            p.indice = indice +2;
            p.clave = "suelo";
            return(p);
          } //del if de suelo o mesa
          else{ // ARTICULO seguido de algo distinto de bloque, mesa o suelo=>ERROR
            p.indice = -1;
            p.clave = "";
            return(p);
          }
        }//del else que no es bloque
      } //del if de es articulo
      else{    //tenemos directamente en el nombre del bloque
        if ((v_palabras[indice].equals("a"))||
              (v_palabras[indice].equals("b"))||
              (v_palabras[indice].equals("c")))
        {
          p.indice = indice +1;
          p.clave = v_palabras[indice];
          return(p);
        }
        else{  //no es el bloque a,b,c,d*/
          if((v_palabras[indice].equals("suelo"))||(v_palabras[indice].equals("mesa"))) {
            p.indice = indice + 1;
            p.clave = "suelo";
          }
          else{
            p.indice = -1;
            p.clave = "";
          }
          return(p);
        }
      }   //del else del articulo

  }// if(indice<=num_pal)*/
  p.indice = -1;
  p.clave = "";
  return(p);
}//de la funcion

/**********************************************************************/

  private parser parseP(int indice,int num_pal)
  {
  // reconoce la parte de la frase: sobre (ART bloque)* NOMBRE
   parser p = new parser();
   p.indice = -1;
   p.clave = "";

    if (indice + 1 < num_pal)
    {
      if(v_tipos[indice].equals(new Integer(4)))
      {
     // 4 => PREPOSICION
        p = parseN(indice +1, num_pal);
        if(p.indice == -1)
        {
          p.clave = "";
          p.indice = -1;
          return(p);
        }
        else
        {
       //la palabra clave es la devuelta por parseN()
          return(p);
        }
      }//del if es preposicion
      else{
      //La siguiente palabra es distinta de preposicion
        p.clave = "";
        p.indice = -1;
        return(p);
      }
  }// del if indice < num_pal
 return(p);  //devolvemos -1 y "" que es lo que esta inicializado
}

/**************************************************************/
    private String frase(int num_pal)
  {
    parser pV = new parser();
    parser pN = new parser();
    parser pP = new parser();

    pV=parseV(0, num_pal);
    if (pV.indice == -1){   //no comienza por verbo.
      pN = parseN(0, num_pal);
      if (pN.indice == -1){ //no comienza por frase nominal
        return "";
      }
      else{ //comienza por frase nominal    Ej:Bloque A sobre B
        pP = parseP(pN.indice,num_pal);
        if (pP.indice == -1) {// no es PN -> PP
          return "";
        }
        else  // PN -> PP
          return("(assert (objetivo (objeto-debajo "+pP.clave.toUpperCase()+") (objeto-encima " +pN.clave.toUpperCase()+")))");
      }
    }
    else{ //comienza por verbo
      pN=parseN(pV.indice,num_pal);
      if (pN.indice == -1){
          return "";
      }
      else{ // pV -> pN
         pP=parseP(pN.indice,num_pal);

        if (pP.indice == -1){
            return "";
       }
        else{   //pV->pN->pP
            return("(assert (objetivo (objeto-debajo "+pP.clave.toUpperCase()+") (objeto-encima " +pN.clave.toUpperCase()+")))");
        }
      }
    }//del else comienza con verbo
}//de la funcion

  public String get_sentencia(String s){
  int num_pal;
    cargar_palabras();

    num_pal = this.palabras(s.toLowerCase()); //obtenemos vector palabras en v_palabras
    if (this.tipos(num_pal)==-1)
      return("");
    return (frase(num_pal));
 }




  static final String [] p_words = {
  "poner","pon","apilar","apila","bloque","a","b","c","suelo","mesa","sobre","en","el","la"
  };
  static final short [] p_type = {
  5,5,5,5,1,1,1,1,1,1,4,4,3,3
  };
   int p_count = 14;
}