/*
 * Copyright (c) 2016 Google Inc.
 *
 * All rights reserved. This program and the accompanying materials are
 * made available under the terms of the Eclipse Public License v1.0 which
 * accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 */
package com.google.eclipse.protobuf.scoping;

import static com.google.eclipse.protobuf.util.Tracer.DEBUG_SCOPING;
import static com.google.eclipse.protobuf.validation.ProtobufResourceValidator.getScopeProviderTimingCollector;
import static java.util.Collections.singletonList;

import com.google.eclipse.protobuf.naming.ProtobufQualifiedNameConverter;
import com.google.eclipse.protobuf.naming.ProtobufQualifiedNameProvider;
import com.google.eclipse.protobuf.protobuf.ComplexType;
import com.google.eclipse.protobuf.protobuf.ComplexTypeLink;
import com.google.eclipse.protobuf.protobuf.ComplexValue;
import com.google.eclipse.protobuf.protobuf.ComplexValueField;
import com.google.eclipse.protobuf.protobuf.CustomFieldOption;
import com.google.eclipse.protobuf.protobuf.CustomOption;
import com.google.eclipse.protobuf.protobuf.DefaultValueFieldOption;
import com.google.eclipse.protobuf.protobuf.ExtensionFieldName;
import com.google.eclipse.protobuf.protobuf.FieldName;
import com.google.eclipse.protobuf.protobuf.Group;
import com.google.eclipse.protobuf.protobuf.IndexedElement;
import com.google.eclipse.protobuf.protobuf.LiteralLink;
import com.google.eclipse.protobuf.protobuf.MessageField;
import com.google.eclipse.protobuf.protobuf.NativeFieldOption;
import com.google.eclipse.protobuf.protobuf.NativeOption;
import com.google.eclipse.protobuf.protobuf.OneOf;
import com.google.eclipse.protobuf.protobuf.OptionField;
import com.google.eclipse.protobuf.protobuf.OptionSource;
import com.google.eclipse.protobuf.protobuf.Package;
import com.google.eclipse.protobuf.protobuf.Protobuf;
import com.google.eclipse.protobuf.protobuf.SimpleValueField;
import com.google.eclipse.protobuf.protobuf.TypeLink;
import com.google.eclipse.protobuf.protobuf.ValueField;
import com.google.eclipse.protobuf.util.EResources;
import com.google.inject.Inject;
import com.google.inject.Provider;

import org.eclipse.core.resources.IProject;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.xtext.naming.QualifiedName;
import org.eclipse.xtext.scoping.IScope;
import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider;
import org.eclipse.xtext.scoping.impl.ImportNormalizer;
import org.eclipse.xtext.util.IResourceScopeCache;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

/**
 * A scope provider for the Protobuf language.
 *
 * @author atrookey@google.com (Alexander Rookey)
 */
public class ProtobufScopeProvider extends AbstractDeclarativeScopeProvider {

  @Inject private ProtoDescriptorProvider descriptorProvider;
  @Inject private IResourceScopeCache cache;
  @Inject private ProtobufQualifiedNameConverter nameConverter;
  @Inject private ProtobufQualifiedNameProvider nameProvider;

  private ImportNormalizer createImportNormalizerForEObject(EObject element, boolean ignoreCase) {
    QualifiedName name = nameProvider.getFullyQualifiedName(element);
    return getLocalScopeProvider().createImportedNamespaceResolver(name.toString(), ignoreCase);
  }

  private List<ImportNormalizer> createImportNormalizersForComplexType(
      ComplexType complexType, boolean ignoreCase) {
    List<ImportNormalizer> normalizers = new ArrayList<>();
    normalizers.add(createImportNormalizerForEObject(complexType, ignoreCase));
    normalizers.addAll(createImportNormalizersForOneOf(complexType.eContents(), ignoreCase));
    return normalizers;
  }

  private List<ImportNormalizer> createImportNormalizersForOneOf(
      EList<EObject> children, boolean ignoreCase) {
    List<ImportNormalizer> normalizers = new ArrayList<>();
    for (EObject child : children) {
      if (child instanceof OneOf) {
        normalizers.add(createImportNormalizerForEObject(child, ignoreCase));
        normalizers.addAll(createImportNormalizersForOneOf(child.eContents(), ignoreCase));
      }
    }
    return normalizers;
  }

  /**
   * An {@code IndexedElement} can be a MessageField or Group. When scoping types {@code FieldName},
   * {@code LiteralLink}, or {@code OptionField} that are all related to protocol buffer options, a
   * scope can be created by traversing the EMF Model to find a suitable {@code IndexedElement}, and
   * then creating an import normalized scope for the {@code ComplexType} of the {@code
   * MessageField} or {@code Group}.
   *
   * <p>For example: <pre>
   * enum MyEnum {
   *   FOO = 1;
   * }
   * extend google.protobuf.ServiceOptions {
   *   optional MyEnum my_service_option = 50005;
   * }
   * service MyService {
   *   option (my_service_option) = FOO;
   * }
   * </pre>
   *
   * To scope the {@code LiteralLink} {@code FOO} in {@code MyService}, the {@code MessageField}
   * {@code my_service_option} is found by traversing the model. The method
   * createNormalizedScopeForIndexedElement(IndexedElement, EReference) creates and returns an
   * import normalized scope for the type of the {@code MessageField}, {@code MyEnum}.
   */
  private IScope createNormalizedScopeForIndexedElement(
      IndexedElement indexedElement, EReference reference) {
    HashMap<EReference, IScope> scopeMap =
        cache.get(
            indexedElement,
            indexedElement.eResource(),
            new Provider<HashMap<EReference, IScope>>() {
              @Override
              public HashMap<EReference, IScope> get() {
                return new HashMap<>();
              }
            });
    if (!scopeMap.containsKey(reference)) {
      IScope scope = null;
      if (indexedElement instanceof MessageField) {
        TypeLink typeLink = ((MessageField) indexedElement).getType();
        if (typeLink instanceof ComplexTypeLink) {
          ComplexType complexType = ((ComplexTypeLink) typeLink).getTarget();
          scope = getGlobalScopeProvider().getScope(complexType.eResource(), reference);
          List<ImportNormalizer> normalizers =
              createImportNormalizersForComplexType(complexType, false);
          scope = createProtobufImportScope(scope, complexType, reference, normalizers);
        }
      }
      if (indexedElement instanceof Group) {
        Group group = (Group) indexedElement;
        scope = getGlobalScopeProvider().getScope(group.eResource(), reference);
        ImportNormalizer normalizer = createImportNormalizerForEObject(group, false);
        scope = createProtobufImportScope(scope, group, reference, singletonList(normalizer));
      }
      scopeMap.put(reference, scope);
    }
    return scopeMap.get(reference);
  }

  /**
   * Let the local scope provider compute the list of {@link ImportNormalizer}s to be associated with
   * the {@link ProtobufImportScope}.
   */
  private IScope createProtobufImportScope(IScope parent, EObject context, EReference reference) {
    IScope scope = parent;
    if (context.eContainer() == null) {
      scope = getLocalScopeProvider().getResourceScope(scope, context, reference);
    } else {
      scope = createProtobufImportScope(scope, context.eContainer(), reference);
    }
    return getLocalScopeProvider().getLocalElementsScope(scope, context, reference);
  }

  /**
   * Associate the {@link ProtobufImportScope} with the list of {@link ImportNormalizer}s
   * passed as an argument.
   */
  private IScope createProtobufImportScope(
      IScope parent, EObject context, EReference reference, List<ImportNormalizer> normalizers) {
    IScope scope = parent;
    if (context.eContainer() == null) {
      scope = getLocalScopeProvider().getResourceScope(scope, context, reference);
    } else {
      scope = createProtobufImportScope(scope, context.eContainer(), reference, normalizers);
    }
    return getLocalScopeProvider().getLocalElementsScope(scope, context, reference, normalizers);
  }

  /** Returns descriptor associated with the current project. */
  private @Nullable Resource getDescriptorResource(EObject context) {
    IProject project = EResources.getProjectOf(context.eResource());
    ResourceSet resourceSet = context.eResource().getResourceSet();
    ProtoDescriptorProvider.ProtoDescriptorInfo descriptorInfo =
        descriptorProvider.primaryDescriptor(project);
    return resourceSet.getResource(descriptorInfo.location, true);
  }

  /** Returns the global scope provider. */
  private ProtobufImportUriGlobalScopeProvider getGlobalScopeProvider() {
    return getLocalScopeProvider().getGlobalScopeProvider();
  }

  /** Returns the local scope provider. */
  private ProtobufImportedNamespaceAwareLocalScopeProvider getLocalScopeProvider() {
    return (ProtobufImportedNamespaceAwareLocalScopeProvider) super.getDelegate();
  }

  // TODO (atrookey) Create utility for getting package.
  private String getPackageOfResource(Resource resource) {
    return cache.get(
        "Package",
        resource,
        new Provider<String>() {
          @Override
          public String get() {
            Protobuf protobuf;
            if (resource != null && (protobuf = (Protobuf) resource.getContents().get(0)) != null) {
              for (EObject content : protobuf.getElements()) {
                if (content instanceof Package) {
                  return ((Package) content).getImportedNamespace();
                }
              }
            }
            return "";
          }
        });
  }

  @Override
  public IScope getScope(EObject context, EReference reference) {
    if (DEBUG_SCOPING) {
      getScopeProviderTimingCollector().startTimer();
    }
    IScope scope = super.getScope(context, reference);
    if (DEBUG_SCOPING) {
      getScopeProviderTimingCollector().stopTimer();
    }
    return scope;
  }

  /**
   * Scopes the {@code FieldName}.
   *
   * <p>For example: <pre>
   * message FooOptions {
   *   optional int32 opt1 = 1;
   * }
   * extend google.protobuf.FieldOptions {
   *   optional FooOptions foo_options = 1234;
   * }
   * message Bar {
   *   optional int32 b = 1 [(foo_options) = { opt1: 123 }];
   * }
   * </pre>
   *
   * The {@code NormalFieldName} {@code opt1} contains a cross-reference to {@code FooOptions.opt1}.
   */
  public IScope scope_FieldName_target(FieldName fieldName, EReference reference) {
    if (fieldName instanceof ExtensionFieldName) {
      return getLocalScopeProvider().getResourceScope(fieldName.eResource(), reference);
    }
    IndexedElement indexedElement = null;
    OptionSource optionSource = null;
    EObject valueField = fieldName.eContainer();
    if (valueField instanceof ValueField) {
      EObject complexValue = valueField.eContainer();
      if (complexValue instanceof ComplexValue) {
        EObject unknownOption = complexValue.eContainer();
        if (unknownOption instanceof ComplexValueField) {
          indexedElement = ((ComplexValueField) unknownOption).getName().getTarget();
        }
        if (unknownOption instanceof NativeFieldOption) {
          NativeFieldOption nativeFieldOption = (NativeFieldOption) unknownOption;
          optionSource = nativeFieldOption.getSource();
        }
        if (unknownOption instanceof CustomFieldOption) {
          CustomFieldOption customFieldOption = (CustomFieldOption) unknownOption;
          optionSource = customFieldOption.getSource();
        }
        if (unknownOption instanceof NativeOption) {
          NativeOption option = (NativeOption) unknownOption;
          optionSource = option.getSource();
        }
        if (unknownOption instanceof CustomOption) {
          CustomOption option = (CustomOption) unknownOption;
          optionSource = option.getSource();
        }
        if (optionSource != null) {
          indexedElement = optionSource.getTarget();
        }
        if (indexedElement instanceof MessageField) {
          return createNormalizedScopeForIndexedElement(indexedElement, reference);
        }
      }
    }
    return null;
  }

  /**
   * Creates a scope containing elements of type {@code Literal} that can be referenced with their
   * local name only.
   *
   * <p>For example: <pre>
   * enum MyEnum {
   *   FOO = 1;
   * }
   * extend google.protobuf.ServiceOptions {
   *   optional MyEnum my_service_option = 50005;
   * }
   * service MyService {
   *   option (my_service_option) = FOO;
   * }
   * </pre>
   *
   * The {@code LiteralLink} {@code FOO} contains a cross-reference to {@code MyEnum.FOO}.
   */
  public @Nullable IScope scope_LiteralLink_target(LiteralLink literalLink, EReference reference) {
    EObject container = literalLink.eContainer();
    IndexedElement indexedElement = null;
    if (container instanceof DefaultValueFieldOption) {
      container = container.eContainer();
      if (container instanceof IndexedElement) {
        indexedElement = (IndexedElement) container;
      }
    }
    if (container instanceof NativeFieldOption) {
      indexedElement = ((NativeFieldOption) container).getSource().getTarget();
    }
    if (container instanceof NativeOption) {
      indexedElement = ((NativeOption) container).getSource().getTarget();
    }
    if (container instanceof CustomFieldOption) {
      EList<OptionField> fields = ((CustomFieldOption) container).getFields();
      if (!fields.isEmpty()) {
        indexedElement = fields.get(fields.size() - 1).getTarget();
      } else {
        indexedElement = ((CustomFieldOption) container).getSource().getTarget();
      }
    }
    if (container instanceof CustomOption) {
      EList<OptionField> fields = ((CustomOption) container).getFields();
      if (!fields.isEmpty()) {
        indexedElement = fields.get(fields.size() - 1).getTarget();
      } else {
        indexedElement = ((CustomOption) container).getSource().getTarget();
      }
    }
    if (container instanceof SimpleValueField) {
      indexedElement = ((SimpleValueField) container).getName().getTarget();
    }
    return createNormalizedScopeForIndexedElement(indexedElement, reference);
  }

  /**
   * Recursively scopes the {@code OptionField} starting with the {@code OptionSource}.
   *
   * <p>For example: <pre>
   * message Code {
   *   optional double number = 1;
   * }
   * message Type {
   *   optional Code code = 1;
   * }
   * extend proto2.FieldOptions {
   *   optional Type type = 1000;
   * }
   * message Person {
   *   optional bool active = 1 [(type).code.number = 68];
   * }
   * </pre>
   *
   * The {@code OptionField} {@code number} contains a cross-reference to {@code Code.number}.
   */
  public IScope scope_OptionField_target(OptionField optionField, EReference reference) {
    IScope scope = getLocalScopeProvider().getResourceScope(optionField.eResource(), reference);
    EObject customOption = optionField.eContainer();
    if (customOption != null) {
      OptionSource optionSource = null;
      EList<OptionField> fields = null;
      if (customOption instanceof CustomFieldOption) {
        optionSource = ((CustomFieldOption) customOption).getSource();
        fields = ((CustomFieldOption) customOption).getFields();
      }
      if (customOption instanceof CustomOption) {
        optionSource = ((CustomOption) customOption).getSource();
        fields = ((CustomOption) customOption).getFields();
      }
      if (optionSource != null && fields != null) {
        int index = fields.indexOf(optionField);
        if (index < 0 || fields.size() <= index) {
          throw new IllegalArgumentException(
              "index is " + index + " but field.size() is " + fields.size());
        }
        IndexedElement indexedElement = null;
        if (index == 0) {
          indexedElement = optionSource.getTarget();
        } else {
          indexedElement = fields.get(index - 1).getTarget();
        }
        return createNormalizedScopeForIndexedElement(indexedElement, reference);
      }
    }
    return scope;
  }

  /**
   * Creates a scope containing the default options defined in descriptor.proto.
   *
   * <p>For example: <pre>
   * option java_package = "com.example.foo";
   * </pre>
   *
   * The {@code OptionSource} {@code java_package} contains a cross-reference to {@code
   * google.protobuf.FileOptions.java_package} defined in descriptor.proto.
   */
  public IScope scope_OptionSource_target(OptionSource optionSource, EReference reference) {
    String optionType = OptionType.typeOf(optionSource).messageName();
    Resource resource = optionSource.eResource();
    IScope descriptorScope =
        cache.get(
            optionType,
            resource,
            new Provider<IScope>() {
              @Override
              public IScope get() {
                IScope scope = getGlobalScopeProvider().getScope(resource, reference);
                Resource descriptorResource = getDescriptorResource(optionSource);
                String descriptorMessage =
                    getPackageOfResource(descriptorResource)
                        + nameConverter.getDelimiter()
                        + optionType;
                ImportNormalizer normalizer =
                    getLocalScopeProvider()
                        .createImportedNamespaceResolver(descriptorMessage, false);
                scope =
                    createProtobufImportScope(
                        scope,
                        descriptorResource.getContents().get(0),
                        reference,
                        singletonList(normalizer));
                return scope;
              }
            });
    return createProtobufImportScope(descriptorScope, optionSource, reference);
  }
}