/*
 * 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.validator;

import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.Stack;
import java.util.TreeMap;

import org.antlr.runtime.Token;
import org.apache.commons.lang3.StringUtils;
import org.apache.uima.UIMAFramework;
import org.apache.uima.cas.CAS;
import org.apache.uima.resource.ResourceManager;
import org.apache.uima.resource.impl.ResourceManager_impl;
import org.apache.uima.resource.metadata.FeatureDescription;
import org.apache.uima.resource.metadata.TypeDescription;
import org.apache.uima.resource.metadata.TypeSystemDescription;
import org.apache.uima.resource.metadata.impl.FeatureDescription_impl;
import org.apache.uima.ruta.ide.RutaIdeUIPlugin;
import org.apache.uima.ruta.ide.core.IRutaKeywords;
import org.apache.uima.ruta.ide.core.RutaCorePreferences;
import org.apache.uima.ruta.ide.core.RutaExtensionManager;
import org.apache.uima.ruta.ide.core.RutaKeywordsManager;
import org.apache.uima.ruta.ide.core.builder.RutaProjectUtils;
import org.apache.uima.ruta.ide.core.extensions.IIDEActionExtension;
import org.apache.uima.ruta.ide.core.extensions.IIDEBlockExtension;
import org.apache.uima.ruta.ide.core.extensions.IIDEBooleanFunctionExtension;
import org.apache.uima.ruta.ide.core.extensions.IIDEConditionExtension;
import org.apache.uima.ruta.ide.core.extensions.IIDENumberFunctionExtension;
import org.apache.uima.ruta.ide.core.extensions.IIDEStringFunctionExtension;
import org.apache.uima.ruta.ide.core.extensions.IIDETypeFunctionExtension;
import org.apache.uima.ruta.ide.core.extensions.IRutaExtension;
import org.apache.uima.ruta.ide.parser.ast.FeatureMatchExpression;
import org.apache.uima.ruta.ide.parser.ast.ForEachBlock;
import org.apache.uima.ruta.ide.parser.ast.NullExpression;
import org.apache.uima.ruta.ide.parser.ast.RutaAction;
import org.apache.uima.ruta.ide.parser.ast.RutaBlock;
import org.apache.uima.ruta.ide.parser.ast.RutaCondition;
import org.apache.uima.ruta.ide.parser.ast.RutaDeclareDeclarationsStatement;
import org.apache.uima.ruta.ide.parser.ast.RutaExpression;
import org.apache.uima.ruta.ide.parser.ast.RutaFeatureDeclaration;
import org.apache.uima.ruta.ide.parser.ast.RutaFunction;
import org.apache.uima.ruta.ide.parser.ast.RutaImportStatement;
import org.apache.uima.ruta.ide.parser.ast.RutaImportTypesStatement;
import org.apache.uima.ruta.ide.parser.ast.RutaListExpression;
import org.apache.uima.ruta.ide.parser.ast.RutaMacroDeclaration;
import org.apache.uima.ruta.ide.parser.ast.RutaPackageDeclaration;
import org.apache.uima.ruta.ide.parser.ast.RutaRegExpRule;
import org.apache.uima.ruta.ide.parser.ast.RutaRule;
import org.apache.uima.ruta.ide.parser.ast.RutaRuleElement;
import org.apache.uima.ruta.ide.parser.ast.RutaStatementConstants;
import org.apache.uima.ruta.ide.parser.ast.RutaStringExpression;
import org.apache.uima.ruta.ide.parser.ast.RutaStructureAction;
import org.apache.uima.ruta.ide.parser.ast.RutaTypeConstants;
import org.apache.uima.ruta.ide.parser.ast.RutaTypeDeclaration;
import org.apache.uima.ruta.ide.parser.ast.RutaVariableDeclaration;
import org.apache.uima.ruta.ide.parser.ast.RutaVariableReference;
import org.apache.uima.util.InvalidXMLException;
import org.apache.uima.util.XMLInputSource;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.dltk.ast.ASTListNode;
import org.eclipse.dltk.ast.ASTNode;
import org.eclipse.dltk.ast.ASTVisitor;
import org.eclipse.dltk.ast.declarations.MethodDeclaration;
import org.eclipse.dltk.ast.expressions.Expression;
import org.eclipse.dltk.ast.expressions.NumericLiteral;
import org.eclipse.dltk.ast.expressions.StringLiteral;
import org.eclipse.dltk.ast.references.SimpleReference;
import org.eclipse.dltk.ast.statements.Statement;
import org.eclipse.dltk.compiler.problem.IProblem;
import org.eclipse.dltk.compiler.problem.IProblemReporter;
import org.eclipse.dltk.compiler.problem.ProblemSeverity;
import org.eclipse.dltk.core.ISourceModule;
import org.eclipse.dltk.core.builder.ISourceLineTracker;
import org.eclipse.jface.preference.IPreferenceStore;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

public class LanguageCheckerVisitor extends ASTVisitor {

  private IProblemReporter pr;

  private ISourceLineTracker linetracker;

  private ISourceModule sourceModule;

  private Map<String, IIDEConditionExtension> conditionExtensions;

  private Map<String, IIDEActionExtension> actionExtensions;

  private Map<String, IIDENumberFunctionExtension> numberFunctionExtensions;

  private Map<String, IIDEBooleanFunctionExtension> booleanFunctionExtensions;

  private Map<String, IIDEStringFunctionExtension> stringFunctionExtensions;

  private Map<String, IIDETypeFunctionExtension> typeFunctionExtensions;

  private Map<String, IIDEBlockExtension> blockExtensions;

  /**
   * Mapping from short type name (e.g. {@code W}) to their disambiguated long type names (e.g.
   * {@code org.apache.uima.ruta.type.W}).
   */
  private Map<String, String> namespaces;

  /**
   * Mapping from ambiguous short type names to all their possible long type names.
   */
  private Map<String, Set<String>> ambiguousTypeAlias;

  /**
   * Known variables for each block environment
   */
  private final Stack<Map<String, Integer>> knownLocalVariables;

  /**
   * Name of each block
   */
  private final Stack<String> blocks;

  /**
   * each (inlined) rules
   */
  private final Stack<RutaRule> rules;

  /**
   * Caching the matched type of a rule element
   */
  private String matchedType;

  /**
   * Caching the declared package of the script
   */
  private String packageName = "";

  /**
   * Mapping all long type names of the type system to their type description
   */
  private Map<String, TypeDescription> typeDescriptionMap;

  /**
   * Mapping all long type names of all declared feature description
   */
  private Map<String, Set<FeatureDescription>> featureDescriptionMap;

  /**
   * The type system description of the script file
   */
  private TypeSystemDescription typeSystemDescription;

  private final String implicitString = "Implicit";

  private Set<String> finalTypes;

  private boolean reportWarningOnShortNames;

  private RutaCheckerProblemFactory problemFactory;

  private ResourceManager resourceManager;

  private Set<String> allLongTypeNames;

  private String parentTypeInDeclaration;

  private ClassLoader classLoader;

  private String packagePathString;

  private boolean packageChecked = false;

  private Collection<String> currentLabels = new HashSet<>();

  public LanguageCheckerVisitor(IProblemReporter problemReporter, ISourceLineTracker linetracker,
          ISourceModule sourceModule, ClassLoader classLoader) {
    super();
    this.pr = problemReporter;
    this.linetracker = linetracker;
    this.sourceModule = sourceModule;
    this.classLoader = classLoader;
    this.problemFactory = new RutaCheckerProblemFactory(sourceModule.getElementName(), linetracker);

    namespaces = new TreeMap<String, String>();
    ambiguousTypeAlias = new TreeMap<String, Set<String>>();
    allLongTypeNames = new HashSet<String>();
    knownLocalVariables = new Stack<Map<String, Integer>>();
    knownLocalVariables.push(new HashMap<String, Integer>());
    blocks = new Stack<String>();
    rules = new Stack<RutaRule>();
    packagePathString = "";

    initializePredefinedInformation();
    initializeExtensionInformation();

    IProject project = sourceModule.getScriptProject().getProject();
    IPath location = sourceModule.getResource().getLocation();
    try {
      IPath packagePath = RutaProjectUtils.getPackagePath(location, project);
      if (packagePath != null) {
        packagePathString = packagePath.toPortableString().replaceAll("/", ".");
      }
    } catch (CoreException e) {
      RutaIdeUIPlugin.error(e);
    }

    IPreferenceStore store = RutaIdeUIPlugin.getDefault().getPreferenceStore();
    reportWarningOnShortNames = !store
            .getBoolean(RutaCorePreferences.BUILDER_IGNORE_DUPLICATE_SHORTNAMES);

  }

  @Override
  public boolean visit(Statement s) throws Exception {
    if (s instanceof RutaPackageDeclaration) {
      this.packageName = ((RutaPackageDeclaration) s).getName();
      checkPackage(s);
      return false;
    }
    if (s instanceof RutaMacroDeclaration) {
      RutaMacroDeclaration decl = (RutaMacroDeclaration) s;
      Map<Token, Token> definition = decl.getDefinition();
      String name = decl.getName();
      int kind = decl.getKind();
      if (kind == RutaTypeConstants.RUTA_TYPE_A) {
        actionExtensions.put(name, null);
      } else if (kind == RutaTypeConstants.RUTA_TYPE_C) {
        conditionExtensions.put(name, null);
      }
      Set<Entry<Token, Token>> entrySet = definition.entrySet();
      Map<String, Integer> map = new HashMap<>();
      for (Entry<Token, Token> entry : entrySet) {
        String varName = entry.getKey().getText();
        String varType = entry.getValue().getText();
        int vt = getType(varType);
        map.put(varName, vt);
      }
      knownLocalVariables.push(map);
    }
    if (s instanceof RutaImportTypesStatement) {
      RutaImportTypesStatement stmt = (RutaImportTypesStatement) s;
      SimpleReference tsExpr = (SimpleReference) stmt.getExpression();
      Token typeToken = stmt.getTypeToken();
      Token pkgToken = stmt.getPkgToken();
      Token aliasToken = stmt.getAliasToken();
      if (tsExpr != null) {
        String localPath = tsExpr.getName();
        processCompleteTypeSystemImport(tsExpr, localPath, typeToken, pkgToken, aliasToken);
      } else {
        // TODO package import not supported in Workbench
      }

    } else if (s instanceof RutaImportStatement) {
      // handle type system imports
      if (((RutaImportStatement) s).getType() == RutaStatementConstants.S_IMPORT_TYPESYSTEM) {
        SimpleReference sRef = (SimpleReference) ((RutaImportStatement) s).getExpression();
        String localPath = sRef.getName();
        processCompleteTypeSystemImport(sRef, localPath);
        return false;
      }
      // handle script-imports
      if (((RutaImportStatement) s).getType() == RutaStatementConstants.S_IMPORT_SCRIPT) {
        SimpleReference sRef = (SimpleReference) ((RutaImportStatement) s).getExpression();
        String localPath = sRef.getName();

        // HOTFIX Peter add also the imported types of the imported type system!
        try {
          URL url = null;
          IFile file = RutaCheckerUtils.checkScriptImport(localPath,
                  sourceModule.getScriptProject());
          if (file == null) {
            String typesystemSuffix = RutaProjectUtils
                    .getTypeSystemSuffix(sourceModule.getScriptProject().getProject());
            url = RutaCheckerUtils.checkImportExistence(localPath + typesystemSuffix, "xml",
                    classLoader);
          }
          if (file == null && url == null) {
            pr.reportProblem(problemFactory.createFileNotFoundProblem(sRef, localPath));
          } else {
            IProject referredProject = sourceModule.getScriptProject().getProject();
            if (file != null) {
              // script in other project? use that if the file was found in the workspace
              referredProject = file.getProject();
              IPath typeSystemDescriptorPath = RutaProjectUtils.getTypeSystemDescriptorPath(
                      file.getLocation(), referredProject, classLoader);
              TypeSystemDescription tsDesc = importCompleteTypeSystem(typeSystemDescriptorPath,
                      url);

              List<String> checkDuplicateShortNames = checkOnAmbiguousShortNames(tsDesc);
              if (!checkDuplicateShortNames.isEmpty()) {
                pr.reportProblem(problemFactory.createDuplicateShortNameInImported(sRef, localPath,
                        checkDuplicateShortNames, ProblemSeverity.WARNING));
              }
            }
          }
        } catch (IOException e) {
          pr.reportProblem(problemFactory.createFileNotFoundProblem(sRef, localPath));
        }
        return false;
      }
    }

    if (s instanceof RutaDeclareDeclarationsStatement) {
      RutaDeclareDeclarationsStatement dds = (RutaDeclareDeclarationsStatement) s;
      ASTNode parent = dds.getParent();
      if (parent != null && parent instanceof RutaVariableReference) {
        RutaVariableReference p = (RutaVariableReference) parent;
        String name = p.getName();
        name = expand(name);
        parentTypeInDeclaration = name;
        // TODO remember name for new types and their features!
        if (finalTypes.contains(name)) {
          IProblem problem = problemFactory.createInheritenceFinalProblem(p);
          pr.reportProblem(problem);
        }
      }
      return true;
    }
    if (s instanceof RutaTypeDeclaration) {
      RutaTypeDeclaration newType = (RutaTypeDeclaration) s;
      String shortName = newType.getName();
      String longName = getLongNameOfNewType(shortName);

      if (namespaces.values().contains(longName)) {
        IProblem problem = problemFactory.createIdConflictsWithTypeProblem(newType);
        pr.reportProblem(problem);
        return false;
      }

      if (reportWarningOnShortNames && namespaces.containsKey(shortName)) {
        IProblem problem = problemFactory.createDuplicateShortName(newType,
                ProblemSeverity.WARNING);
        pr.reportProblem(problem);
        return false;
      }
      if (knowsVariable(shortName)) {
        IProblem problem = problemFactory.createIdConflictsWithVariableProblem(newType);
        pr.reportProblem(problem);
        return false;
      }
      List<RutaFeatureDeclaration> features = newType.getFeatures();
      Set<FeatureDescription> feats = new HashSet<FeatureDescription>();
      if (parentTypeInDeclaration != null) {
        Set<FeatureDescription> set = featureDescriptionMap.get(parentTypeInDeclaration);
        if (set != null) {
          feats.addAll(set);
        }
      }
      if (features != null) {
        for (RutaFeatureDeclaration each : features) {
          // TODO create correct feature description! Works right now because the type is not
          // checked
          String type = each.getType();
          type = translate(type);
          type = expand(type);
          FeatureDescription f = new FeatureDescription_impl(each.getName(), "", type);
          feats.add(f);
          if (type.equals("INT") || type.equals("STRING") || type.equals("DOUBLE")
                  || type.equals("FLOAT") || type.equals("BOOLEAN")) {
            continue;
          }
          if (!namespaces.keySet().contains(type) && !namespaces.values().contains(type)) {
            IProblem problem = problemFactory.createUnknownFeatureTypeProblem(each);
            pr.reportProblem(problem);
          }

        }
        featureDescriptionMap.put(longName, feats);
      }
      addDeclaredType(shortName);
      return false;
    }
    if (s instanceof RutaVariableDeclaration) {
      RutaVariableDeclaration newVar = (RutaVariableDeclaration) s;
      if (knowsVariable(newVar.getName())) {
        IProblem problem = problemFactory.createIdConflictsWithVariableProblem(newVar);
        pr.reportProblem(problem);
        return false;
      }
      if (namespaces.containsKey(newVar.getName())) {
        IProblem problem = problemFactory.createIdConflictsWithTypeProblem(newVar);
        pr.reportProblem(problem);
        return false;
      }
      knownLocalVariables.peek().put(newVar.getName(), newVar.getKind());
      return false;
    }
    if (s instanceof RutaRegExpRule) {
      RutaRegExpRule rule = (RutaRegExpRule) s;
      Map<Expression, Map<Expression, Expression>> faMap = rule.getFeats();
      Set<Entry<Expression, Map<Expression, Expression>>> typeEntrySet = faMap.entrySet();
      for (Entry<Expression, Map<Expression, Expression>> entry : typeEntrySet) {
        Expression struct = entry.getKey();
        String structure = "";
        if (struct != null) {
          structure = sourceModule.getSource().substring(struct.sourceStart(), struct.sourceEnd());
          structure = expand(structure);
        }
        Map<Expression, Expression> fmap = entry.getValue();
        Set<Expression> keySet = fmap.keySet();
        for (Expression fkey : keySet) {
          if (fkey instanceof RutaExpression && fkey.getKind() == RutaTypeConstants.RUTA_TYPE_S) {
            String feat = fkey.toString();
            feat = getFeatureName(fkey, feat);
            boolean findFeature = findFeature(structure, feat, -1);
            if (!findFeature) {
              IProblem problem = problemFactory.createUnknownFeatureProblem(fkey, structure);
              pr.reportProblem(problem);
            }
          }
        }
      }
    }
    if (s instanceof RutaRule) {
      if (rules.isEmpty()) {
        collectAllLabels((RutaRule) s);
      }
      rules.push((RutaRule) s);
    }
    return true;
  }

  private void collectAllLabels(RutaRule rule) {
    try {
      RuleElementLabelVisitor visitor = new RuleElementLabelVisitor();
      rule.traverse(visitor);
      currentLabels = visitor.getLabels();
    } catch (Exception e) {
      RutaIdeUIPlugin.error(e);
    }
  }

  private void checkPackage(ASTNode node) {
    if (!StringUtils.equals(packageName, packagePathString) && !packageChecked) {
      pr.reportProblem(problemFactory.createWrongPackageProblem(node));
    }
    packageChecked = true;
  }

  private void processCompleteTypeSystemImport(SimpleReference sRef, String localPath)
          throws CoreException {
    processCompleteTypeSystemImport(sRef, localPath, null, null, null);
  }

  private void processCompleteTypeSystemImport(SimpleReference sRef, String localPath,
          Token typeToken, Token pkgToken, Token aliasToken) throws CoreException {
    try {
      URL url = null;
      IFile file = RutaCheckerUtils.checkTypeSystemImport(localPath,
              sourceModule.getScriptProject());
      if (file == null) {
        url = RutaCheckerUtils.checkImportExistence(localPath, "xml", classLoader);
      }
      if (file == null && url == null) {
        pr.reportProblem(problemFactory.createFileNotFoundProblem(sRef, localPath));
      } else {
        IPath path = file == null ? null : file.getLocation();
        TypeSystemDescription tsDesc = importTypeSystem(path, url, typeToken, pkgToken, aliasToken);
        if (reportWarningOnShortNames) {
          List<String> checkDuplicateShortNames = checkOnAmbiguousShortNames(tsDesc);
          if (!checkDuplicateShortNames.isEmpty()) {
            pr.reportProblem(problemFactory.createDuplicateShortNameInImported(sRef, localPath,
                    checkDuplicateShortNames, ProblemSeverity.WARNING));
          }
        }
      }
    } catch (IOException e) {
      pr.reportProblem(problemFactory.createFileNotFoundProblem(sRef, localPath));
    } catch (InvalidXMLException e) {
      pr.reportProblem(problemFactory.createXMLProblem(sRef, localPath));
    }
  }

  private List<String> checkOnAmbiguousShortNames(TypeSystemDescription tsDesc) {
    List<String> checkDuplicateShortNames = new ArrayList<String>();
    for (TypeDescription each : tsDesc.getTypes()) {
      String longName = each.getName();
      String shortName = getShortName(longName);
      Set<String> set = ambiguousTypeAlias.get(shortName);
      if (set != null && set.size() > 1) {
        checkDuplicateShortNames.addAll(set);
      }
    }
    return checkDuplicateShortNames;
  }

  private TypeSystemDescription importTypeSystem(IPath path, URL url, Token typeToken,
          Token pkgToken, Token aliasToken)
          throws InvalidXMLException, IOException, MalformedURLException, CoreException {
    TypeSystemDescription tsDesc = null;
    if (path != null) {
      tsDesc = UIMAFramework.getXMLParser()
              .parseTypeSystemDescription(new XMLInputSource(path.toFile()));
    } else {
      tsDesc = UIMAFramework.getXMLParser().parseTypeSystemDescription(new XMLInputSource(url));
    }

    ResourceManager resMgr = getResourceManager(classLoader);
    tsDesc.resolveImports(resMgr);
    for (TypeDescription each : tsDesc.getTypes()) {
      String longName = each.getName();
      String shortName = getShortName(longName);
      if (pkgToken != null) {
        String pkg = pkgToken.getText();
        if (!longName.startsWith(pkg + ".")) {
          continue;
        }
      }
      if (typeToken != null) {
        String type = typeToken.getText();
        if (!longName.equals(type)) {
          continue;
        }
      }
      if (aliasToken != null) {
        String alias = aliasToken.getText();
        if (typeToken == null) {
          shortName = alias + "." + shortName;
        } else {
          shortName = alias;
        }
      }
      importType(longName, shortName);
    }
    return tsDesc;
  }

  private ResourceManager getResourceManager(ClassLoader classloader)
          throws MalformedURLException, CoreException {
    if (resourceManager == null) {
      resourceManager = new ResourceManager_impl(classloader);
      List<IFolder> folders = RutaProjectUtils
              .getAllDescriptorFolders(sourceModule.getScriptProject().getProject());
      StringBuilder sb = new StringBuilder();
      Iterator<IFolder> iterator = folders.iterator();
      while (iterator.hasNext()) {
        IFolder iFolder = iterator.next();
        sb.append(iFolder.getLocation().toPortableString());
        if (iterator.hasNext()) {
          sb.append(System.getProperty("path.separator"));
        }
      }
      resourceManager.setDataPath(sb.toString());
    }
    return resourceManager;
  }

  @Override
  public boolean visit(Expression s) throws Exception {

    if (s instanceof RutaRuleElement) {
      RutaRuleElement re = (RutaRuleElement) s;
      Expression head = re.getHead();
      if (head instanceof FeatureMatchExpression) {
        FeatureMatchExpression fme = (FeatureMatchExpression) head;
        String text = fme.getFeature().getText();
        int lastIndexOf = text.lastIndexOf('.');
        String twf = text.substring(0, lastIndexOf);
        Integer variableType = getVariableType(twf);
        if (variableType != null && variableType == RutaTypeConstants.RUTA_TYPE_AT) {
          matchedType = twf;
        } else {
          twf = expand(twf);
          matchedType = isFeatureMatch(twf);
        }
      } else if (head != null) {
        matchedType = sourceModule.getSource().substring(head.sourceStart(), head.sourceEnd());
      }
      // cache long name
      matchedType = expand(matchedType);
      if (matchedType == null) {
        matchedType = "uima.tcas.Annotation";
      }
    }
    if (s instanceof FeatureMatchExpression) {
      FeatureMatchExpression fme = (FeatureMatchExpression) s;
      String featText = fme.getFeature().getText();
      // HOTFIX: parser creates wrong AST element
      if (allLongTypeNames.contains(featText)) {
        return true;
      }
      if (namespaces.keySet().contains(featText)) {
        // wrong ast elements, alias interpreted as feature expression
        return false;
      }
      checkTypeOfFeatureMatch(featText, fme);
      return true;
    }
    if (s instanceof RutaVariableReference) {
      if (s instanceof NullExpression) {
        return false;
      }
      RutaVariableReference ref = (RutaVariableReference) s;
      if (ref.getType() == RutaTypeConstants.RUTA_TYPE_WT
              || ref.getType() == RutaTypeConstants.RUTA_TYPE_WL) {
        if (StringUtils.isBlank(ref.getName())) {
          // declaration with a string expression: do not check
          return false;
        }
      }
      if ((ref.getType() & RutaTypeConstants.RUTA_TYPE_AT) != 0) {
        // types
        String name = ref.getName();
        if (name.equals("Document")) {
          return false;
        }

        Set<String> set = ambiguousTypeAlias.get(name);
        if (set != null && !set.isEmpty()) {
          pr.reportProblem(
                  problemFactory.createAmbiguousShortName(ref, set, ProblemSeverity.ERROR));
          return false;
        }
        if (namespaces.keySet().contains(name) || namespaces.values().contains(name)
                || allLongTypeNames.contains(name)) {
          return false;
        }
        Integer variableType = getVariableType(name);
        if (variableType != null && (variableType == RutaTypeConstants.RUTA_TYPE_AT
                || variableType == RutaTypeConstants.RUTA_TYPE_UA
                || variableType == RutaTypeConstants.RUTA_TYPE_UAL)) {
          return false;
        }
        if (isFeatureMatch(name) != null) {
          return false;
        }
        if (isLabel(name)) {
          return false;
        }
        if (name.indexOf(".") != -1) {
          String[] split = name.split("[.]");
          if (StringUtils.equals(split[split.length - 1], "ct")
                  || StringUtils.equals(split[split.length - 1], "coveredText")) {
            return false;
          }
          Integer prefixType = getVariableType(split[0]);
          if (prefixType == RutaTypeConstants.RUTA_TYPE_UA
                  || prefixType == RutaTypeConstants.RUTA_TYPE_UAL) {
            return false;
          }
        }

        pr.reportProblem(problemFactory.createTypeProblem(ref, sourceModule));
        return false;
      }
      if (!isVariableDeclared(ref)) {
        return false;
      }
      checkTypeOfVariable(ref);
      return false;
    }
    // check assign types
    if (s instanceof RutaAction) {
      RutaAction tma = (RutaAction) s;

      String actionName = sourceModule.getSource().substring(tma.getNameStart(), tma.getNameEnd());
      String[] keywords = RutaKeywordsManager.getKeywords(IRutaKeywords.ACTION);
      List<String> asList = Arrays.asList(keywords);
      if (!StringUtils.isEmpty(actionName) && !"-".equals(actionName)
              && !asList.contains(actionName) && !implicitString.equals(tma.getName())
              && !actionExtensions.keySet().contains(actionName)) {
        IProblem problem = problemFactory.createUnknownActionProblem(tma);
        pr.reportProblem(problem);
      }

      IRutaExtension extension = actionExtensions.get(actionName);
      if (extension != null) {
        extension.checkSyntax(tma, problemFactory, pr);
      }

      if (tma.getName().equals("GETFEATURE") || tma.getName().equals("SETFEATURE")) {
        List<?> childs = tma.getChilds();
        RutaStringExpression stringExpr = (RutaStringExpression) childs.get(0);
        String feat = stringExpr.toString();
        feat = getFeatureName(stringExpr, feat);
        boolean featureFound = findFeature(matchedType, feat, -1);
        if (!featureFound) {
          IProblem problem = problemFactory.createUnknownFeatureProblem(stringExpr, matchedType);
          pr.reportProblem(problem);
        }
      }

      if (s instanceof RutaStructureAction) {
        RutaStructureAction sa = (RutaStructureAction) s;
        Expression struct = sa.getStructure();
        String structure = null;
        if (struct != null) {
          structure = sourceModule.getSource().substring(struct.sourceStart(), struct.sourceEnd());
          structure = expand(structure);
        }
        Map<Expression, Expression> assignments = sa.getAssignments();
        // hotfix... correct name in ast
        String action = sourceModule.getSource().substring(sa.getNameStart(), sa.getNameEnd());
        if (assignments != null && !action.equals("TRIE")) {
          for (Expression each : assignments.keySet()) {
            // TODO refactor to visitor?
            String feat = each.toString();
            // List<?> childs = each.getChilds();
            feat = getFeatureName(each, feat);
            boolean featureFound = findFeature(structure, feat, -1);
            if (!featureFound) {
              IProblem problem = problemFactory.createUnknownFeatureProblem(each, structure);
              pr.reportProblem(problem);
            }
          }
        } else if (assignments != null && action.equals("TRIE")) {
          for (Expression each : assignments.values()) {
            if (each instanceof RutaListExpression) {
              RutaListExpression rle = (RutaListExpression) each;
              List<?> childs = rle.getExprs().getChilds();
              if (childs.size() != 2 && childs.size() != 3) {
                IProblem problem = problemFactory.createWrongNumberOfArgumentsProblem(actionName,
                        rle, 2);
                pr.reportProblem(problem);
              }
              Object arg1 = childs.get(0);
              if (arg1 instanceof RutaExpression) {
                RutaExpression e1 = (RutaExpression) arg1;
                if (e1.getKind() != RutaTypeConstants.RUTA_TYPE_AT) {
                  IProblem problem = problemFactory.createWrongArgumentTypeProblem(e1, "Type");
                  pr.reportProblem(problem);
                }
              }
              Object arg2 = childs.get(1);
              if (arg2 instanceof RutaExpression) {
                RutaExpression e2 = (RutaExpression) arg2;
                if (e2.getKind() != RutaTypeConstants.RUTA_TYPE_S) {
                  IProblem problem = problemFactory.createWrongArgumentTypeProblem(e2, "String");
                  pr.reportProblem(problem);
                }
              }
            }
          }
        }
      }
    }
    if (s instanceof RutaCondition) {
      RutaCondition cond = (RutaCondition) s;
      String conditionName = sourceModule.getSource().substring(cond.getNameStart(),
              cond.getNameEnd());
      String[] keywords = RutaKeywordsManager.getKeywords(IRutaKeywords.CONDITION);
      List<String> asList = Arrays.asList(keywords);
      if (!StringUtils.isEmpty(conditionName) && !"-".equals(conditionName)
              && !asList.contains(conditionName) && !implicitString.equals(cond.getName())
              && !conditionExtensions.keySet().contains(conditionName)) {
        IProblem problem = problemFactory.createUnknownConditionProblem(cond);
        pr.reportProblem(problem);
      }

      IRutaExtension extension = conditionExtensions.get(conditionName);
      if (extension != null) {
        // boolean checkSyntax =
        extension.checkSyntax(cond, problemFactory, pr);
      }

      if (conditionName.equals("FEATURE")) {
        if (matchedType != null) {
          List<?> args = cond.getChilds();
          RutaStringExpression se = (RutaStringExpression) args.get(0);
          String feat = se.toString();
          feat = getFeatureName(se, feat);
          boolean featureFound = findFeature(matchedType, feat, -1);
          if (!featureFound) {
            String featureMatch = isFeatureMatch(matchedType);
            if (featureMatch != null) {
              featureFound = findFeature(featureMatch, feat, -1);
            }
          }
          if (!featureFound) {
            IProblem problem = problemFactory.createUnknownFeatureProblem(se, matchedType);
            pr.reportProblem(problem);
          }
        }
      }
      if (conditionName.equals("CONTAINS")) {
        List<?> args = cond.getChilds();
        boolean valid = checkContainsArguments(args);
        if (!valid) {
          IProblem problem = problemFactory.createWrongArgumentTypeProblem(cond,
                  "different combination of arguments.");
          pr.reportProblem(problem);
        }
      }

    }
    if (s instanceof RutaFunction) {
      RutaFunction f = (RutaFunction) s;
      String name = f.getName();
      if (s.getKind() == RutaTypeConstants.RUTA_TYPE_AT) {
        IRutaExtension extension = typeFunctionExtensions.get(name);
        if (extension != null) {
          extension.checkSyntax(s, problemFactory, pr);
        }
      } else if (s.getKind() == RutaTypeConstants.RUTA_TYPE_B) {
        IRutaExtension extension = booleanFunctionExtensions.get(name);
        if (extension != null) {
          extension.checkSyntax(s, problemFactory, pr);
        }
      } else if (s.getKind() == RutaTypeConstants.RUTA_TYPE_N) {
        IRutaExtension extension = numberFunctionExtensions.get(name);
        if (extension != null) {
          extension.checkSyntax(s, problemFactory, pr);
        }
      } else if (s.getKind() == RutaTypeConstants.RUTA_TYPE_S) {
        IRutaExtension extension = stringFunctionExtensions.get(name);
        if (extension != null) {
          extension.checkSyntax(s, problemFactory, pr);
        }
      }
    }
    return true;
  }

  @SuppressWarnings("unused")
  private boolean checkContainsArguments(List<?> args) {
    if (args.size() == 1) {
      Object arg = args.get(0);
      // if (arg instanceof ITypeExpression) {
      return true;
      // }
    } else if (args.size() == 2) {
      Object arg1 = args.get(0);
      Object arg2 = args.get(1);
      // if (arg1 instanceof ListExpression) {
      return true;
      // }
    } else if (args.size() == 3) {
      Object arg1 = args.get(0);
      Object arg2 = args.get(1);
      Object arg3 = args.get(2);
      // if (arg1 instanceof ITypeExpression && arg2 instanceof INumberExpression
      // && arg3 instanceof INumberExpression) {
      return true;
      // }
    } else if (args.size() == 4) {
      Object arg1 = args.get(0);
      Object arg2 = args.get(1);
      Object arg3 = args.get(2);
      Object arg4 = args.get(3);
      // if (arg1 instanceof ITypeExpression && arg2 instanceof INumberExpression
      // && arg3 instanceof INumberExpression && arg4 instanceof IBooleanExpression) {
      return true;
      // }
    } else if (args.size() == 5) {
      Object arg1 = args.get(0);
      Object arg2 = args.get(1);
      Object arg3 = args.get(2);
      Object arg4 = args.get(3);
      Object arg5 = args.get(3);
      // if (arg1 instanceof ListExpression && arg3 instanceof INumberExpression
      // && arg4 instanceof INumberExpression && arg5 instanceof IBooleanExpression) {
      return true;
      // }
    }
    return false;
  }

  private boolean isLabel(String name) {

    if (currentLabels.contains(name)) {
      return true;
    }

    if (name.contains(".")) {
      String[] split = name.split("[.]");
      if (split.length > 0) {
        return currentLabels.contains(split[0]);
      }
    }

    return false;
  }

  private String expand(String shortName) {
    if (shortName == null) {
      return null;
    }
    String longName = shortName;
    String string = namespaces.get(shortName);
    if (string != null) {
      longName = string;
    }
    return longName;
  }

  private void checkTypeOfFeatureMatch(String featText, FeatureMatchExpression fme) {
    int lastIndexOf = featText.lastIndexOf(".");
    int firstIndexOf = featText.indexOf(".");
    if (lastIndexOf == -1) {
      return;
    }
    String bref = featText.substring(0, firstIndexOf);
    String aref = featText.substring(0, lastIndexOf);
    String fref = featText.substring(lastIndexOf + 1, featText.length());
    if (currentLabels.contains(aref) || currentLabels.contains(bref)) {
      return;
    }
    String match = isFeatureMatch(aref);
    Integer variableType1 = getVariableType(aref);
    Integer variableType2 = getVariableType(bref);
    if (match == null && variableType1 != null && variableType2 != null
            && (variableType1 == RutaTypeConstants.RUTA_TYPE_AT
                    || variableType2 == RutaTypeConstants.RUTA_TYPE_AT
                    || variableType1 == RutaTypeConstants.RUTA_TYPE_UA)) {
      // do not check on variables!
      return;
    }

    // match expression against local annotation variables cannot be checked
    if (variableType2 == RutaTypeConstants.RUTA_TYPE_UA
            || variableType2 == RutaTypeConstants.RUTA_TYPE_UAL) {
      return;
    }

    match = expand(match);
    if (match != null) {
      int kind = -1;
      if (fme.getValue() != null) {
        kind = fme.getValue().getKind();
        if (fme.getValue() instanceof StringLiteral) {
          kind = RutaTypeConstants.RUTA_TYPE_S;
        } else if (fme.getValue() instanceof NumericLiteral) {
          kind = RutaTypeConstants.RUTA_TYPE_N;
        } else if (fme.getValue() instanceof RutaVariableReference) {
          kind = ((RutaVariableReference) fme.getValue()).getType();
        } else if (fme.getValue() instanceof RutaFunction) {
          // check on function deactivates, requires correct parsing of AST with external factory
          kind = -1;
        }
      }
      boolean findFeature = findFeature(match, fref, kind);
      if (findFeature || fme.getValue() instanceof NullExpression) {

      } else {
        pr.reportProblem(problemFactory.createUnknownFeatureProblem(fme, aref));
      }
    } else {
      pr.reportProblem(problemFactory.createTypeProblem(fme, sourceModule));
      pr.reportProblem(problemFactory.createUnknownFeatureProblem(fme, aref));
    }
  }

  @Override
  public boolean endvisit(Expression s) throws Exception {
    if (s instanceof RutaRuleElement) {
      matchedType = null;
    }
    return super.endvisit(s);
  }

  @Override
  public boolean endvisit(Statement s) throws Exception {
    if (s instanceof RutaDeclareDeclarationsStatement) {
      parentTypeInDeclaration = null;
    }
    if (s instanceof ForEachBlock) {
      knownLocalVariables.pop();
    }
    if (s instanceof RutaMacroDeclaration) {
      knownLocalVariables.pop();
    }
    if (!packageChecked) {
      checkPackage(null);
    }
    if (s instanceof RutaRule) {
      rules.pop();
      if (rules.isEmpty()) {
        currentLabels.clear();
      }
    }

    return super.endvisit(s);
  }

  @Override
  public boolean endvisit(MethodDeclaration s) throws Exception {
    if (s instanceof RutaBlock) {
      knownLocalVariables.pop();
      blocks.pop();
    }
    return super.endvisit(s);
  }

  @Override
  public boolean visit(MethodDeclaration s) throws Exception {
    if (s instanceof RutaBlock) {
      RutaBlock b = (RutaBlock) s;
      String name = b.getName();
      HashMap<String, Integer> map = new HashMap<String, Integer>();
      if (b instanceof ForEachBlock) {
        map.put(name, RutaTypeConstants.RUTA_TYPE_UA);
      }
      knownLocalVariables.push(map);
      blocks.push(name);
      // TODO add syntax check for block extensions
    }
    return true;
  }

  private boolean findFeature(String longTypeName, String featureName, int kind) {
    if (longTypeName == null) {
      return false;
    }
    if (longTypeName.equals("Document") || longTypeName.equals("org.apache.uima.ruta.type.Document")
            || longTypeName.equals("uima.tcas.DocumentAnnotation")) {
      if (featureName.equals("language") || featureName.equals("begin")
              || featureName.equals("end")) {
        return true;
      }
    }
    if (featureName.equals("begin") || featureName.equals("end")) {
      return kind == -1 || kind == RutaTypeConstants.RUTA_TYPE_N;
    }
    if (featureName.equals("ct") || featureName.equals("coveredText")) {
      return kind == -1 || kind == RutaTypeConstants.RUTA_TYPE_S;
    }
    Set<FeatureDescription> set = featureDescriptionMap.get(longTypeName);
    if (set != null) {
      for (FeatureDescription featureDescription : set) {
        String fName = featureDescription.getName();
        // TODO check on correct feature type, e.g., the type of the annotation
        if (fName.equals(featureName)
                && (kind == -1 || checkFeatureKind(featureDescription, kind))) {
          return true;
        }
      }
    }
    return false;
  }

  private boolean checkFeatureKind(FeatureDescription f, int kind) {
    if (kind == -1) {
      return true;
    }
    String t = f.getRangeTypeName();
    if (t.equals(CAS.TYPE_NAME_BOOLEAN) && RutaTypeConstants.RUTA_TYPE_B == kind) {
      return true;
    } else if (t.equals(CAS.TYPE_NAME_STRING) && RutaTypeConstants.RUTA_TYPE_S == kind) {
      return true;
    } else if ((t.equals(CAS.TYPE_NAME_BYTE) || t.equals(CAS.TYPE_NAME_DOUBLE)
            || t.equals(CAS.TYPE_NAME_FLOAT) || t.equals(CAS.TYPE_NAME_INTEGER)
            || t.equals(CAS.TYPE_NAME_LONG) || t.equals(CAS.TYPE_NAME_SHORT))
            && RutaTypeConstants.RUTA_TYPE_N == kind) {
      return true;
    } else if (RutaTypeConstants.RUTA_TYPE_AT == kind) {
      return true;
    }
    return false;
  }

  private void addDeclaredType(String shortName) {
    String longName = getLongNameOfNewType(shortName);
    importType(longName, shortName);
  }

  private String getLongNameOfNewType(String shortName) {
    String moduleName = sourceModule.getElementName();
    moduleName = moduleName.substring(0, moduleName.length() - 5);
    String packagePrefix = "";
    if (!packageName.isEmpty()) {
      packagePrefix = packageName + ".";
    }
    for (String each : blocks) {
      packagePrefix += each + ".";
    }
    String longName = packagePrefix + moduleName + "." + shortName;
    return longName;
  }

  /**
   * Import a type in the current namespace.
   * 
   * @param longName
   *          Complete type name.
   * @param shortName
   *          Short type name (without namespace).
   */
  private void importType(String longName, String shortName) {
    if (allLongTypeNames.contains(longName)) {
      // TODO: in conflict with double import
      // pr.reportProblem(problemFactory.createIdenticalLongTypeNameProblem(longName,
      // sourceModule));
    } else {
      allLongTypeNames.add(longName);
    }
    Set<String> targets = ambiguousTypeAlias.get(shortName);
    if (targets != null) {
      // shortName is already ambiguous, add longName to its list of possible targets
      targets.add(longName);
    } else {
      String existing = namespaces.put(shortName, longName);

      if (existing != null && !existing.equals(longName)) {
        // shortName can now be resolved to "existing" or "longName"
        targets = new HashSet<String>(2);
        targets.add(existing);
        targets.add(longName);

        // add existing mapping and longName to its list of possible targets
        ambiguousTypeAlias.put(shortName, targets);

        // remove shortName from the namespace because it is ambiguous
        namespaces.remove(shortName);
      }
    }
  }

  private boolean knowsVariable(String name) {
    for (Map<String, Integer> each : knownLocalVariables) {
      if (each.containsKey(name)) {
        return true;
      }
    }
    return false;
  }

  private Integer getVariableType(String name) {
    for (Map<String, Integer> each : knownLocalVariables) {
      Integer integer = each.get(name);
      if (integer != null) {
        return integer;
      }
    }
    return null;
  }

  private String getFeatureName(Expression expression, String defaultValue) {
    // TODO refactor AST. This is not a really straightforward!
    String result = defaultValue;
    List<?> childs = expression.getChilds();
    if (childs != null && !childs.isEmpty()) {
      Object object = childs.get(0);
      if (object instanceof ASTListNode) {
        List<?> childs2 = ((ASTListNode) object).getChilds();
        if (childs2 != null && !childs2.isEmpty()) {
          Object object2 = childs2.get(0);
          if (object2 instanceof StringLiteral) {
            StringLiteral sl = (StringLiteral) object2;
            result = sl.getValue().replaceAll("\"", "");
          }
        }
      }
    }
    return result;
  }

  private void initializePredefinedInformation() {

    typeDescriptionMap = new HashMap<String, TypeDescription>();
    featureDescriptionMap = new HashMap<String, Set<FeatureDescription>>();

    try {
      typeSystemDescription = getTypeSystemOfScript();
      IProject project = sourceModule.getScriptProject().getProject();
      List<IFolder> descriptorFolders = RutaProjectUtils.getDescriptorFolders(project);
      boolean exists = false;
      for (IFolder iFolder : descriptorFolders) {
        IPath basicTSD = iFolder.getLocation().append("BasicTypeSystem.xml");
        exists = basicTSD.toFile().exists();
        if (exists) {
          importCompleteTypeSystem(basicTSD, null);
          break;
        }
      }
      if (!exists) {
        // not in a common ruta project
        // try to find the file in the classpath
        URL resource = classLoader.getResource("org/apache/uima/ruta/engine/BasicTypeSystem.xml");
        importCompleteTypeSystem(null, resource);
      }
    } catch (Exception e) {
      RutaIdeUIPlugin.error(e);
    }
    if (typeSystemDescription != null) {
      TypeDescription[] descriptions = typeSystemDescription.getTypes();
      for (TypeDescription typeDescription : descriptions) {
        String typeName = typeDescription.getName();
        typeDescriptionMap.put(typeName, typeDescription);
      }

      for (TypeDescription typeDescription : descriptions) {
        Set<FeatureDescription> allFeatures = getAllDeclaredFeatures(typeDescription,
                typeDescriptionMap);
        featureDescriptionMap.put(typeDescription.getName(), allFeatures);
      }
    }

    List<String> uimaPredefTypes = Arrays.asList(new String[] { "uima.cas.Boolean", "uima.cas.Byte",
        "uima.cas.Short", "uima.cas.Integer", "uima.cas.Long", "uima.cas.Float", "uima.cas.Double",
        "uima.cas.String", "uima.cas.BooleanArray", "uima.cas.ByteArray", "uima.cas.ShortArray",
        "uima.cas.IntegerArray", "uima.cas.LongArray", "uima.cas.FloatArray",
        "uima.cas.DoubleArray", "uima.cas.StringArray", "uima.cas.FSArray",
        "uima.cas.AnnotationBase", "uima.tcas.Annotation", "uima.tcas.DocumentAnnotation",
        "uima.cas.FloatList", "uima.cas.IntegerList", "uima.cas.StringList", "uima.cas.FSList",
        "uima.cas.EmptyFloatList", "uima.cas.EmptyIntegerList", "uima.cas.EmptyStringList",
        "uima.cas.EmptyFSList", "uima.cas.NonEmptyFloatList", "uima.cas.NonEmptyIntegerList",
        "uima.cas.NonEmptyStringList", "uima.cas.NonEmptyFSList" });
    for (String longName : uimaPredefTypes) {
      String shortName = getShortName(longName);
      importType(longName, shortName);
    }

    this.finalTypes = new HashSet<String>();
    Set<String> uimaFinalTypes = new HashSet<String>();
    uimaFinalTypes.addAll(Arrays.asList(new String[] { "uima.cas.Boolean", "uima.cas.Byte",
        "uima.cas.Short", "uima.cas.Integer", "uima.cas.Long", "uima.cas.Float", "uima.cas.Double",
        "uima.cas.BooleanArray", "uima.cas.ByteArray", "uima.cas.ShortArray",
        "uima.cas.IntegerArray", "uima.cas.LongArray", "uima.cas.FloatArray",
        "uima.cas.DoubleArray", "uima.cas.StringArray", "uima.cas.FSArray" }));

    for (String string : uimaFinalTypes) {
      int indexOf = string.lastIndexOf('.');
      finalTypes.add(string);
      finalTypes.add(string.substring(indexOf + 1, string.length()));
    }
  }

  private TypeSystemDescription importCompleteTypeSystem(IPath path, URL url)
          throws InvalidXMLException, MalformedURLException, IOException, CoreException {
    return importTypeSystem(path, url, null, null, null);
  }

  private void initializeExtensionInformation() {
    conditionExtensions = new HashMap<String, IIDEConditionExtension>();
    actionExtensions = new HashMap<String, IIDEActionExtension>();
    numberFunctionExtensions = new HashMap<String, IIDENumberFunctionExtension>();
    booleanFunctionExtensions = new HashMap<String, IIDEBooleanFunctionExtension>();
    stringFunctionExtensions = new HashMap<String, IIDEStringFunctionExtension>();
    typeFunctionExtensions = new HashMap<String, IIDETypeFunctionExtension>();
    blockExtensions = new HashMap<String, IIDEBlockExtension>();
    IIDEConditionExtension[] cextensions = RutaExtensionManager.getDefault()
            .getIDEConditionExtensions();
    for (IIDEConditionExtension each : cextensions) {
      String[] knownExtensions = each.getKnownExtensions();
      for (String string : knownExtensions) {
        conditionExtensions.put(string, each);
      }
    }
    IIDEActionExtension[] aextensions = RutaExtensionManager.getDefault().getIDEActionExtensions();
    for (IIDEActionExtension each : aextensions) {
      String[] knownExtensions = each.getKnownExtensions();
      for (String string : knownExtensions) {
        actionExtensions.put(string, each);
      }
    }
    IIDENumberFunctionExtension[] nfextensions = RutaExtensionManager.getDefault()
            .getIDENumberFunctionExtensions();
    for (IIDENumberFunctionExtension each : nfextensions) {
      String[] knownExtensions = each.getKnownExtensions();
      for (String string : knownExtensions) {
        numberFunctionExtensions.put(string, each);
      }
    }
    IIDEBooleanFunctionExtension[] bfextensions = RutaExtensionManager.getDefault()
            .getIDEBooleanFunctionExtensions();
    for (IIDEBooleanFunctionExtension each : bfextensions) {
      String[] knownExtensions = each.getKnownExtensions();
      for (String string : knownExtensions) {
        booleanFunctionExtensions.put(string, each);
      }
    }
    IIDEStringFunctionExtension[] sfextensions = RutaExtensionManager.getDefault()
            .getIDEStringFunctionExtensions();
    for (IIDEStringFunctionExtension each : sfextensions) {
      String[] knownExtensions = each.getKnownExtensions();
      for (String string : knownExtensions) {
        stringFunctionExtensions.put(string, each);
      }
    }
    IIDETypeFunctionExtension[] tfextensions = RutaExtensionManager.getDefault()
            .getIDETypeFunctionExtensions();
    for (IIDETypeFunctionExtension each : tfextensions) {
      String[] knownExtensions = each.getKnownExtensions();
      for (String string : knownExtensions) {
        typeFunctionExtensions.put(string, each);
      }
    }
    IIDEBlockExtension[] bextensions = RutaExtensionManager.getDefault().getIDEBlockExtensions();
    for (IIDEBlockExtension each : bextensions) {
      String[] knownExtensions = each.getKnownExtensions();
      for (String string : knownExtensions) {
        blockExtensions.put(string, each);
      }
    }

  }

  private Set<FeatureDescription> getAllDeclaredFeatures(TypeDescription typeDescription,
          Map<String, TypeDescription> typeMap) {
    Set<FeatureDescription> result = new HashSet<FeatureDescription>();
    if (typeDescription == null) {
      return result;
    }
    FeatureDescription[] features = typeDescription.getFeatures();
    if (features == null) {
      return result;
    }
    result.addAll(Arrays.asList(features));
    String supertypeName = typeDescription.getSupertypeName();
    if (supertypeName != null) {
      TypeDescription parent = typeMap.get(supertypeName);
      result.addAll(getAllDeclaredFeatures(parent, typeMap));
    }
    return result;
  }

  private String isFeatureMatch(String text) {
    for (String each : namespaces.values()) {
      String t = checkFeatureMatch(text, each);
      if (t != null) {
        return t;
      }
    }
    for (String each : namespaces.keySet()) {
      String t = checkFeatureMatch(text, each);
      if (t != null) {
        return t;
      }
    }
    return null;
  }

  private String checkFeatureMatch(String name, String type) {
    if (name.startsWith(type)) {
      boolean foundAll = true;
      if (name.length() > type.length()) {
        String tail = name.substring(type.length() + 1);
        String[] split = tail.split("[.]");
        String typeToCheck = type;
        for (String feat : split) {
          typeToCheck = expand(typeToCheck);
          typeToCheck = checkFSFeatureOfType(feat, typeToCheck);
          if (StringUtils.contains(typeToCheck, CAS.TYPE_NAME_FS_ARRAY)) {
            // stop here because we do not know the type
            return CAS.TYPE_NAME_FS_ARRAY;
          }
          foundAll &= (typeToCheck != null);
          if (!foundAll) {
            return null;
          }
        }
        return typeToCheck;
      } else {
        return type;
      }
    } else {
      return null;
    }
  }

  private String checkFSFeatureOfType(String featureName, String longTypeName) {
    TypeDescription t = typeDescriptionMap.get(longTypeName);
    if (t == null) {
      return null;
    }
    FeatureDescription[] features = t.getFeatures();
    for (FeatureDescription featureDescription : features) {
      String name = featureDescription.getName();
      String rangeTypeName = featureDescription.getRangeTypeName();
      boolean isFS = isFeatureStructure(rangeTypeName);
      if (name.equals(featureName)) {
        if (isFS) {
          return rangeTypeName;
        } else if (StringUtils.equals(CAS.TYPE_NAME_FS_ARRAY, rangeTypeName)) {
          String elementType = featureDescription.getElementType();
          if (elementType == null) {
            return CAS.TYPE_NAME_FS_ARRAY;
          } else {
            return elementType;
          }
        }
      }
    }
    return null;
  }

  private boolean isFeatureStructure(String rangeTypeName) {
    if (rangeTypeName.equals("uima.tcas.Annotation") || rangeTypeName.equals("uima.cas.TOP")) {
      return true;
    }
    TypeDescription type = typeDescriptionMap.get(rangeTypeName);
    if (type == null) {
      return false;
    }
    String supertypeName = type.getSupertypeName();
    if (supertypeName != null) {
      return isFeatureStructure(supertypeName);
    }
    return false;
  }

  private boolean checkTypeOfVariable(RutaVariableReference ref) {
    Integer vt = getVariableType(ref.getName());
    if (vt == null) {
      IProblem problem = problemFactory.createUnknownVariableProblem(ref);
      pr.reportProblem(problem);
      return false;
    } else {
      int variableType = vt.intValue();
      int requiredType = ref.getType();
      // reject generic types
      if ((requiredType & RutaTypeConstants.RUTA_TYPE_G) != 0) {
        return true;
      }
      if ((variableType & requiredType) == 0) {
        String errMsg = "Variable \"" + ref.getName() + "\" has type "
                + RutaTypeConstants.typeStringOfInt.get(variableType) + ". But type "
                + RutaTypeConstants.typeStringOfInt.get(requiredType) + " is required.";
        IProblem problem = new RutaCheckerDefaultProblem(sourceModule.getElementName(), errMsg, ref,
                linetracker.getLineNumberOfOffset(ref.sourceStart()));
        pr.reportProblem(problem);
        return false;
      }
    }
    return true;
  }

  private boolean isVariableDeclared(RutaVariableReference ref) {
    if (!knowsVariable(ref.getName()) && !(ref instanceof NullExpression)) {
      // declared as type?
      if (namespaces.keySet().contains(ref.getName())) {
        String errMsg = "\"" + ref.getName() + "\" declared as a Type. Variable of type "
                + RutaTypeConstants.typeStringOfInt.get(ref.getType()) + " required.";
        IProblem problem = new RutaCheckerDefaultProblem(sourceModule.getElementName(), errMsg, ref,
                linetracker.getLineNumberOfOffset(ref.sourceStart()));
        pr.reportProblem(problem);
        return false;
      }
      String errMsgHead = "Variable \"";
      String errMsgTailDefault = " defined in this script or block!";

      // not found
      String errMsg = errMsgHead + ref.getName() + "\" not" + errMsgTailDefault;
      IProblem problem = new RutaCheckerDefaultProblem(sourceModule.getElementName(), errMsg, ref,
              linetracker.getLineNumberOfOffset(ref.sourceStart()));
      pr.reportProblem(problem);
      return false;
    }
    return true;
  }

  private String getShortName(String typeName) {
    String[] nameSpace = typeName.split("[.]");
    return nameSpace[nameSpace.length - 1];
  }

  private TypeSystemDescription getTypeSystemOfScript()
          throws InvalidXMLException, IOException, CoreException {
    IPath descriptorPath = RutaProjectUtils.getTypeSystemDescriptorPath(
            sourceModule.getResource().getLocation(), sourceModule.getScriptProject().getProject(),
            classLoader);
    if (descriptorPath == null) {
      return null;
    }

    TypeSystemDescription typeSysDescr = null;
    if (descriptorPath.toFile().exists()) {
      typeSysDescr = UIMAFramework.getXMLParser()
              .parseTypeSystemDescription(new XMLInputSource(descriptorPath.toPortableString()));
      ResourceManager resMgr = getResourceManager(classLoader);
      typeSysDescr.resolveImports(resMgr);
    } else {
      // backup: just search for the file named correctly
      String lastSegment = descriptorPath.lastSegment();
      PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(
              classLoader);
      String prefix = "classpath*:**/";
      String pattern = prefix + lastSegment;
      Resource[] resources = resolver.getResources(pattern);
      if (resources != null && resources.length != 0) {
        typeSysDescr = UIMAFramework.getXMLParser()
                .parseTypeSystemDescription(new XMLInputSource(resources[0].getURL()));
        ResourceManager resMgr = getResourceManager(classLoader);
        typeSysDescr.resolveImports(resMgr);
      }
    }
    return typeSysDescr;
  }

  private String translate(String name) {
    if (name == null) {
      return null;
    }
    if (name.equals("Annotation")) {
      return "uima.tcas.Annotation";
    } else if (name.equals("STRING")) {
      return CAS.TYPE_NAME_STRING;
    } else if (name.equals("INT")) {
      return CAS.TYPE_NAME_INTEGER;
    } else if (name.equals("DOUBLE")) {
      return CAS.TYPE_NAME_DOUBLE;
    } else if (name.equals("FLOAT")) {
      return CAS.TYPE_NAME_FLOAT;
    } else if (name.equals("BOOLEAN")) {
      return CAS.TYPE_NAME_BOOLEAN;
    } else if (name.equals("TYPE")) {
      return CAS.TYPE_NAME_STRING;
    }
    return name;
  }

  private int getType(String name) {
    if (name == null) {
      return 0;
    }
    // TODO reuse field in constants
    if (name.equals("STRING")) {
      return RutaTypeConstants.RUTA_TYPE_S;
    } else if (name.equals("STRINGLIST")) {
      return RutaTypeConstants.RUTA_TYPE_SL;
    } else if (name.equals("INT")) {
      return RutaTypeConstants.RUTA_TYPE_I;
    } else if (name.equals("INTLIST")) {
      return RutaTypeConstants.RUTA_TYPE_NL;
    } else if (name.equals("DOUBLE")) {
      return RutaTypeConstants.RUTA_TYPE_D;
    } else if (name.equals("DOUBLELIST")) {
      return RutaTypeConstants.RUTA_TYPE_NL;
    } else if (name.equals("FLOAT")) {
      return RutaTypeConstants.RUTA_TYPE_F;
    } else if (name.equals("FLOATLIST")) {
      return RutaTypeConstants.RUTA_TYPE_NL;
    } else if (name.equals("BOOLEAN")) {
      return RutaTypeConstants.RUTA_TYPE_B;
    } else if (name.equals("BOOLEANLIST")) {
      return RutaTypeConstants.RUTA_TYPE_BL;
    } else if (name.equals("TYPE")) {
      return RutaTypeConstants.RUTA_TYPE_AT;
    } else if (name.equals("TYPELIST")) {
      return RutaTypeConstants.RUTA_TYPE_TL;
    } else if (name.equals("ANNOTATION")) {
      return RutaTypeConstants.RUTA_TYPE_UA;
    } else if (name.equals("ANNOTATIONLIST")) {
      return RutaTypeConstants.RUTA_TYPE_UAL;
    }
    return 0;
  }

}