/*
 * 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.core;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.dltk.ast.references.SimpleReference;
import org.eclipse.dltk.compiler.SourceElementRequestorAdaptor;
import org.eclipse.dltk.compiler.env.MethodSourceCode;
import org.eclipse.dltk.core.DLTKCore;
import org.eclipse.dltk.core.DLTKLanguageManager;
import org.eclipse.dltk.core.ICalleeProcessor;
import org.eclipse.dltk.core.IMethod;
import org.eclipse.dltk.core.IModelElement;
import org.eclipse.dltk.core.ISourceElementParser;
import org.eclipse.dltk.core.ISourceModule;
import org.eclipse.dltk.core.ModelException;
import org.eclipse.dltk.core.search.IDLTKSearchScope;
import org.eclipse.dltk.core.search.SearchEngine;
import org.eclipse.dltk.core.search.SearchParticipant;
import org.eclipse.dltk.core.search.SearchPattern;
import org.eclipse.dltk.core.search.SearchRequestor;

public class RutaCalleeProcessor implements ICalleeProcessor {
  protected static int EXACT_RULE = SearchPattern.R_EXACT_MATCH | SearchPattern.R_CASE_SENSITIVE;

  private Map fSearchResults = new HashMap();

  private IMethod method;

  // private IDLTKSearchScope scope;

  public RutaCalleeProcessor(IMethod method, IProgressMonitor monitor, IDLTKSearchScope scope) {
    this.method = method;
    // this.scope = scope;
  }

  private class CaleeSourceElementRequestor extends SourceElementRequestorAdaptor {

    @Override
    public void acceptMethodReference(String methodName, int argCount, int sourcePosition,
            int sourceEndPosition) {
      String name = new String(methodName);
      int off = 0;
      try {
        off = method.getSourceRange().getOffset();
      } catch (ModelException e) {
        if (DLTKCore.DEBUG) {
          e.printStackTrace();
        }
      }
      SimpleReference ref = new SimpleReference(off + sourcePosition, off + sourceEndPosition, name);
      IMethod[] methods = findMethods(name, argCount, off + sourcePosition);
      fSearchResults.put(ref, methods);
    }
  }

  public Map doOperation() {
    try {
      if (method.getSource() != null) {
        CaleeSourceElementRequestor requestor = new CaleeSourceElementRequestor();
        ISourceElementParser parser = DLTKLanguageManager
                .getSourceElementParser(RutaNature.NATURE_ID);
        parser.setRequestor(requestor);
        parser.parseSourceModule(new MethodSourceCode(method));
      } else {
        // TODO: Report error here.
      }
      return fSearchResults;
    } catch (ModelException e) {
      if (DLTKCore.DEBUG) {
        e.printStackTrace();
      }
    } catch (CoreException e) {
      if (DLTKCore.DEBUG) {
        e.printStackTrace();
      }
    }
    return fSearchResults;
  }

  public IMethod[] findMethods(final String methodName, int argCount, int sourcePosition) {
    final List methods = new ArrayList();
    ISourceModule module = this.method.getSourceModule();
    try {
      IModelElement[] elements = module.codeSelect(sourcePosition, methodName.length());
      for (int i = 0; i < elements.length; ++i) {
        if (elements[i] instanceof IMethod) {
          methods.add(elements[i]);
        }
      }
    } catch (ModelException e) {
      if (DLTKCore.DEBUG) {
        e.printStackTrace();
      }
    }
    // final String nsName;
    // if( methodName.indexOf("::") != -1 ) {
    // String mmName = methodName;
    // if( mmName.startsWith("::")) {
    // mmName = mmName.substring(2);
    // }
    // if( mmName.indexOf("::") != -1 ) {
    // int posb = mmName.indexOf("::");
    // nsName = mmName.substring(0, posb);
    // }
    // else {
    // nsName = null;
    // }
    // }
    // else {
    // nsName = null;
    // }
    // SearchRequestor requestor = new SearchRequestor() {
    // public void acceptSearchMatch(SearchMatch match) throws CoreException
    // {
    // Object element = match.getElement();
    // if( element instanceof IMethod ) {
    // IMethod method = (IMethod)element;
    // String mn = method.getTypeQualifiedName('$', false).replaceAll("\\$",
    // "::");
    // if( mn.equals(methodName) && !isIgnoredBySearchScope(method) ) {
    // methods.add(method);
    // }
    // }
    // else {
    // IType type = (IType) element;
    // if( !( type.getParent() instanceof ISourceModule )) {
    // return;
    // }
    // processTypeFunctions(type);
    // }
    // }
    // private void processTypeFunctions(IType type) throws ModelException {
    // IMethod[] tmethods = type.getMethods();
    // for (int i = 0; i < tmethods.length; ++i) {
    // String mn = tmethods[i].getTypeQualifiedName('$',
    // false).replaceAll("\\$", "::");
    // if( mn.equals(methodName) && !isIgnoredBySearchScope(tmethods[i]) ) {
    // methods.add(tmethods[i]);
    // }
    // }
    // IType[] types = type.getTypes();
    // for( int i = 0; i < types.length; ++i ) {
    // processTypeFunctions(types[i]);
    // }
    // }
    // };
    //
    // try {
    // String pattern = methodName;
    // if( pattern.startsWith("::")) {
    // pattern = pattern.substring(2);
    // }
    // if( pattern.indexOf("::")==-1) {
    // search(pattern, IDLTKSearchConstants.METHOD,
    // IDLTKSearchConstants.DECLARATIONS, scope, requestor);
    // }
    // if( nsName != null ) {
    // search(nsName, IDLTKSearchConstants.TYPE,
    // IDLTKSearchConstants.DECLARATIONS, scope, requestor);
    // }
    // } catch (CoreException e) {
    // // TODO Auto-generated catch block
    // e.printStackTrace();
    // }

    return (IMethod[]) methods.toArray(new IMethod[methods.size()]);
  }

  protected void search(String patternString, int searchFor, int limitTo, IDLTKSearchScope scope,
          SearchRequestor resultCollector) throws CoreException {
    search(patternString, searchFor, limitTo, EXACT_RULE, scope, resultCollector);
  }

  protected void search(String patternString, int searchFor, int limitTo, int matchRule,
          IDLTKSearchScope scope, SearchRequestor requestor) throws CoreException {
    if (patternString.indexOf('*') != -1 || patternString.indexOf('?') != -1) {
      matchRule |= SearchPattern.R_PATTERN_MATCH;
    }
    SearchPattern pattern = SearchPattern.createPattern(patternString, searchFor, limitTo,
            matchRule, scope.getLanguageToolkit());
    new SearchEngine().search(pattern,
            new SearchParticipant[] { SearchEngine.getDefaultSearchParticipant() }, scope,
            requestor, null);
  }
}