/*
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You may obtain a copy of the License at
 * http://www.gnu.org/licenses/gpl.txt
 *
 * The Initial Developer of the Original Code is David Moner
 * Portions created by the Initial Developer are Copyright (C) 2013 VeraTech for Health
 * Developer. All Rights Reserved.
 *
 * Contributors: part of the code is based in the ADL parser
 * implemented by Rong Chen (rong.acode@gmail.com), from ACODE HB, Sweden.
 *
 */

options
{
  STATIC = false;
  DEBUG_PARSER = false;
  DEBUG_TOKEN_MANAGER = false;
  DEBUG_LOOKAHEAD = false;

  LOOKAHEAD= 1;
  UNICODE_INPUT = true;
}

PARSER_BEGIN(BMMParser)
package es.veratech.linkehr.io.bmm;
import java.io.*;
import java.util.*;
import java.text.*;
import org.ehr.rm.openehr.support.basic.Interval;

/**
 * JavaCC grammar file for BMM
 *
 * Targeted BMM revision 2.0
 *
 * @author David Moner (damoca@veratech.es)
 * @version 1.0
 */
public class BMMParser
{
  /* static fields */
  private static final String CHARSET = "UTF-8";

  /* =======================  public constructors  ======================== */
  /* Constructor that takes file as input */
  public BMMParser(File file) throws IOException
  {
    this (new FileInputStream(file), CHARSET);
  }

  /* Constructor that takes string as input */
  public BMMParser(String value)
  {
    this (new BufferedReader(new StringReader(value)));
  }

  /* =========================  public interface ======================== */
  /* execute the parsing */
  public void parse() throws ParseException
  {
    bmm();
  }

  /* re-initial the parser */
  public void reInit(File file) throws IOException
  {
    ReInit(new FileInputStream(file), CHARSET);
  }

  /* re-initial the parser */
  public void reInit(InputStream input) throws IOException
  {
    ReInit(new BufferedInputStream(input));
  }
}

PARSER_END(BMMParser)

<* >
SKIP : /* WHITE SPACE */
{
  " "
| "\t"
| "\n"
| "\r"
| "\f"
| "\u00ef\u00bb\u00bf" /* UTF-8 Byte Order Mark */
| "\ufeff" /* UTF-16 Byte Order Mark */
}

<* >
SPECIAL_TOKEN : /* COMMENTS */
{
  < SINGLE_LINE_COMMENT : "--" (~[ "\n", "\r" ])* >
}


<* >
TOKEN [ IGNORE_CASE ] : /* KEYWORDS - Values */
{
  < SYM_TRUE : "true" >
| < SYM_FALSE : "false" >
}

<* >
TOKEN [ IGNORE_CASE ] : /* KEYWORDS - BMM HEADER*/
{
  < SYM_BMM_VERSION : "bmm_version" >
| < SYM_RM_PUBLISHER : "rm_publisher" >
| < SYM_RM_NAME : "schema_name" >
| < SYM_RM_RELEASE : "rm_release" >
| < SYM_SCHEMA_REVISION : "schema_revision" >
| < SYM_LIFECYCLE_STATE : "schema_lifecycle_state" >
| < SYM_SCHEMA_DESCRIPTION : "schema_description" >
| < SYM_INCLUDES : "includes" >
| < SYM_ID : "id" >
| < SYM_PARENT_CLASS : "archetype_parent_class" >
| < SYM_DATA_PARENT_CLASS : "archetype_data_value_parent_class" >
| < SYM_CLOSURE : "archetype_rm_closure_packages" >
| < SYM_PACKAGES : "packages" >
| < SYM_CLASSES : "classes" >
}

<* >
TOKEN [ IGNORE_CASE ] : /* KEYWORDS - BMM DEFINITION*/
{
  < SYM_CLASS_DEFINITION : "class_definitions" >
| < SYM_PRIMITIVE_TYPES : "primitive_types" >
| < SYM_NAME : "name" >
| < SYM_IS_MANDATORY : "is_mandatory" >
| < SYM_IS_INFRASTRUCTURE : "is_im_infrastructure" >
| < SYM_IS_RUNTIME : "is_im_runtime" >
| < SYM_IS_COMPUTED : "is_computed" >
| < SYM_IS_ABSTRACT : "is_abstract" >
| < SYM_ANCESTORS : "ancestors" >
| < SYM_PROPERTY_TYPE : "type" >
| < SYM_TYPE_DEF : "type_def" >
| < SYM_CONTAINER_TYPE : "container_type" >
| < SYM_PROPERTIES : "properties" >
| < SYM_SINGLE_PROPERTY : "P_BMM_SINGLE_PROPERTY" >
| < SYM_SINGLE_PROPERTY_OPEN : "P_BMM_SINGLE_PROPERTY_OPEN" >
| < SYM_CONTAINER_PROPERTY : "P_BMM_CONTAINER_PROPERTY" >
| < SYM_GENERIC_PROPERTY : "P_BMM_GENERIC_PROPERTY" >
| < SYM_GENERIC_PARAMETER : "generic_parameter_defs" >
| < SYM_CARDINALITY : "cardinality" >
| < SYM_CONFORMS : "conforms_to_type" >
| < SYM_ROOT_TYPE : "root_type" >
| < SYM_PARAMETER_TYPE : "generic_parameters" >
}


<* >
TOKEN : /* SYMBOLS - common */
{
  < SYM_MINUS : "-" >
| < SYM_L_PARENTHESIS : "(" >
| < SYM_R_PARENTHESIS : ")" >
| < SYM_L_BRACKET : "[" >
| < SYM_R_BRACKET : "]" > 
| < SYM_INTERVAL_DELIM : "|" >
| < SYM_EQ : "=" >
| < SYM_GE : ">=" >
| < SYM_LE : "<=" >
| < SYM_LT : "<" >
| < SYM_GT : ">" >
| < SYM_ELLIPSIS : ".." >
| < SYM_LIST_CONTINUE : "..." >
}

<* >
TOKEN : /* LOCAL TOKENS */
{
  < #DIG : [ "0"-"9" ] >
| 
  < #LET_DIG : [ "a"-"z", "A"-"Z", "0"-"9" ] >
}

/* -------------------- TOKEN - dADL & cADL ------------------------- */
<* >
TOKEN : /* VALUES - dADL & cADL */
{
  < V_INTEGER :
    (< DIG >)+
  | (< DIG >)
    {
      1, 3
    }
    (
      "," (< DIG >)
      {
        3
      }
    )+ >
| < V_REAL :
    (< DIG >)+ "./" ~[ ".", "0"-"9" ]
  | (< DIG >)+ "." (< DIG >)* [ "e", "E" ] ([ "+", "-" ])? (< DIG >)+
  | (< DIG >)* "." (< DIG >)+
    (
      [ "e", "E" ] ([ "+", "-" ])? (< DIG >)+
    )?
  | (< DIG >)
    {
      1, 3
    }
    (
      "_" (< DIG >)
      {
        3
      }
    )+
    "./" ~[ ".", "0"-"9" ]
  | (< DIG >)
    {
      1, 3
    }
    (
      "_" (< DIG >)
      {
        3
      }
    )*
    "."
    (
      (< DIG >)
      {
        1, 3
      }
      (
        "_" (< DIG >)
        {
          3
        }
      )*
    )?
    [ "e", "E" ] ([ "+", "-" ])? (< DIG >)
    {
      1, 3
    }
    (
      "_" (< DIG >)
      {
        3
      }
    )*
  |
    (
      (< DIG >)
      {
        1, 3
      }
      (
        "_" (< DIG >)
        {
          3
        }
      )*
    )?
    "." (< DIG >)
    {
      1, 3
    }
    (
      "_" (< DIG >)
      {
        3
      }
    )*
    (
      [ "e", "E" ] ([ "+", "-" ])? (< DIG >)
      {
        1, 3
      }
      (
        "_" (< DIG >)
        {
          3
        }
      )*
    )? >
| 
  < V_STRING :
    "\""
    (
      (
        "\\" (~[ "\"", "\n", "\\" ])*
      )
    |
      (
        "\\\"" (~[ "\"", "\n", "\\" ])*
      )
    |
      (
        "\\\\" (~[ "\"", "\n", "\\" ])*
      )
    |
      (
        "\n" ([ "\r", " ", "\t" ])*
      )
    | 
      (~[ "\\", "\n", "\"" ])*
    )*
    "\"" 
    >
| 
  < V_CHARACTER :
    "'" ~[ "\\", "\n", "'" ] "'"  | < CHAR_REF > >
| 
  < #CHAR_REF :
    "'&"
    (
      ([ "a"-"z", "A"-"Z" ])+
    | 
      "#"
      (
        ([ "0"-"9" ])+
      | "x" ([ "0"-"9", "a"-"f", "A"-"F" ])+
      )
    )
    ";'" >
}



/*****************************************
 * BMM LANGUAGE GRAMMAR                  *
 *****************************************/

/*
 Main method
*/
void bmm() :
{

  String id;
  String version;
  String parentClass;
}
{
  // BMM version
  version = bmm_version()

  // BMM schema identification
  id = bmm_schema_identification()

  // BMM schema documentation
  [ bmm_schema_documentation() ]

  // BMM inclusions
  [ bmm_inclusions() ]

  // Archetyping info
  [ parentClass = bmm_archetyping() ]

  // Packages
  [ bmm_packages() ]
  
  // Classes
  [ bmm_class_list() ]
   
  < EOF >
}


/*
 Parse BMM version
*/
String bmm_version() :
{
  String version = "";
}
{
  < SYM_BMM_VERSION > < SYM_EQ > < SYM_LT > version = string_value() < SYM_GT >

  {
    return version;
  }
}


/*
 Parse BMM sechema identification
*/
String bmm_schema_identification() :
{
  String schemaPublisher = "";
  String schemaName = "";
  String schemaRelease = "";
}
{
  < SYM_RM_PUBLISHER > < SYM_EQ > < SYM_LT > schemaPublisher = string_value() < SYM_GT >
  < SYM_RM_NAME > < SYM_EQ > < SYM_LT > schemaName = string_value() < SYM_GT >
  < SYM_RM_RELEASE > < SYM_EQ > < SYM_LT > schemaRelease = string_value() < SYM_GT >

  {
    return schemaPublisher + "_" + schemaName + "_" + schemaRelease;
  }
}


/*
 Parse BMM documentation
*/
void bmm_schema_documentation() :
{
}
{
  < SYM_SCHEMA_REVISION > < SYM_EQ > < SYM_LT > string_value() < SYM_GT >
  < SYM_LIFECYCLE_STATE > < SYM_EQ > < SYM_LT > string_value() < SYM_GT >
  < SYM_SCHEMA_DESCRIPTION > < SYM_EQ > < SYM_LT > string_value() < SYM_GT >
}


/*
 Parse BMM inclusions
*/
void bmm_inclusions() :
{
}
{
  < SYM_INCLUDES > < SYM_EQ > < SYM_LT >
  (
    < SYM_L_BRACKET > string_value() < SYM_R_BRACKET > < SYM_EQ > < SYM_LT >
      < SYM_ID > < SYM_EQ > < SYM_LT > string_value() < SYM_GT >
    < SYM_GT >
  )*
  < SYM_GT >
}


/*
 Parse BMM archetyping information
*/
String bmm_archetyping() :
{
  String parentClass = null;
  List closure = null;
}
{
  (
    < SYM_PARENT_CLASS > < SYM_EQ > < SYM_LT > parentClass = string_value() < SYM_GT >
  |
    < SYM_DATA_PARENT_CLASS > < SYM_EQ > < SYM_LT > parentClass = string_value() < SYM_GT >
  )
  [ < SYM_CLOSURE > < SYM_EQ > < SYM_LT > closure = string_list_value() < SYM_GT > ]

  {
    return parentClass;
  } 
}


/*
 Parse BMM packages
*/
void bmm_packages() :
{
}
{
  < SYM_PACKAGES > < SYM_EQ > < SYM_LT >
  (
    < SYM_L_BRACKET > string_value() < SYM_R_BRACKET > < SYM_EQ > < SYM_LT >
      < SYM_NAME > < SYM_EQ > < SYM_LT > string_value() < SYM_GT >
      [ < SYM_CLASSES > < SYM_EQ > < SYM_LT > string_list_value() < SYM_GT > ]

      [ bmm_packages() ]
      
    < SYM_GT >
  )*
  < SYM_GT >
}


/*
 Parse BMM class list
*/
void bmm_class_list() :
{
  String classInternalName;
  String className;
  List ancestors = null;
  HashMap<String,String> genericList = null;
  boolean isAbstract = false;
  boolean isGeneric = false;
}
{
  (
    < SYM_CLASS_DEFINITION > < SYM_EQ > < SYM_LT >
  |
    < SYM_PRIMITIVE_TYPES > < SYM_EQ > < SYM_LT >
  )
  
  (
    < SYM_L_BRACKET >
    classInternalName = string_value()
    < SYM_R_BRACKET > < SYM_EQ > < SYM_LT >
    {
      className = null;
      isAbstract = false;
      ancestors = null;
      genericList = null;
    }
     
       < SYM_NAME > < SYM_EQ > < SYM_LT >
         className = string_value()
       < SYM_GT >
     (
       < SYM_ANCESTORS > < SYM_EQ > < SYM_LT >
         ancestors = string_list_value()
       < SYM_GT >
       | 
       < SYM_GENERIC_PARAMETER > < SYM_EQ > < SYM_LT >
         genericList = generic_parameter_list()
       < SYM_GT >
       | 
       < SYM_IS_ABSTRACT > < SYM_EQ > < SYM_LT >
         isAbstract = boolean_value()
       < SYM_GT >
       | 
       < SYM_PROPERTIES > < SYM_EQ > < SYM_LT >
         // parse properties
         bmm_property_list()
       < SYM_GT >
     )*
    < SYM_GT >
  )*

  < SYM_GT >

}


/*
 Parse BMM property list
*/
void bmm_property_list() :
{
  String propertyInternalName;
  String propertyName;
  String containerType = null;
  String rootType = null;
  String propertyType = null;
  Interval<Integer> cardinality = null;
  boolean isMandatory = false;
  boolean isGeneric = false;
  Token t;
}
{
  (
    < SYM_L_BRACKET >
    propertyInternalName = string_value()
    < SYM_R_BRACKET > < SYM_EQ > < SYM_L_PARENTHESIS >
    {
      propertyName = null;
      containerType = null;
      rootType = null;
      propertyType = null;
      cardinality = null;
      isMandatory = false;
      isGeneric = false;
    }
    ( 
       < SYM_SINGLE_PROPERTY > < SYM_R_PARENTHESIS > < SYM_LT >
     (
         
       < SYM_NAME > < SYM_EQ > < SYM_LT >
         propertyName = string_value()
       < SYM_GT >
     | 
       < SYM_PROPERTY_TYPE > < SYM_EQ > < SYM_LT >
         propertyType = string_value()
       < SYM_GT >
     | 
       < SYM_IS_MANDATORY > < SYM_EQ > < SYM_LT >
         isMandatory = boolean_value()
       < SYM_GT >
     | 
       < SYM_IS_RUNTIME > < SYM_EQ > < SYM_LT >
         boolean_value()
       < SYM_GT >
     | 
       < SYM_IS_INFRASTRUCTURE > < SYM_EQ > < SYM_LT >
         boolean_value()
       < SYM_GT >
     | 
       < SYM_IS_COMPUTED > < SYM_EQ > < SYM_LT >
         boolean_value()
       < SYM_GT >
     )*
       
    |
       < SYM_CONTAINER_PROPERTY > < SYM_R_PARENTHESIS > < SYM_LT >
     (
       < SYM_NAME > < SYM_EQ > < SYM_LT >
         propertyName = string_value()
       < SYM_GT >
     | 
       < SYM_TYPE_DEF > < SYM_EQ > < SYM_LT >
         < SYM_CONTAINER_TYPE > < SYM_EQ > < SYM_LT > containerType = string_value()< SYM_GT >
         < SYM_PROPERTY_TYPE > < SYM_EQ > < SYM_LT > propertyType = string_value() < SYM_GT >
       < SYM_GT >
     | 
       < SYM_CARDINALITY > < SYM_EQ > < SYM_LT >
         cardinality = integer_interval_value()
       < SYM_GT >
     | 
       < SYM_IS_MANDATORY > < SYM_EQ > < SYM_LT >
         isMandatory = boolean_value()
       < SYM_GT >
     | 
       < SYM_IS_RUNTIME > < SYM_EQ > < SYM_LT >
         boolean_value()
       < SYM_GT >
     | 
       < SYM_IS_INFRASTRUCTURE > < SYM_EQ > < SYM_LT >
         boolean_value()
       < SYM_GT >
     | 
       < SYM_IS_COMPUTED > < SYM_EQ > < SYM_LT >
         boolean_value()
       < SYM_GT >
     )*
    |
       < SYM_GENERIC_PROPERTY > < SYM_R_PARENTHESIS > < SYM_LT >
     (    
       < SYM_NAME > < SYM_EQ > < SYM_LT >
         propertyName = string_value()
       < SYM_GT >
     | 
       < SYM_TYPE_DEF > < SYM_EQ > < SYM_LT >
         < SYM_ROOT_TYPE > < SYM_EQ > < SYM_LT > rootType = string_value()< SYM_GT >
         < SYM_PARAMETER_TYPE > < SYM_EQ > < SYM_LT > propertyType = string_value() < SYM_GT >
       < SYM_GT >
     |
       < SYM_IS_MANDATORY > < SYM_EQ > < SYM_LT >
         isMandatory = boolean_value()
       < SYM_GT >
     | 
       < SYM_IS_RUNTIME > < SYM_EQ > < SYM_LT >
         boolean_value()
       < SYM_GT >
     | 
       < SYM_IS_INFRASTRUCTURE > < SYM_EQ > < SYM_LT >
         boolean_value()
       < SYM_GT >
     | 
       < SYM_IS_COMPUTED > < SYM_EQ > < SYM_LT >
         boolean_value()
       < SYM_GT >
     )*
    |
      < SYM_SINGLE_PROPERTY_OPEN > < SYM_R_PARENTHESIS > < SYM_LT >
      {
        isGeneric = true;
      }
     (   
       < SYM_NAME > < SYM_EQ > < SYM_LT >
         propertyName = string_value()
       < SYM_GT >
     | 
       < SYM_PROPERTY_TYPE > < SYM_EQ > < SYM_LT >
         propertyType = string_value()
       < SYM_GT >
     |
       < SYM_IS_MANDATORY > < SYM_EQ > < SYM_LT >
         isMandatory = boolean_value()
       < SYM_GT >
     | 
       < SYM_IS_RUNTIME > < SYM_EQ > < SYM_LT >
         boolean_value()
       < SYM_GT >
     | 
       < SYM_IS_INFRASTRUCTURE > < SYM_EQ > < SYM_LT >
         boolean_value()
       < SYM_GT >
     | 
       < SYM_IS_COMPUTED > < SYM_EQ > < SYM_LT >
         boolean_value()
       < SYM_GT >
     )*
    )
    
    < SYM_GT >
    )*
}


/*
 Parse BMM generic parameter list
*/
HashMap<String,String> generic_parameter_list() :
{
  HashMap<String,String> genericList = new HashMap<String,String>();
  String genericInternalName = null;
  String genericName = null;
  String conformsType = null;
}
{
  (
    < SYM_L_BRACKET >
    genericInternalName = string_value()
    < SYM_R_BRACKET > < SYM_EQ > < SYM_LT >
       < SYM_NAME > < SYM_EQ > < SYM_LT >
         genericName = string_value()
       < SYM_GT >

       [
       < SYM_CONFORMS > < SYM_EQ > < SYM_LT >
         conformsType = string_value()
       < SYM_GT >
       ]
    < SYM_GT >
    {
      genericList.put(genericName, conformsType);
    }
  )*
    {
      return genericList;
    }
}






/* ---------------------- dADL - BASIC DATA VALUES ----------------------- */
String string_value() :
{
  Token t;
  String value;
}
{
  t = < V_STRING >
  {
    value = t.image;
  }
  {
    return value.substring(1, value.length() - 1);
  }
}

List index_string_list() :
{
  List list = new ArrayList();
  String value = null;
  String index = null; // not used
}
{
  (
    < SYM_L_BRACKET > index = string_value() < SYM_R_BRACKET > < SYM_EQ > < SYM_LT >
    (
      value = string_value()
    )
    {
      list.add(value);
    }
    < SYM_GT >
  )*
  {
    return list.isEmpty() ? null : list;
  }
}

List string_list_value() :
{
  List list = new ArrayList();
  String value;
}
{
  value = string_value()
  {
    list.add(value);
  }
  (
    LOOKAHEAD(2)
    ","
    (
      value = string_value()
      {
        list.add(value);
      }
    | 
      < SYM_LIST_CONTINUE >
    )
  )+
  {
    return list;
  }
}

boolean boolean_value() :
{}
{
  < SYM_TRUE >
  {
    return true;
  }
| 
  < SYM_FALSE >
  {
    return false;
  }
}

Interval integer_interval_value() :
{
  Interval i = null;
  int lower = 0;
  int upper = 0;
}
{
  < SYM_INTERVAL_DELIM >
  (
    LOOKAHEAD(3)
    {
      boolean lowerInclusive = true;
      boolean upperInclusive = true;
      boolean upperSpecified = false;
    }
    [
      < SYM_GT >
      {
        lowerInclusive = false;
      }
    ]
    lower = integer_value()
    {
      upper = lower;
    }
    [
      < SYM_ELLIPSIS >
      [
        < SYM_LT >
        {
          upperInclusive = false;
        }
      ]
      upper = integer_value()
      {
        upperSpecified = true;
      }
    ]
    {
      if (!lowerInclusive && !upperSpecified)
      {
        // specical case for |>100|
        i = new Interval(new Integer(lower), null, false, false);
      }
      else
      {
        i = new Interval(new Integer(lower), new Integer(upper), lowerInclusive, 
        upperInclusive);
      }
    }
  | 
    < SYM_LT > upper = integer_value()
    {
      i = new Interval(null, new Integer(upper), false, false);
    }
  | 
    < SYM_GT > lower = integer_value()
    {
      i = new Interval(new Integer(lower), null, false, false);
    }
  | 
    < SYM_LE > upper = integer_value()
    {
      i = new Interval(null, new Integer(upper), false, true);
    }
  | 
    < SYM_GE > lower = integer_value()
    {
      i = new Interval(new Integer(lower), null, true, false);
    }
  )
  < SYM_INTERVAL_DELIM >
  {
    return i;
  }
}

int integer_value() :
{
  int i;
  boolean negative = false;
}
{
  [
    (
      "+"
    | "-"
      {
        negative = true;
      }
    )
  ]
  i = positive_int_value()
  {
    if (negative)
    {
      i = - i;
    }
    return i;
  }
}

int positive_int_value() :
{
  Token t;
}
{
  t = < V_INTEGER >
  {
    try
    {
      return Integer.parseInt(t.image);
    }
    catch (NumberFormatException e)
    {
      throw new ParseException("Wrong format of integer: " + t.image);
    }
  }
}