/*
 * Copyright 2002-2019 the original author or 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
 *
 *      https://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.springframework.integration.http.config;

import java.util.List;

import org.w3c.dom.Element;

import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.ManagedMap;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.beans.factory.xml.ParserContext;
import org.springframework.expression.common.LiteralExpression;
import org.springframework.integration.config.ExpressionFactoryBean;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import org.springframework.util.xml.DomUtils;

/**
 * @author Oleg Zhurakousky
 * @author Mark Fisher
 * @author Gary Russell
 * @author Artem Bilan
 * @author Shiliang Li
 * @since 2.0.2
 */
abstract class HttpAdapterParsingUtils {

	static final String[] SYNC_REST_TEMPLATE_REFERENCE_ATTRIBUTES = {
			"request-factory", "error-handler", "message-converters"
	};

	static void verifyNoRestTemplateAttributes(Element element, ParserContext parserContext) {
		for (String attributeName : SYNC_REST_TEMPLATE_REFERENCE_ATTRIBUTES) {
			if (element.hasAttribute(attributeName)) {
				parserContext.getReaderContext().error("When providing a 'rest-template' reference, the '"
								+ attributeName + "' attribute is not allowed.",
						parserContext.extractSource(element));
			}
		}
	}

	static void configureUriVariableExpressions(BeanDefinitionBuilder builder, ParserContext parserContext,
			Element element) {
		String uriVariablesExpression = element.getAttribute("uri-variables-expression");

		List<Element> uriVariableElements = DomUtils.getChildElementsByTagName(element, "uri-variable");
		boolean hasUriVariableExpressions = !CollectionUtils.isEmpty(uriVariableElements);

		if (StringUtils.hasText(uriVariablesExpression)) {
			if (hasUriVariableExpressions) {
				parserContext.getReaderContext().error("'uri-variables-expression' attribute " +
						"and 'uri-variable' sub-elements are mutually exclusive.", element);
			}
			BeanDefinitionBuilder beanDefinitionBuilder =
					BeanDefinitionBuilder.genericBeanDefinition(ExpressionFactoryBean.class)
							.addConstructorArgValue(uriVariablesExpression);
			builder.addPropertyValue("uriVariablesExpression", beanDefinitionBuilder.getBeanDefinition());
		}

		if (hasUriVariableExpressions) {
			ManagedMap<String, Object> uriVariableExpressions = new ManagedMap<String, Object>();
			for (Element uriVariableElement : uriVariableElements) {
				String name = uriVariableElement.getAttribute("name");
				String expression = uriVariableElement.getAttribute("expression");
				BeanDefinitionBuilder factoryBeanBuilder =
						BeanDefinitionBuilder.genericBeanDefinition(ExpressionFactoryBean.class);
				factoryBeanBuilder.addConstructorArgValue(expression);
				uriVariableExpressions.put(name, factoryBeanBuilder.getBeanDefinition());
			}
			builder.addPropertyValue("uriVariableExpressions", uriVariableExpressions);
		}
	}

	static void configureUrlConstructorArg(Element element, ParserContext parserContext,
			BeanDefinitionBuilder builder) {
		String urlAttribute = element.getAttribute("url");
		String urlExpressionAttribute = element.getAttribute("url-expression");
		boolean hasUrlAttribute = StringUtils.hasText(urlAttribute);
		boolean hasUrlExpressionAttribute = StringUtils.hasText(urlExpressionAttribute);
		if (hasUrlAttribute == hasUrlExpressionAttribute) {
			parserContext.getReaderContext()
					.error("Adapter must have exactly one of 'url' or 'url-expression'", element);
		}
		RootBeanDefinition expressionDef;
		if (hasUrlAttribute) {
			expressionDef = new RootBeanDefinition(LiteralExpression.class);
			expressionDef.getConstructorArgumentValues().addGenericArgumentValue(urlAttribute);
		}
		else {
			expressionDef = new RootBeanDefinition(ExpressionFactoryBean.class);
			expressionDef.getConstructorArgumentValues().addGenericArgumentValue(urlExpressionAttribute);
		}
		builder.addConstructorArgValue(expressionDef);

	}

	static void setHttpMethodOrExpression(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
		String httpMethod = element.getAttribute("http-method");
		String httpMethodExpression = element.getAttribute("http-method-expression");

		boolean hasHttpMethod = StringUtils.hasText(httpMethod);
		boolean hasHttpMethodExpression = StringUtils.hasText(httpMethodExpression);

		if (hasHttpMethod && hasHttpMethodExpression) {
			parserContext.getReaderContext()
					.error("The 'http-method' and 'http-method-expression' are mutually exclusive. " +
							"You can only have one or the other", element);
		}

		RootBeanDefinition expressionDef = null;
		if (hasHttpMethod) {
			expressionDef = new RootBeanDefinition(LiteralExpression.class);
			expressionDef.getConstructorArgumentValues().addGenericArgumentValue(httpMethod);
		}
		else if (hasHttpMethodExpression) {
			expressionDef = new RootBeanDefinition(ExpressionFactoryBean.class);
			expressionDef.getConstructorArgumentValues().addGenericArgumentValue(httpMethodExpression);
		}
		if (expressionDef != null) {
			builder.addPropertyValue("httpMethodExpression", expressionDef);
		}
	}

	static void setExpectedResponseOrExpression(Element element, ParserContext parserContext,
			BeanDefinitionBuilder builder) {
		String expectedResponseType = element.getAttribute("expected-response-type");
		String expectedResponseTypeExpression = element.getAttribute("expected-response-type-expression");

		boolean hasExpectedResponseType = StringUtils.hasText(expectedResponseType);
		boolean hasExpectedResponseTypeExpression = StringUtils.hasText(expectedResponseTypeExpression);

		if (hasExpectedResponseType && hasExpectedResponseTypeExpression) {
			parserContext.getReaderContext()
					.error("The 'expected-response-type' and 'expected-response-type-expression' are mutually exclusive. " +
							"You can only have one or the other", element);
		}

		RootBeanDefinition expressionDef = null;
		if (hasExpectedResponseType) {
			expressionDef = new RootBeanDefinition(LiteralExpression.class);
			expressionDef.getConstructorArgumentValues().addGenericArgumentValue(expectedResponseType);
		}
		else if (hasExpectedResponseTypeExpression) {
			expressionDef = new RootBeanDefinition(ExpressionFactoryBean.class);
			expressionDef.getConstructorArgumentValues().addGenericArgumentValue(expectedResponseTypeExpression);
		}
		if (expressionDef != null) {
			builder.addPropertyValue("expectedResponseTypeExpression", expressionDef);
		}
	}

}
