/*
* Copyright 2010 The authors
* Licensed 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 com.intellij.struts2.reference.web;
import com.intellij.codeInsight.daemon.EmptyResolveMessageProvider;
import com.intellij.codeInsight.lookup.LookupElement;
import com.intellij.javaee.model.xml.ParamValue;
import com.intellij.openapi.util.Pair;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiPackage;
import com.intellij.psi.PsiReference;
import com.intellij.psi.PsiReferenceBase;
import com.intellij.psi.impl.source.resolve.reference.impl.providers.JavaClassReference;
import com.intellij.psi.xml.XmlTag;
import com.intellij.struts2.model.constant.StrutsConstantKey;
import com.intellij.struts2.model.constant.StrutsConstantManager;
import com.intellij.util.ArrayUtil;
import com.intellij.util.Consumer;
import com.intellij.util.xml.*;
import com.intellij.util.xml.impl.ConvertContextFactory;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.*;
/**
* Delegates {@link com.intellij.struts2.model.constant.StrutsConstant#getConverter()} references.
*
* @author Yann Cébron
*/
class StrutsConstantValueReference extends PsiReferenceBase<XmlTag> implements EmptyResolveMessageProvider {
@Nullable
private final Pair<DomElement, Converter> elementConverterPair;
StrutsConstantValueReference(@NotNull final XmlTag xmlTag) {
super(xmlTag, false);
elementConverterPair = getElementConverterPair();
}
@SuppressWarnings({"unchecked"})
public PsiElement resolve() {
if (elementConverterPair == null) {
return myElement;
}
final Converter converter = elementConverterPair.getSecond();
final ConvertContext convertContext = ConvertContextFactory.createConvertContext(elementConverterPair.first);
// additional variants (String only)
if (converter instanceof ResolvingConverter) {
final Set additionalVariants = ((ResolvingConverter) converter).getAdditionalVariants(convertContext);
if (additionalVariants.contains(getValue())) {
return myElement;
}
}
// "normal" reference
final Object resolveObject = converter.fromString(getValue(), convertContext);
if (resolveObject == null) {
return null;
}
// DomElement
if (resolveObject instanceof DomElement) {
return ((DomElement) resolveObject).getXmlTag();
}
// fake self-reference (e.g. String value from Converter)
if (!(resolveObject instanceof PsiElement)) {
return myElement;
}
// "real" reference
return (PsiElement) resolveObject;
}
@NotNull
public String getUnresolvedMessagePattern() {
assert elementConverterPair != null;
return elementConverterPair.second
.getErrorMessage(getValue(), ConvertContextFactory.createConvertContext(elementConverterPair.first));
}
@NotNull
@SuppressWarnings({"unchecked"})
public Object[] getVariants() {
if (elementConverterPair == null) {
return ArrayUtil.EMPTY_OBJECT_ARRAY;
}
final Converter converter = elementConverterPair.second;
if (!(converter instanceof ResolvingConverter)) {
return ArrayUtil.EMPTY_OBJECT_ARRAY;
}
final ResolvingConverter resolvingConverter = (ResolvingConverter) converter;
// merge "normal" + additional variants
final DomElement paramValueElement = elementConverterPair.first;
final ConvertContext convertContext = ConvertContextFactory.createConvertContext(paramValueElement);
// wrap explicitly for empty list
final Collection converterVariants = new ArrayList(resolvingConverter.getVariants(convertContext));
final Collection variants;
if (!converterVariants.isEmpty() &&
converterVariants.iterator().next() instanceof DomElement) {
variants = Arrays.asList(ElementPresentationManager.getInstance().createVariants(converterVariants));
} else {
variants = converterVariants;
}
variants.addAll(resolvingConverter.getAdditionalVariants(convertContext));
// add custom created references
if (resolvingConverter instanceof CustomReferenceConverter) {
final PsiReference[] references = ((CustomReferenceConverter) resolvingConverter).
createReferences((GenericDomValue) paramValueElement,
myElement,
convertContext);
for (final PsiReference customReference : references) {
if (customReference instanceof JavaClassReference) {
JavaClassReference javaClassReference = (JavaClassReference)customReference;
String[] names = javaClassReference.getExtendClassNames();
PsiElement context = javaClassReference.getCompletionContext();
if (names != null && context instanceof PsiPackage) {
javaClassReference.processSubclassVariants((PsiPackage)context, names, new Consumer<LookupElement>() {
@Override
public void consume(LookupElement element) {
variants.add(element);
}
});
continue;
}
}
Collections.addAll(variants, customReference.getVariants());
}
}
return ArrayUtil.toObjectArray(variants);
}
/**
* Gets the DomElement and corresponding converter.
*
* @return {@code null} on errors or if one of both could not be resolved.
*/
@Nullable
private Pair<DomElement, Converter> getElementConverterPair() {
final DomElement paramValueElement = DomUtil.getDomElement(myElement);
assert paramValueElement != null;
final DomElement domElement = paramValueElement.getParent();
assert domElement instanceof ParamValue;
final ParamValue initParamElement = (ParamValue) domElement;
final String paramName = initParamElement.getParamName().getStringValue();
if (StringUtil.isEmpty(paramName)) {
return null;
}
final StrutsConstantManager constantManager = StrutsConstantManager.getInstance(myElement.getProject());
@SuppressWarnings({"ConstantConditions"})
final Converter converter = constantManager.findConverter(myElement, StrutsConstantKey.create(paramName));
if (converter == null) {
return null;
}
return Pair.create(paramValueElement, converter);
}
}