/*******************************************************************************
 * Copyright (c) 2012, 2017 NumberFour AG 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:
 *     NumberFour AG - initial API and Implementation (Alex Panchenko)
 *******************************************************************************/
package org.eclipse.dltk.core.tests;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import org.eclipse.core.resources.IFile;
import org.eclipse.dltk.codeassist.ICompletionEngine;
import org.eclipse.dltk.codeassist.ISelectionEngine;
import org.eclipse.dltk.codeassist.ISelectionRequestor;
import org.eclipse.dltk.compiler.env.IModuleSource;
import org.eclipse.dltk.core.CompletionProposal;
import org.eclipse.dltk.core.CompletionRequestor;
import org.eclipse.dltk.core.DLTKCore;
import org.eclipse.dltk.core.IModelElement;
import org.eclipse.dltk.core.ISourceModule;
import org.eclipse.dltk.core.ISourceRange;
import org.eclipse.dltk.core.ModelException;
import org.eclipse.dltk.core.tests.util.StringList;
import org.eclipse.osgi.util.NLS;
import org.junit.Assert;

public class CodeAssistUtil {

	static abstract class Module<M> {
		final M module;

		public Module(M module) {
			this.module = module;
		}

		abstract String getSource();

		abstract String getName();

		abstract IModelElement[] codeSelect(int offset, int length)
				throws ModelException;

		abstract void codeComplete(int offset, CompletionRequestor requestor)
				throws ModelException;

	}

	private static class SourceModule extends Module<ISourceModule> {

		public SourceModule(ISourceModule module) {
			super(module);
		}

		@Override
		String getSource() {
			try {
				return module.getSource();
			} catch (ModelException e) {
				throw new IllegalStateException(e);
			}
		}

		@Override
		String getName() {
			return module.getElementName();
		}

		@Override
		IModelElement[] codeSelect(int offset, int length)
				throws ModelException {
			return module.codeSelect(offset, length);
		}

		@Override
		void codeComplete(int offset, CompletionRequestor requestor)
				throws ModelException {
			module.codeComplete(offset, requestor);
		}
	}

	private static class Source extends Module<IModuleSource> {
		public Source(IModuleSource source) {
			super(source);
		}

		@Override
		String getSource() {
			return module.getSourceContents();
		}

		@Override
		String getName() {
			return module.getFileName();
		}

		@Override
		IModelElement[] codeSelect(int offset, int length) {
			throw new UnsupportedOperationException();
		}

		@Override
		void codeComplete(int offset, CompletionRequestor requestor)
				throws ModelException {
			throw new UnsupportedOperationException();
		}
	}

	private final Module<?> module;
	private Integer offset;
	private int length;

	private CodeAssistUtil(Module<?> module) {
		this.module = module;
	}

	public static CodeAssistUtil on(IFile file) {
		return on(DLTKCore.createSourceModuleFrom(file));
	}

	public static CodeAssistUtil on(ISourceModule module) {
		return new CodeAssistUtil(new SourceModule(module));
	}

	public static CodeAssistUtil on(IModuleSource module) {
		return new CodeAssistUtil(new Source(module));
	}

	public CodeAssistUtil after(String marker) {
		return calculateOffset(marker, false, true);
	}

	public CodeAssistUtil afterLast(String marker) {
		return calculateOffset(marker, true, true);
	}

	public CodeAssistUtil before(String marker) {
		return calculateOffset(marker, false, false);
	}

	public CodeAssistUtil beforeLast(String marker) {
		return calculateOffset(marker, true, false);
	}

	private CodeAssistUtil calculateOffset(String marker, boolean last,
			boolean after) {
		final String text = module.getSource();
		final int offset = last ? text.lastIndexOf(marker)
				: text.indexOf(marker);
		Assert.assertTrue(NLS.bind("Pattern \"{0}\" not found in {1}", marker,
				module.getName()), offset != -1);
		this.offset = offset + (after ? marker.length() : 0);
		return this;
	}

	public CodeAssistUtil length(int length) {
		this.length = length;
		return this;
	}

	public int length() {
		return length;
	}

	public CodeAssistUtil offset(int offset) {
		this.offset = offset;
		return this;
	}

	public int offset() {
		return offset;
	}

	public IModelElement[] codeSelect() throws ModelException {
		return module.codeSelect(offset, length);
	}

	private IModuleSource getModuleSource() {
		return (IModuleSource) module.module;
	}

	/**
	 * Value class for completion proposals returned by
	 * {@link CodeAssistUtil#codeComplete()} methods.
	 */
	public class CodeCompletionResult {

		private final List<CompletionProposal> proposals;

		public CodeCompletionResult(List<CompletionProposal> proposals) {
			this.proposals = proposals;
		}

		public int size() {
			return proposals.size();
		}

		public CompletionProposal get(int index) {
			return proposals.get(index);
		}

		private boolean compareProposalNames(String[] names) {
			if (names.length != proposals.size()) {
				return false;
			}
			final CompletionProposal[] sorted = proposals
					.toArray(new CompletionProposal[proposals.size()]);
			Arrays.sort(sorted,
					(pr, pr1) -> pr.getName().compareTo(pr1.getName()));
			final String[] sortedNames = new String[names.length];
			System.arraycopy(names, 0, sortedNames, 0, names.length);
			Arrays.sort(sortedNames);
			for (int i = 0, size = proposals.size(); i < size; ++i) {
				if (!names[i].equals(proposals.get(i).getName())) {
					return false;
				}
			}
			return true;
		}

		private StringList exractProposalNames(boolean withKinds) {
			final StringList list = new StringList(proposals.size());
			for (int i = 0, size = proposals.size(); i < size; ++i) {
				final CompletionProposal proposal = proposals.get(i);
				String name = proposal.getName();
				if (withKinds && proposal
						.getKind() == CompletionProposal.METHOD_REF) {
					name += "()";
				}
				list.add(name);
			}
			return list;
		}

		public void assertEquals(String... expectedProposalNames) {
			if (!compareProposalNames(expectedProposalNames)) {
				Assert.assertEquals(
						new StringList(expectedProposalNames).sort().toString(),
						exractProposalNames(false).sort().toString());
			}
		}

		/**
		 * Finds the proposal with the specified name or throws exception if no
		 * such proposal found.
		 */
		public CompletionProposal get(String name)
				throws IllegalArgumentException {
			for (CompletionProposal proposal : proposals) {
				if (name.equals(proposal.getName())) {
					return proposal;
				}
			}
			throw new IllegalArgumentException(
					NLS.bind("\"{0}\" completion proposal not found", name));
		}

		/**
		 * Finds the proposal with the specified kind and name or throws
		 * exception if no such proposal found.
		 */
		public CompletionProposal get(int kind, String name)
				throws IllegalArgumentException {
			for (CompletionProposal proposal : proposals) {
				if (kind == proposal.getKind()
						&& name.equals(proposal.getName())) {
					return proposal;
				}
			}
			throw new IllegalArgumentException(NLS.bind(
					"\"{0}:{1}\" completion proposal not found", kind, name));
		}
	}

	public CodeCompletionResult codeComplete(ICompletionEngine engine) {
		final List<CompletionProposal> proposals = new ArrayList<>();
		engine.setRequestor(new TestCompletionRequestor(proposals));
		engine.complete(getModuleSource(), offset(), 0);
		return new CodeCompletionResult(proposals);
	}

	/**
	 * Performs code completion in this source module.
	 */
	public CodeCompletionResult codeComplete() throws ModelException {
		final List<CompletionProposal> proposals = new ArrayList<>();
		module.codeComplete(offset(), new TestCompletionRequestor(proposals));
		return new CodeCompletionResult(proposals);
	}

	public Object[] codeSelectAll(ISelectionEngine engine) {
		final List<Object> elements = new ArrayList<>();
		engine.setRequestor(new ISelectionRequestor() {
			@Override
			public void acceptModelElement(IModelElement element) {
				elements.add(element);
			}

			@Override
			public void acceptForeignElement(Object element) {
				elements.add(element);
			}

			@Override
			public void acceptElement(Object element, ISourceRange range) {
				elements.add(element);
			}
		});
		final IModelElement[] result = engine.select(getModuleSource(), offset,
				offset);
		if (result != null) {
			Collections.addAll(elements, result);
		}
		return elements.toArray();
	}

	public IModelElement[] codeSelect(ISelectionEngine engine) {
		final List<IModelElement> elements = new ArrayList<>();
		engine.setRequestor(new ISelectionRequestor() {

			@Override
			public void acceptModelElement(IModelElement element) {
				elements.add(element);
			}

			@Override
			public void acceptForeignElement(Object element) {
				if (element instanceof IModelElement) {
					elements.add((IModelElement) element);
				}
			}

			@Override
			public void acceptElement(Object element, ISourceRange range) {
				acceptForeignElement(element);
			}
		});
		final IModelElement[] result = engine.select(getModuleSource(), offset,
				offset);
		if (result != null) {
			Collections.addAll(elements, result);
		}
		return elements.toArray(new IModelElement[elements.size()]);
	}

}