/*******************************************************************************
 * Copyright (c) 2004, 2009 Eugene Kuleshov and others.
 * 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
 *
 * Contributors:
 *     Eugene Kuleshov - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylyn.internal.web.tasks;

import static org.eclipse.mylyn.internal.web.tasks.Util.isPresent;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.codec.EncoderException;
import org.apache.commons.codec.net.URLCodec;
import org.apache.commons.httpclient.Header;
import org.apache.commons.httpclient.HostConfiguration;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpException;
import org.apache.commons.httpclient.HttpMethod;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.lang.StringEscapeUtils;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.mylyn.commons.net.AbstractWebLocation;
import org.eclipse.mylyn.commons.net.AuthenticationCredentials;
import org.eclipse.mylyn.commons.net.AuthenticationType;
import org.eclipse.mylyn.commons.net.WebLocation;
import org.eclipse.mylyn.commons.net.WebUtil;
import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;
import org.eclipse.mylyn.tasks.core.IRepositoryManager;
import org.eclipse.mylyn.tasks.core.IRepositoryQuery;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.core.data.TaskAttribute;
import org.eclipse.mylyn.tasks.core.data.TaskAttributeMapper;
import org.eclipse.mylyn.tasks.core.data.TaskData;
import org.eclipse.mylyn.tasks.core.data.TaskDataCollector;
import org.eclipse.mylyn.tasks.core.data.TaskMapper;
import org.eclipse.mylyn.tasks.core.sync.ISynchronizationSession;
import org.eclipse.mylyn.tasks.ui.TaskRepositoryLocationUiFactory;
import org.eclipse.mylyn.tasks.ui.TasksUi;

import com.sun.syndication.feed.module.DCModule;
import com.sun.syndication.feed.synd.SyndEntry;
import com.sun.syndication.feed.synd.SyndFeed;
import com.sun.syndication.io.SyndFeedInput;
import com.sun.syndication.io.XmlReader;

/**
 * Generic connector for web based issue tracking systems
 * 
 * @author Eugene Kuleshov
 */
public class WebRepositoryConnector extends AbstractRepositoryConnector {

	public static final String REPOSITORY_TYPE = "web"; //$NON-NLS-1$

	public static final String PROPERTY_TASK_CREATION_URL = "taskCreationUrl"; //$NON-NLS-1$

	public static final String PROPERTY_TASK_URL = "taskUrl"; //$NON-NLS-1$

	public static final String PROPERTY_QUERY_URL = "queryUrl"; //$NON-NLS-1$

	public static final String PROPERTY_QUERY_METHOD = "queryMethod"; //$NON-NLS-1$

	public static final String PROPERTY_QUERY_REGEXP = "queryPattern"; //$NON-NLS-1$

	public static final String PROPERTY_LOGIN_FORM_URL = "loginFormUrl"; //$NON-NLS-1$

	public static final String PROPERTY_LOGIN_TOKEN_REGEXP = "loginTokenPattern"; //$NON-NLS-1$

	public static final String PROPERTY_LOGIN_REQUEST_METHOD = "loginRequestMethod"; //$NON-NLS-1$

	public static final String PROPERTY_LOGIN_REQUEST_URL = "loginRequestUrl"; //$NON-NLS-1$

	public static final String PARAM_PREFIX = "param_"; //$NON-NLS-1$

	public static final String PARAM_SERVER_URL = "serverUrl"; //$NON-NLS-1$

	public static final String PARAM_USER_ID = "userId"; //$NON-NLS-1$

	public static final String PARAM_PASSWORD = "password"; //$NON-NLS-1$

	public static final String PARAM_LOGIN_TOKEN = "loginToken"; //$NON-NLS-1$

	public static final String REQUEST_POST = "POST"; //$NON-NLS-1$

	public static final String REQUEST_GET = "GET"; //$NON-NLS-1$

	private static final String COMPLETED_STATUSES = "completed|fixed|resolved|invalid|verified|deleted|closed|done"; //$NON-NLS-1$

	public static final String KEY_TASK_PREFIX = "taskPrefix"; //$NON-NLS-1$

	public static final String KEY_QUERY_TEMPLATE = "UrlTemplate"; //$NON-NLS-1$

	public static final String KEY_QUERY_PATTERN = "Regexp"; //$NON-NLS-1$

	private static final String USER_AGENT = "WebTemplatesConnector"; //$NON-NLS-1$

	private final static Date DEFAULT_DATE = new Date(0);

	@Override
	public String getConnectorKind() {
		return REPOSITORY_TYPE;
	}

	@Override
	public String getLabel() {
		return Messages.WebRepositoryConnector_Web_Template_Advanced_;
	}

	@Override
	public boolean canCreateNewTask(TaskRepository repository) {
		return repository.hasProperty(PROPERTY_TASK_CREATION_URL);
	}

	@Override
	public boolean canCreateTaskFromKey(TaskRepository repository) {
		return repository.hasProperty(PROPERTY_TASK_URL);
	}

	@Override
	public boolean canSynchronizeTask(TaskRepository taskRepository, ITask task) {
		return false;
	}

//	@Override
//	public AbstractTask createTaskFromExistingId(TaskRepository repository, final String id, IProgressMonitor monitor)
//			throws CoreException {
//		if (REPOSITORY_TYPE.equals(repository.getConnectorKind())) {
//			String taskPrefix = evaluateParams(repository.getProperty(PROPERTY_TASK_URL), repository);
//
//			final WebTask task = new WebTask(id, id, taskPrefix, repository.getRepositoryUrl(), REPOSITORY_TYPE);
//
//			RetrieveTitleFromUrlJob job = new RetrieveTitleFromUrlJob(taskPrefix + id) {
//				@Override
//				protected void setTitle(String pageTitle) {
//					task.setSummary(pageTitle);
//					TasksUiPlugin.getTaskList().notifyTaskChanged(task, false);
//				}
//			};
//			job.schedule();
//
//			return task;
//		}
//
//		return null;
//	}

	@Override
	public TaskData getTaskData(TaskRepository repository, String taskId, IProgressMonitor monitor)
			throws CoreException {
		String taskPrefix = evaluateParams(repository.getProperty(PROPERTY_TASK_URL), repository);
		TaskData taskData = createTaskData(repository, taskId);
		TaskMapper mapper = new TaskMapper(taskData, true);
		mapper.setCreationDate(DEFAULT_DATE);
		mapper.setTaskUrl(taskPrefix + taskId);
		mapper.setValue(KEY_TASK_PREFIX, taskPrefix);
		// bug 300310: only update the summary on forced refreshes
		mapper.setSummary(taskId);
		try {
			String pageTitle = WebUtil.getTitleFromUrl(new WebLocation(taskPrefix + taskId), monitor);
			if (pageTitle != null) {
				mapper.setSummary(pageTitle);
			}
		} catch (IOException e) {
			// log to error log?
		}
		taskData.getRoot()
				.getMappedAttribute(TaskAttribute.SUMMARY)
				.getMetaData()
				.putValue("forced", Boolean.TRUE.toString());
		return taskData;
	}

	@SuppressWarnings("restriction")
	@Override
	public String getRepositoryUrlFromTaskUrl(String url) {
		if (url == null) {
			return null;
		}

		// lookup repository using task prefix url
		IRepositoryManager repositoryManager = TasksUi.getRepositoryManager();
		for (TaskRepository repository : repositoryManager.getRepositories(getConnectorKind())) {
			String taskUrl = evaluateParams(repository.getProperty(PROPERTY_TASK_URL), repository);
			if (taskUrl != null && !taskUrl.equals("") && url.startsWith(taskUrl)) { //$NON-NLS-1$
				return repository.getRepositoryUrl();
			}
		}

		for (IRepositoryQuery query : org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal.getTaskList()
				.getQueries()) {
			TaskRepository repository = repositoryManager.getRepository(query.getConnectorKind(),
					query.getRepositoryUrl());
			if (repository != null) {
				String queryUrl = evaluateParams(query.getAttribute(KEY_TASK_PREFIX), //
						getQueryParams(query), repository);
				if (queryUrl != null && !queryUrl.equals("") && url.startsWith(queryUrl)) { //$NON-NLS-1$
					return query.getRepositoryUrl();
				}
			}
		}
		return null;
	}

	public static Map<String, String> getQueryParams(IRepositoryQuery query) {
		Map<String, String> params = new LinkedHashMap<String, String>();
		Map<String, String> attributes = query.getAttributes();
		for (String name : attributes.keySet()) {
			if (name.startsWith(WebRepositoryConnector.PARAM_PREFIX)) {
				params.put(name, attributes.get(name));
			}
		}
		return params;
	}

	@Override
	public String getTaskIdFromTaskUrl(String url) {
		if (url == null) {
			return null;
		}

		IRepositoryManager repositoryManager = TasksUi.getRepositoryManager();
		for (TaskRepository repository : repositoryManager.getRepositories(getConnectorKind())) {
			String start = evaluateParams(repository.getProperty(PROPERTY_TASK_URL), repository);
			if (start != null && url.startsWith(start)) {
				return url.substring(start.length());
			}
		}
		return null;
	}

	@Override
	public String getTaskUrl(String repositoryUrl, String taskId) {
		IRepositoryManager repositoryManager = TasksUi.getRepositoryManager();
		TaskRepository repository = repositoryManager.getRepository(getConnectorKind(), repositoryUrl);
		if (repository != null) {
			String prefix = evaluateParams(repository.getProperty(PROPERTY_TASK_URL), repository);
			return prefix + taskId;
		}
		return null;
	}

	@Override
	public IStatus performQuery(TaskRepository repository, IRepositoryQuery query, TaskDataCollector resultCollector,
			ISynchronizationSession session, IProgressMonitor monitor) {
		Map<String, String> queryParameters = getQueryParams(query);
		String queryUrl = evaluateParams(query.getUrl(), queryParameters, repository);
		try {
			String content = fetchResource(queryUrl, queryParameters, repository);

			String taskPrefixAttribute = query.getAttribute(KEY_TASK_PREFIX);
			if (!Util.isPresent(taskPrefixAttribute)) {
				return performRssQuery(content, monitor, resultCollector, repository);
			} else {
				String taskPrefix = evaluateParams(taskPrefixAttribute, queryParameters, repository);
				String queryPattern = evaluateParams(query.getAttribute(KEY_QUERY_PATTERN), queryParameters, repository);
				return performQuery(content, queryPattern, taskPrefix, monitor, resultCollector, repository);
			}
		} catch (IOException e) {
			String msg = e.getMessage() == null ? e.toString() : e.getMessage();
			return new Status(IStatus.ERROR, TasksWebPlugin.ID_PLUGIN, IStatus.ERROR, //
					Messages.WebRepositoryConnector_Could_not_fetch_resource + queryUrl + "\n" + msg, e); //$NON-NLS-1$ 
		}
	}

	@Override
	public boolean isRepositoryConfigurationStale(TaskRepository repository, IProgressMonitor monitor)
			throws CoreException {
		return false;
	}

	@Override
	public void updateRepositoryConfiguration(TaskRepository repository, IProgressMonitor monitor) throws CoreException {
		// ignore
	}

	@Override
	public void updateTaskFromTaskData(TaskRepository repository, ITask task, TaskData taskData) {
		preProcessTaskData(task, taskData);

		TaskMapper mapper = new TaskMapper(taskData);
		if (Util.isPresent(mapper.getValue(KEY_TASK_PREFIX))) {
			task.setAttribute(KEY_TASK_PREFIX, mapper.getValue(KEY_TASK_PREFIX));
			task.setTaskKey(task.getTaskId());
		} else {
			// do not show task id for RSS items
			task.setTaskKey(null);
		}
		mapper.applyTo(task);
	}

	private void preProcessTaskData(ITask task, TaskData taskData) {
		if (task.getSummary() != null && task.getSummary().length() > 0) {
			// bug 300310: if task already has a summary, keep it 
			TaskAttribute summaryAttribute = taskData.getRoot().getMappedAttribute(TaskAttribute.SUMMARY);
			if (summaryAttribute != null && Boolean.parseBoolean(summaryAttribute.getMetaData().getValue("forced"))) {
				summaryAttribute.setValue(task.getSummary());
			}
		}
	}

	public static IStatus performQuery(String resource, String regexp, String taskPrefix, IProgressMonitor monitor,
			TaskDataCollector resultCollector, TaskRepository repository) {
		NamedPattern p = new NamedPattern(regexp, Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL
				| Pattern.UNICODE_CASE | Pattern.CANON_EQ);

		Matcher matcher = p.matcher(resource);

		if (!matcher.find()) {
			return Status.OK_STATUS;
		} else {
			boolean isCorrect = true;
			do {
				if (p.getGroups().isEmpty()) {
					// "classic" mode, no named patterns
					if (matcher.groupCount() < 2) {
						isCorrect = false;
					}
					if (matcher.groupCount() >= 1) {
						String id = matcher.group(1);
						String description = matcher.groupCount() > 1 ? cleanup(matcher.group(2), repository) : null;
						description = unescapeHtml(description);

						TaskData data = createTaskData(repository, id);
						TaskMapper mapper = new TaskMapper(data, true);
						mapper.setCreationDate(DEFAULT_DATE);
						mapper.setTaskUrl(taskPrefix + id);
						mapper.setSummary(description);
						mapper.setValue(KEY_TASK_PREFIX, taskPrefix);
						resultCollector.accept(data);
					}
				} else {
					String id = p.group("Id", matcher); //$NON-NLS-1$
					String description = p.group("Description", matcher); //$NON-NLS-1$
					if (id == null || description == null) {
						isCorrect = false;
					}
					if (id != null) {
						description = unescapeHtml(description);

						String owner = unescapeHtml(cleanup(p.group("Owner", matcher), repository)); //$NON-NLS-1$
						String type = unescapeHtml(cleanup(p.group("Type", matcher), repository)); //$NON-NLS-1$

						TaskData data = createTaskData(repository, id);
						TaskMapper mapper = new TaskMapper(data, true);
						mapper.setCreationDate(DEFAULT_DATE);
						mapper.setTaskUrl(taskPrefix + id);
						mapper.setSummary(description);
						mapper.setValue(KEY_TASK_PREFIX, taskPrefix);
						mapper.setOwner(owner);
						mapper.setTaskKind(type);

						String status = p.group("Status", matcher); //$NON-NLS-1$
						if (status != null) {
							if (COMPLETED_STATUSES.contains(status.toLowerCase())) {
								// TODO set actual completion date here
								mapper.setCompletionDate(DEFAULT_DATE);
							}
						}

						resultCollector.accept(data);
					}
				}
			} while (matcher.find() && !monitor.isCanceled());

			if (isCorrect) {
				return Status.OK_STATUS;
			} else {
				return new Status(IStatus.ERROR, TasksWebPlugin.ID_PLUGIN, IStatus.ERROR,
						Messages.WebRepositoryConnector_Require_two_matching_groups, null);
			}
		}
	}

	private static TaskData createTaskData(TaskRepository taskRepository, String id) {
		TaskData data = new TaskData(new TaskAttributeMapper(taskRepository), WebRepositoryConnector.REPOSITORY_TYPE,
				taskRepository.getRepositoryUrl(), id);
		data.setPartial(true);
		return data;
	}

	private static String unescapeHtml(String text) {
		if (text == null) {
			return ""; //$NON-NLS-1$
		}
		return StringEscapeUtils.unescapeHtml(text);
	}

	private static String cleanup(String text, TaskRepository repository) {
		if (text == null) {
			return null;
		}

		// Has to disable this for now. See bug 166737 and bug 166936
		// try {
		// text = URLDecoder.decode(text, repository.getCharacterEncoding());
		// } catch (UnsupportedEncodingException ex) {
		// // ignore
		// }

		text = text.replaceAll("<!--.+?-->", ""); //$NON-NLS-1$ //$NON-NLS-2$

		String[] tokens = text.split(" |\\t|\\n|\\r"); //$NON-NLS-1$
		StringBuilder sb = new StringBuilder();
		String sep = ""; //$NON-NLS-1$
		for (String token : tokens) {
			if (token.length() > 0) {
				sb.append(sep).append(token);
				sep = " "; //$NON-NLS-1$
			}
		}

		return sb.toString();
	}

	public static IStatus performRssQuery(String content, IProgressMonitor monitor, TaskDataCollector resultCollector,
			TaskRepository repository) {
		SyndFeedInput input = new SyndFeedInput();
		try {
			SyndFeed feed = input.build(new XmlReader(new ByteArrayInputStream(content.getBytes())));

			SimpleDateFormat df = new SimpleDateFormat("yy-MM-dd HH:mm"); //$NON-NLS-1$

			Iterator<?> it;
			for (it = feed.getEntries().iterator(); it.hasNext();) {
				SyndEntry entry = (SyndEntry) it.next();

				String author = entry.getAuthor();
				if (author == null) {
					DCModule module = (DCModule) entry.getModule("http://purl.org/dc/elements/1.1/"); //$NON-NLS-1$
					author = module.getCreator();
				}

				Date date = entry.getUpdatedDate();
				if (date == null) {
					date = entry.getPublishedDate();
				}
				if (date == null) {
					DCModule module = (DCModule) entry.getModule("http://purl.org/dc/elements/1.1/"); //$NON-NLS-1$
					date = module.getDate();
				}

				String entryUri = entry.getLink();
				if (entryUri == null) {
					entryUri = entry.getUri();
				}

				String entrTitle = entry.getTitle();

				TaskData data = createTaskData(repository, entryUri.replaceAll("-", "%2D")); //$NON-NLS-1$ //$NON-NLS-2$
				TaskMapper schema = new TaskMapper(data, true);
				schema.setSummary(((date == null ? "" : df.format(date) + " - ") + entrTitle)); //$NON-NLS-1$ //$NON-NLS-2$
				schema.setCreationDate(date);
				schema.setOwner(author);
				schema.setTaskUrl(entryUri);
				resultCollector.accept(data);
			}
			return Status.OK_STATUS;
		} catch (Exception e) {
			String msg = e.getMessage() == null ? e.toString() : e.getMessage();
			return new Status(IStatus.ERROR, TasksWebPlugin.ID_PLUGIN, IStatus.ERROR, //
					Messages.WebRepositoryConnector_Failed_to_parse_RSS_feed + "\"" + msg + "\"", e); //$NON-NLS-1$ //$NON-NLS-2$ 
		}
	}

	public static String fetchResource(String url, Map<String, String> params, TaskRepository repository)
			throws IOException {
		HttpClient client = new HttpClient();
		WebUtil.configureHttpClient(client, USER_AGENT);
		AbstractWebLocation location = new TaskRepositoryLocationUiFactory().createWebLocation(repository);
		HostConfiguration hostConfiguration = WebUtil.createHostConfiguration(client, location, null);

		loginRequestIfNeeded(client, hostConfiguration, params, repository);

		GetMethod method = new GetMethod(url);
		// method.setFollowRedirects(false);
		return requestResource(url, client, hostConfiguration, method);
	}

	private static void loginRequestIfNeeded(HttpClient client, HostConfiguration hostConfiguration,
			Map<String, String> params, TaskRepository repository) throws HttpException, IOException {
		if (repository.getCredentials(AuthenticationType.REPOSITORY) == null
				|| !isPresent(repository.getProperty(PROPERTY_LOGIN_REQUEST_URL))) {
			return;
		}

		String loginFormUrl = evaluateParams(repository.getProperty(PROPERTY_LOGIN_FORM_URL), params, repository);
		String loginToken = evaluateParams(repository.getProperty(PROPERTY_LOGIN_TOKEN_REGEXP), params, repository);
		if (isPresent(loginFormUrl) || isPresent(loginToken)) {
			GetMethod method = new GetMethod(loginFormUrl);
			// method.setFollowRedirects(false);
			String loginFormPage = requestResource(loginFormUrl, client, hostConfiguration, method);
			if (loginFormPage != null) {
				Pattern p = Pattern.compile(loginToken);
				Matcher m = p.matcher(loginFormPage);
				if (m.find()) {
					params.put(PARAM_PREFIX + PARAM_LOGIN_TOKEN, m.group(1));
				}
			}
		}

		String loginRequestUrl = evaluateParams(repository.getProperty(PROPERTY_LOGIN_REQUEST_URL), params, repository);
		requestResource(loginRequestUrl, client, hostConfiguration, getLoginMethod(params, repository));
	}

	public static HttpMethod getLoginMethod(Map<String, String> params, TaskRepository repository) {
		String requestMethod = repository.getProperty(PROPERTY_LOGIN_REQUEST_METHOD);
		String requestTemplate = repository.getProperty(PROPERTY_LOGIN_REQUEST_URL);
		String requestUrl = evaluateParams(requestTemplate, params, repository);

		if (REQUEST_GET.equals(requestMethod)) {
			return new GetMethod(requestUrl);
			// method.setFollowRedirects(false);
		}

		int n = requestUrl.indexOf('?');
		if (n == -1) {
			return new PostMethod(requestUrl);
		}

		PostMethod postMethod = new PostMethod(requestUrl.substring(0, n));
		// TODO this does not take into account escaped values
		n = requestTemplate.indexOf('?');
		String[] requestParams = requestTemplate.substring(n + 1).split("&"); //$NON-NLS-1$
		for (String requestParam : requestParams) {
			String[] nv = requestParam.split("="); //$NON-NLS-1$
			if (nv.length == 1) {
				postMethod.addParameter(nv[0], ""); //$NON-NLS-1$
			} else {
				String value = evaluateParams(nv[1], getParams(repository, params), false);
				postMethod.addParameter(nv[0], value);
			}
		}
		return postMethod;
	}

	private static String requestResource(String url, HttpClient client, HostConfiguration hostConfiguration,
			HttpMethod method) throws IOException, HttpException {
		String refreshUrl = null;
		try {
			client.executeMethod(hostConfiguration, method);
//          int statusCode = client.executeMethod(method);
//			if (statusCode == 300 || statusCode == 301 || statusCode == 302 || statusCode == 303 || statusCode == 307) {
//				Header location = method.getResponseHeader("Location");
//				if (location != null) {
//					refreshUrl = location.getValue();
//					if (!refreshUrl.startsWith("/")) {
//						refreshUrl = "/" + refreshUrl;
//					}
//				}
//			}

			refreshUrl = getRefreshUrl(url, method);
			if (refreshUrl == null) {
				return method.getResponseBodyAsString();
			}
		} finally {
			method.releaseConnection();
		}

		method = new GetMethod(refreshUrl);
		try {
			client.executeMethod(hostConfiguration, method);
			return method.getResponseBodyAsString();
		} finally {
			method.releaseConnection();
		}
	}

	private static String getRefreshUrl(String url, HttpMethod method) {
		Header refreshHeader = method.getResponseHeader("Refresh"); //$NON-NLS-1$
		if (refreshHeader == null) {
			return null;
		}
		String value = refreshHeader.getValue();
		int n = value.indexOf(";url="); //$NON-NLS-1$
		if (n == -1) {
			return null;
		}
		value = value.substring(n + 5);
		int requestPath;
		if (value.charAt(0) == '/') {
			int colonSlashSlash = url.indexOf("://"); //$NON-NLS-1$
			requestPath = url.indexOf('/', colonSlashSlash + 3);
		} else {
			requestPath = url.lastIndexOf('/');
		}

		String refreshUrl;
		if (requestPath == -1) {
			refreshUrl = url + "/" + value; //$NON-NLS-1$
		} else {
			refreshUrl = url.substring(0, requestPath + 1) + value;
		}
		return refreshUrl;
	}

	public static String evaluateParams(String value, Map<String, String> params, TaskRepository repository) {
		return evaluateParams(value, getParams(repository, params), true);
	}

	public static String evaluateParams(String value, TaskRepository repository) {
		return evaluateParams(value, getParams(repository, null), true);
	}

	private static String evaluateParams(String value, Map<String, String> params, boolean encode) {
		if (value == null || value.indexOf("${") == -1) { //$NON-NLS-1$
			return value;
		}

		int n = 0;
		int n1 = value.indexOf("${"); //$NON-NLS-1$
		StringBuilder evaluatedValue = new StringBuilder(value.length());
		while (n1 > -1) {
			evaluatedValue.append(value.substring(n, n1));
			int n2 = value.indexOf("}", n1); //$NON-NLS-1$
			if (n2 > -1) {
				String key = value.substring(n1 + 2, n2);
				if (PARAM_SERVER_URL.equals(key) || PARAM_USER_ID.equals(key) || PARAM_PASSWORD.equals(key)) {
					evaluatedValue.append(evaluateParams(params.get(key), params, false));
				} else {
					String val = evaluateParams(params.get(PARAM_PREFIX + key), params, false);
					evaluatedValue.append(encode ? encode(val) : val);
				}
			}
			n = n2 + 1;
			n1 = value.indexOf("${", n2); //$NON-NLS-1$
		}
		if (n > -1) {
			evaluatedValue.append(value.substring(n));
		}
		return evaluatedValue.toString();
	}

	private static Map<String, String> getParams(TaskRepository repository, Map<String, String> params) {
		Map<String, String> mergedParams = new LinkedHashMap<String, String>(repository.getProperties());
		mergedParams.put(PARAM_SERVER_URL, repository.getRepositoryUrl());
		AuthenticationCredentials credentials = repository.getCredentials(AuthenticationType.REPOSITORY);
		if (credentials != null) {
			mergedParams.put(PARAM_USER_ID, credentials.getUserName());
			mergedParams.put(PARAM_PASSWORD, credentials.getPassword());
		}
		if (params != null) {
			mergedParams.putAll(params);
		}
		return mergedParams;
	}

	private static String encode(String value) {
		try {
			return new URLCodec().encode(value);
		} catch (EncoderException ex) {
			return value;
		}
	}

	public static List<String> getTemplateVariables(String value) {
		if (value == null) {
			return Collections.emptyList();
		}

		List<String> vars = new ArrayList<String>();
		Matcher m = Pattern.compile("\\$\\{(.+?)\\}").matcher(value); //$NON-NLS-1$
		while (m.find()) {
			vars.add(m.group(1));
		}
		return vars;
	}

	@Override
	public boolean hasLocalCompletionState(TaskRepository taskRepository, ITask task) {
		return true;
	}

	@Override
	public boolean hasTaskChanged(TaskRepository taskRepository, ITask task, TaskData taskData) {
		preProcessTaskData(task, taskData);
		return new TaskMapper(taskData).hasChanges(task);
	}

}