/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.apache.uima.ruta.ide.parser.ast;

import java.util.ArrayList;
import java.util.List;

import org.antlr.runtime.CommonToken;
import org.antlr.runtime.Token;
import org.apache.uima.ruta.parser.RutaLexer;
import org.eclipse.dltk.ast.expressions.BooleanLiteral;
import org.eclipse.dltk.ast.expressions.Expression;
import org.eclipse.dltk.ast.expressions.ExpressionConstants;
import org.eclipse.dltk.ast.expressions.FloatNumericLiteral;
import org.eclipse.dltk.ast.expressions.NumericLiteral;
import org.eclipse.dltk.ast.expressions.StringLiteral;
import org.eclipse.dltk.ast.references.VariableReference;

public class ExpressionFactory extends AbstractFactory implements ExpressionConstants {

  /**
   * @param ref
   * @param kind
   *          see {@link RutaExpressionConstants}
   * @return instance of VariableReference
   */
  private static VariableReference newVariableReference(Token ref, int kind) {
    int bounds[] = getBounds(ref);
    return new RutaVariableReference(bounds[0], bounds[1], ref.getText(), kind);
  }

  public static VariableReference createGenericVariableReference(Token ref) {
    return newVariableReference(ref, RutaTypeConstants.RUTA_TYPE_G);
  }

  public static RutaQuantifierLiteralExpression createQuantifierLiteralExpression(Token q, Token q2) {
    int bounds[] = getBounds(q);
    if (q2 != null) {
      bounds[1] = Math.max(bounds[1], getBounds(q2)[1]);
    }
    return new RutaQuantifierLiteralExpression(bounds[0], bounds[1], q.getText());
  }

  // =====> BOOLEAN-EXPRESSIONS <======
  public static Expression createBooleanExpression(Expression e) {
    if (e == null)
      return null;
    return new RutaExpression(e.sourceStart(), e.sourceEnd(), e, RutaTypeConstants.RUTA_TYPE_B);
  }

  public static RutaBooleanNumberExpression createBooleanNumberExpression(Expression e1, Token op,
          Expression e2) {
    int lexerOpID = op.getType(); // Integer.valueOf(op.getText());
    int operatorID = 0;
    // convert lexer-opId to dltk-opId:
    switch (lexerOpID) {
      case RutaLexer.LESS:
        operatorID = E_LT;
        break;
      case RutaLexer.LESSEQUAL:
        operatorID = E_LE;
        break;
      case RutaLexer.GREATER:
        operatorID = E_GT;
        break;
      case RutaLexer.GREATEREQUAL:
        operatorID = E_GE;
        break;
      case RutaLexer.EQUAL:
        operatorID = E_EQUAL;
        break;
      case RutaLexer.NOTEQUAL:
        operatorID = E_NOT_EQUAL;
        break;
      default:
        break;
    }
    return new RutaBooleanNumberExpression(e1.sourceStart(), e2.sourceEnd(), operatorID, e1, e2);
  }

  public static VariableReference createBooleanVariableReference(Token variableId) {
    // int bounds[] = getBounds(variableId);
    return newVariableReference(variableId, RutaTypeConstants.RUTA_TYPE_B);
  }

  public static BooleanLiteral createSimpleBooleanExpression(Token bToken) {
    int bounds[] = getBounds(bToken);
    boolean value = Boolean.valueOf(bToken.getText());
    return new BooleanLiteral(bounds[0], bounds[1], value);
  }

  // =====> TYPE-EXPRESSIONS <======
  public static Expression createTypeExpression(Expression e) {
    if (e != null) {
      return new RutaExpression(e.sourceStart(), e.sourceEnd(), e, RutaTypeConstants.RUTA_TYPE_AT);
    }
    return null;
  }

  public static Expression createEmptyTypeExpression(Token token) {
    int bounds[] = getBounds(token);
    return new RutaVariableReference(bounds[0], bounds[1], "", RutaTypeConstants.RUTA_TYPE_AT);
  }

  public static Expression createEmptyStringExpression(Token token) {
    int bounds[] = getBounds(token);
    return new RutaVariableReference(bounds[0], bounds[1], "", RutaTypeConstants.RUTA_TYPE_S);
  }

  public static Expression createEmptyNumberExpression(Token token) {
    int bounds[] = getBounds(token);
    return new RutaVariableReference(bounds[0], bounds[1], "", RutaTypeConstants.RUTA_TYPE_N);
  }

  public static Expression createEmptyBooleanExpression(Token token) {
    int bounds[] = getBounds(token);
    return new RutaVariableReference(bounds[0], bounds[1], "", RutaTypeConstants.RUTA_TYPE_B);
  }

  // public static Expression createSimpleTypeExpression(Token at, RutaBlock env) {
  // int bounds[] = getBounds(at);
  // return new RutaSimpleTypeExpression(bounds[0], bounds[1], at.getText());
  // }

  public static VariableReference createAnnotationTypeVariableReference(Token atRef) {
    return newVariableReference(atRef, RutaTypeConstants.RUTA_TYPE_AT);
  }

  public static Expression createAnnotationTypeConstantReference(Token atBasic) {
    int bounds[] = getBounds(atBasic);
    return new RutaVariableReference(bounds[0], bounds[1], atBasic.getText(),
            RutaTypeConstants.RUTA_TYPE_AT);
    // RutaBasicAnnotationType(atBasic.getText(),bounds[0],bounds[1],bounds[0],bounds[1]);
  }

  // =====> STRING-EXPRESSIONS <======
  public static RutaStringExpression createStringExpression(List<Expression> exprList) {
    if (exprList == null) {
      exprList = new ArrayList<Expression>();
    }
    int start = 0;
    int end = 0;
    if (!exprList.isEmpty()) {
      start = exprList.get(0).sourceStart();
      end = exprList.get(exprList.size() - 1).sourceEnd();
    }
    return new RutaStringExpression(start, end, exprList);
  }

  public static StringLiteral createSimpleString(Token stringToken) {
    int bounds[] = getBounds(stringToken);
    return new StringLiteral(bounds[0], bounds[1], stringToken.getText());
  }

  // public static RessourceReference createRessourceReference

  public static VariableReference createStringVariableReference(Token variableId) {
    return newVariableReference(variableId, RutaTypeConstants.RUTA_TYPE_S);
  }

  // =====> NUMBER-EXPRESSIONS <======
  public static RutaExpression createNumberExpression(Expression e) {
    return new RutaExpression(e.sourceStart(), e.sourceEnd(), e, RutaTypeConstants.RUTA_TYPE_N);
  }

  public static NumericLiteral createDecimalLiteral(Token decLit, Token minus) {
    int bounds[] = getBounds(decLit);
    int value = Integer.valueOf(decLit.getText()); // .getInteger(decLit.getText());
    if (minus != null) {
      value = -value;
      bounds[0] = ((CommonToken) minus).getStartIndex();
    }
    return new NumericLiteral(bounds[0], bounds[1], value);
  }

  public static FloatNumericLiteral createFloatingPointLiteral(Token fpLit, Token minus) {
    int bounds[] = getBounds(fpLit);
    double value;
    try {
      value = Double.parseDouble(fpLit.getText());
    } catch (NumberFormatException e) {
      value = 0.0;
    }
    if (minus != null) {
      value = -value;
      bounds[0] = ((CommonToken) minus).getStartIndex();
    }
    return new FloatNumericLiteral(bounds[0], bounds[1], value);
  }

  /**
   * Creates (local) NumberVariableReference
   * 
   * @param numVarRef
   * @return new VariableReference of Token
   */
  public static VariableReference createNumberVariableReference(Token numVarRef) {
    return newVariableReference(numVarRef, RutaTypeConstants.RUTA_TYPE_N);
  }

  public static Expression createNegatedNumberExpression(Token minus, Expression expr) {
    int bounds[] = getSurroundingBounds(expr, (List<?>) null);
    if (minus != null) {
      bounds[0] = ((CommonToken) minus).getStartIndex();
    }
    return new RutaExpression(bounds[0], bounds[1], expr, RutaTypeConstants.RUTA_TYPE_N);
  }

  public static RutaBinaryArithmeticExpression createBinaryArithmeticExpr(Expression exprA,
          Expression exprB, Token op) {
    int bounds[] = getBounds(exprA, exprB);
    int lexerOpID = op.getType();
    int operatorID = 0;
    // convert lexer-opId to dltk-opId:
    switch (lexerOpID) {
      case RutaLexer.STAR:
        operatorID = ExpressionConstants.E_MULT;
        break;
      case RutaLexer.SLASH:
        operatorID = ExpressionConstants.E_DIV;
        break;
      case RutaLexer.PERCENT:
        operatorID = ExpressionConstants.E_MOD;
        break;
      case RutaLexer.PLUS:
        operatorID = ExpressionConstants.E_PLUS;
        break;
      case RutaLexer.MINUS:
        operatorID = ExpressionConstants.E_MINUS;
        break;
      case RutaLexer.POW:
        operatorID = ExpressionConstants.E_POWER;
        break;
      default:
        break;
    }
    return new RutaBinaryArithmeticExpression(bounds[0], bounds[1], exprA, exprB, operatorID);
  }

  public static Expression createUnaryArithmeticExpr(Expression expr, Token op) {
    int bounds[] = getBounds(op);
    if (expr != null) {
      bounds[1] = expr.sourceEnd();
    }
    int opID = convertOpToInt(op);
    return new RutaUnaryArithmeticExpression(bounds[0], bounds[1], expr, opID);
  }

  private static int convertOpToInt(Token opToken) {
    return RutaExpressionConstants.opIDs.get(opToken.getText());
  }

  // TODO
  public static Expression createBooleanFunction(Token op, Expression e1, Expression e2) {
    return new RutaExpression(e1.sourceStart(), e2.sourceEnd(), null, RutaTypeConstants.RUTA_TYPE_B);
  }

  public static Expression createListVariableReference(Token id) {
    return newVariableReference(id, RutaTypeConstants.RUTA_TYPE_WL);
  }

  public static Expression createTableVariableReference(Token id) {
    return newVariableReference(id, RutaTypeConstants.RUTA_TYPE_WT);
  }

  public static Expression createRessourceReference(Token path) {
    int bounds[] = getBounds(path);
    String pathWithoutQuotes = path.getText();
    pathWithoutQuotes = pathWithoutQuotes.substring(1, pathWithoutQuotes.length() - 1);
    return new RutaRessourceReference(bounds[0], bounds[1], pathWithoutQuotes);
  }

  public static Expression createInnerListExpression(Token lBrak, List<String> inner, Token rBrak) {
    int boundsA[] = getBounds(lBrak, rBrak);
    StringBuffer s = new StringBuffer();
    s.append(lBrak);
    for (String el : inner) {
      s.append(el);
    }
    s.append(rBrak);
    return new RutaInnerListExpression(boundsA[0], boundsA[1], s.toString());
  }

  public static Expression createBooleanTypeExpression(Expression e1, Token op, Expression e2) {
    int lexerOpID = op.getType(); // Integer.valueOf(op.getText());
    int operatorID = 0;
    // convert lexer-opId to dltk-opId:
    switch (lexerOpID) {
      case RutaLexer.EQUAL:
        operatorID = E_EQUAL;
        break;
      case RutaLexer.NOTEQUAL:
        operatorID = E_NOT_EQUAL;
        break;
      default:
        break;
    }
    if (e1 != null && e2 != null) {
      return new RutaBooleanTypeExpression(e1.sourceStart(), e2.sourceEnd(), operatorID, e1, e2);
    }
    return null;
  }

  public static Expression createListExpression(List<Expression> exprList, int type) {
    if (exprList == null) {
      exprList = new ArrayList<Expression>();
    }
    int start = 0;
    int end = 0;
    if (!exprList.isEmpty()) {
      start = exprList.get(0).sourceStart();
      Expression expression = exprList.get(exprList.size() - 1);
      if (expression != null) {
        end = expression.sourceEnd();
      } else {
        exprList.get(0).sourceEnd();
      }
    }
    return new RutaListExpression(start, end, exprList, type);
  }

  public static Expression createListExpression(Token var, int type) {
    return newVariableReference(var, type);
  }

  public static Expression createStringFunction(Token name, Expression var, List<Expression> list) {
    list.add(0, var);
    return createStringFunction(name, list);
  }

  public static Expression createFeatureMatch(Token feature, Token comp, Expression value) {
    int bounds[] = getBounds(feature);
    int end = bounds[1];
    if (value != null) {
      end = value.sourceEnd();
    }
    return new FeatureMatchExpression(bounds[0], end, feature, comp, value);
  }

  public static Expression createBooleanFunction(Token id, List<Expression> args) {
    return createFunction(id, args, RutaTypeConstants.RUTA_TYPE_B);
  }

  public static Expression createNumberFunction(Token id, List<Expression> args) {
    return createFunction(id, args, RutaTypeConstants.RUTA_TYPE_N);
  }

  public static Expression createStringFunction(Token id, List<Expression> args) {
    return createFunction(id, args, RutaTypeConstants.RUTA_TYPE_S);
  }

  public static Expression createTypeFunction(Token id, List<Expression> args) {
    return createFunction(id, args, RutaTypeConstants.RUTA_TYPE_AT);
  }

  public static RutaFunction createFunction(Token type, List<Expression> exprsRaw, int kind) {
    int bounds[] = getBounds(type);
    int nameStart = bounds[0];
    int nameEnd = bounds[1];
    List<Expression> exprs = new ArrayList<Expression>();
    if (exprsRaw != null) {
      for (Object expressionObj : exprsRaw) {
        Expression expr = (Expression) expressionObj;
        if (expr != null) {
          exprs.add(expr);
        }
      }
      if (!exprs.isEmpty()) {
        Expression lastExpr = (Expression) exprs.get(exprs.size() - 1);
        bounds[1] = Math.max(bounds[1], lastExpr.sourceEnd());
      }
    }
    return new RutaFunction(bounds[0], bounds[1], exprs, kind, type.getText(), nameStart, nameEnd);
  }

  public static Expression createFeatureExpression(Token f) {
    return createFeatureMatch(f, null, null);
  }

  public static Expression createStringExpression(Expression fe) {
    List<Expression> list = new ArrayList<Expression>(1);
    list.add(fe);
    return createStringExpression(list);
  }
  public static Expression createNullExpression(Token t) {
    int bounds[] = getBounds(t);
    return new NullExpression(bounds[0], bounds[1]);
  }
}