/*******************************************************************************
 * Copyright (c) 2000, 2015 IBM Corporation and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     Genady Beryozkin, me@genady.org - initial API and implementation
 *     Fabio Zadrozny <fabiofz at gmail dot com> - [typing] HippieCompleteAction is slow  ( Alt+/ ) - https://bugs.eclipse.org/bugs/show_bug.cgi?id=270385
 *******************************************************************************/
package org.eclipse.ui.workbench.texteditor.tests;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

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

import org.junit.Before;
import org.junit.Test;

import org.eclipse.core.runtime.AssertionFailedException;

import org.eclipse.text.tests.Accessor;

import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.IDocument;

import org.eclipse.ui.internal.texteditor.HippieCompletionEngine;

/**
 * Tests for the Hippie completion action of the text editor.
 *
 * @author Genady Beryozkin, me@genady.org
 */
public class HippieCompletionTest {

	IDocument[] documents;
	private HippieCompletionEngine fEngine;

	@Before
	public void setUp() throws Exception {
		documents= new IDocument[5];
		documents[0]= new Document("package ui.TestPackage;\n" +
				"\n" +
				"/**\n" +
				" * This is a testing class that tests the hippie completion engine.\n" +
				" * it has a simple main with a print method\n" +
				" */\n" +
				"public class TestClass1 {\n" +
				"\n" +
				"    public static void main(String[] args) {\n" +
				"        System.out.println(\"I will be printing Hello world!\");\n" +
				"    }\n" +
				"}");
		documents[1]= new Document("This is a simple text file\n" +
				"with some testssome test that is also used in the completion engine tests");

		documents[2]= new Document("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
				"<plugin\n" +
				"   id=\"org.eclipse.ui.workbench.texteditor.tests\"\n" +
				"   name=\"%Plugin.name\"\n" +
				"   version=\"3.1.0\"\n" +
				"   provider-name=\"%Plugin.providerName\">\n" +
				"\n" +
				"   <runtime>\n" +
				"      <library name=\"workbenchtexteditortests.jar\">\n" +
				"         <export name=\"*\"/>\n" +
				"      </library>\n" +
				"   </runtime>\n" +
				"   \n" +
				"   <requires>\n" +
				"      <import plugin=\"org.eclipse.core.runtime.compatibility\"/>\n" +
				"      <import plugin=\"org.junit\"/>\n" +
				"      <import plugin=\"org.eclipse.text.tests\"/>\n" +
				"      <import plugin=\"org.eclipse.jface.text\"/>\n" +
				"      <import plugin=\"org.eclipse.ui.workbench.texteditor\"/>\n" +
				"      <import plugin=\"org.eclipse.ui\"/>\n" +
				"   </requires>\n" +
				"   \n" +
				"</plugin>\n" +
				"");

		documents[3]= new Document("###############################################################################\n" +
				"# Copyright (c) 2000, 2004 IBM Corporation and others.\n" +
				"\\n"+
				"# This program and the accompanying materials \n" +
				"# are made available under the terms of the Eclipse Public License 2.0\n" +
				"# which accompanies this distribution, and is available at\n" +
				"# https://www.eclipse.org/legal/epl-2.0/"+
				"# \n"+
				"# SPDX-License-Identifier: EPL-2.0\n" +
				"# \n" +
				"# Contributors:\n" +
				"#     IBM Corporation - initial API and implementation\n" +
				"###############################################################################\n" +
				"bin.includes= plugin.xml,\\\n" +
				"               plugin.properties,\\\n" +
				"               test.xml,\\\n" +
				"               about.html,\\\n" +
				"               *.jar\n" +
				"\n" +
				"src.includes= about.html\n" +
				"               \n" +
				"source.workbenchtexteditortests.jar= src/\n" +
				"");
		documents[4]= new Document("/**\n" +
				" * This class tests the hippie completion functionality.\n" +
				" * \u05D4\u05DE\u05D7\u05DC\u05E7\u05D4 \u05D4\u05D6\u05D5 \u05D1\u05D5\u05D3\u05E7\u05EA \u05D0\u05EA \u05DE\u05E0\u05D2\u05E0\u05D5\u05DF \u05D4\u05D4\u05E9\u05DC\u05DE\u05D5\u05EA\n" +
				" * This is an arabic word - \u0647\u0630\u0627 \u0643\u0644\u0645\u0629 \u0639\u0631\u0628\u064A\u0651\u0629\n" +
				" * Eclipse is the best IDE - Eclipse \u044D\u0442\u043E \u0441\u0430\u043C\u044B\u0439 \u043B\u0443\u0447\u0448\u0438\u0439 IDE.\n" +
				" */\n" +
				"\n" +
				"public class HippieTester2 {\n" +
				"\n" +
				"\tpublic static void main(String[] args) {\n" +
					"\t\tchar \u05DE\u05D7= '9';\n" +   // hebrew text
				"\t\tString $arabic\u20ACDigits= \"\u0661\u0662\u0663\u0664\u0665\u0666" + // Euro symbol in variable name, arabic digits from 1 to 6
									"\u2021\u0667\u0668\u0669\u0660\";\n" + // double dagger, arabic digits 7-0
				"\t\tString $arabic\u20AAWord= \"\u0628\u064E\u0627\u0628\u0650\";\n" + // shekel (israeli) currency symbol + arabic word
				"\t\tString \u0628\u0627\u0628= \"\u044D\u0442\";\n" + // arabic var, russian string
				"\t\tint \u20A31= 3;\n" + // frank currency symbol
				"\t\tint \u00A3\u0661\u0662\u0663= \u20A31 + \u05DE\u05D7;\n" + // pound, arabic digits 1-3, partial hebrew word
				"\t\tint a\u0300\u0301b= 18;\n" + // combining diactritical marks
				"\t\t}\n" +
				"\t\t\n" +
				"\tpublic void \u05D4\u05D4\u05E9(int \u0441\u0430\u043C) {\n" + // hebrew word prexif, russian word prefix
				"\t\tString \u043B\u0443\u0447\u0448= \"\u05D1\u05D5\u05D3\u05E7\";\n" +
				"\t\tchar \u20AA129;\n" + // shekel (israeli) currency
				"\t}\n" +
				"}");

		fEngine= new HippieCompletionEngine();
	}

	@Test
	public void testSearchBackwards1() {
		try {
			List<String> list= fEngine.getCompletionsBackwards(documents[0],
					"pri", documents[0].get().indexOf("println") + 10);
			assertEquals(list.size(), 2);
			assertEquals(list.get(0), "ntln");
			assertEquals(list.get(1), "nt");

			list= fEngine.getCompletionsBackwards(documents[0],
					"pri", documents[0].getLength());
			assertEquals(list.size(), 3);
			assertEquals(list.get(0), "nting");
			assertEquals(list.get(1), "ntln");
			assertEquals(list.get(2), "nt");

			list= fEngine.getCompletionsBackwards(documents[0],
					"pri", documents[0].get().indexOf("println") + 1);
			assertEquals(list.size(), 1);
			assertEquals(list.get(0), "nt");

			list= fEngine.getCompletionsBackwards(documents[0],
					"pa", 2);
			assertEquals(list.size(), 0);

		} catch (BadLocationException e) {
			assertTrue("Got out of document bounds", false);
		}
	}

	@Test
	public void testSearchBackwards2() {
		try {
			List<String> list= fEngine.getCompletionsBackwards(documents[2],
					"plugi", documents[2].getLength());
			assertEquals(8, list.size());
			list= fEngine.makeUnique(list);
			assertEquals(1, list.size());
			assertEquals("n", list.get(0));

			list= fEngine.getCompletionsBackwards(documents[2],
					"plugin", documents[2].getLength());
			assertEquals(0, list.size()); // empty completions discarded

		} catch (BadLocationException e) {
			assertTrue("Got out of document bounds", false);
		}
	}

	@Test
	public void testSearchBackwards3() {
		try {
			List<String> list= fEngine.getCompletionsBackwards(documents[1],
					"test", documents[1].getLength());
			assertEquals("Number of backwards suggestions does not match", 2, list.size());
			list= fEngine.getCompletionsBackwards(documents[1],
					"tests", documents[1].getLength());
			assertEquals("Number of backwards suggestions does not match", 1, list.size());

			list= fEngine.getCompletionsBackwards(documents[1],
					"test", documents[1].getLength() - 1);
			assertEquals("Number of backwards suggestions does not match", 1, list.size());
		} catch (BadLocationException e) {
			assertTrue("Got out of document bounds", false);
		}
	}

	@Test
	public void testSearch() {
		ArrayList<IDocument> docsList= new ArrayList<>(Arrays.asList(this.documents));
		List<String> result= createSuggestions("te", docsList);
		assertEquals("Number of completions does not match", 15, result.size());
		result= fEngine.makeUnique(result);
		assertEquals("Number of completions does not match", 7, result.size());

		result= createSuggestions("Plug", docsList);
		assertEquals("Number of completions does not match", 2, result.size());

		result= createSuggestions("p", docsList);
		assertEquals("Number of completions does not match", 23, result.size());
		result= fEngine.makeUnique(result);
		assertEquals("Number of completions does not match", 10, result.size());
		assertEquals("Incorrect completion", "ackage", result.get(0));
		assertEquals("Incorrect completion", "rint", result.get(1));
		assertEquals("Incorrect completion", "ublic", result.get(2));
		assertEquals("Incorrect completion", "rintln", result.get(3));
		assertEquals("Incorrect completion", "rinting", result.get(4));
		assertEquals("Incorrect completion", "lugin", result.get(5));
		assertEquals("Incorrect completion", "rovider", result.get(6));
		assertEquals("Incorrect completion", "roviderName", result.get(7));
		assertEquals("Incorrect completion", "rogram", result.get(8));
		assertEquals("Incorrect completion", "roperties", result.get(9));
	}

	@Test
	public void testSearch2() {
		ArrayList<IDocument> docsList= new ArrayList<>(Arrays.asList(this.documents));
		List<String> result= createSuggestions("printe", docsList);
		assertEquals("Number of completions does not match", 0, result.size());

		result= createSuggestions("s", docsList);
		assertEquals("Number of completions does not match", 8, result.size());

		result= createSuggestions("pack", documents[0]);
		assertEquals("Number of completions does not match", 1, result.size());
	}

	@Test
	public void testForwardSearch() {
		try {
			List<String> result= fEngine.getCompletionsForward(documents[0],
					"cl", documents[0].get().indexOf("cl"), true);
			assertEquals(2, result.size());

			result= fEngine.getCompletionsForward(documents[0],
					"cl", documents[0].get().indexOf("cl") + 1, true);
			assertEquals(1, result.size());

			result= fEngine.getCompletionsForward(documents[1],
					"Thi", 0, true);
			assertEquals(1, result.size());

			result= fEngine.getCompletionsForward(documents[1],
					"Thi", 1, true);
			assertEquals(0, result.size());
		} catch (BadLocationException e) {
			assertTrue("Got out of document bounds", false);
		}
	}

	@Test
	public void testForwardSearchInternational() {
		List<String> result;
		try {
			result= fEngine.getCompletionsForward(documents[4],
					"$", documents[4].get().indexOf('$'), true);
			assertEquals(2, result.size());
			assertEquals("arabic\u20AAWord", result.get(0));
			assertEquals("arabic\u20ACDigits", result.get(1));

			result= fEngine.getCompletionsForward(documents[4],
					"$", documents[4].get().indexOf('$'), false);
			assertEquals(2, result.size());
			assertEquals("arabic\u20ACDigits", result.get(0));
			assertEquals("arabic\u20AAWord", result.get(1));

			result= fEngine.getCompletionsForward(documents[4],
					"$", documents[4].get().indexOf('$') + 1, true);
			assertEquals(1, result.size());
			assertEquals("arabic\u20AAWord", result.get(0));
		} catch (BadLocationException e) {
			assertTrue("Got out of document bounds", false);
		}
	}

	@Test
	public void testPrefix() {
		try {
			String prefix= fEngine.getPrefixString(documents[0],
					documents[0].get().indexOf("testing") + 3);
			assertEquals(prefix, "tes");

			prefix= fEngine.getPrefixString(documents[0],
					documents[0].get().indexOf("public") + 4);
			assertEquals(prefix, "publ");

			prefix= fEngine.getPrefixString(documents[0],
					documents[0].get().indexOf("println") + 7);
			assertEquals(prefix, "println");

			prefix= fEngine.getPrefixString(documents[0],
					documents[0].get().indexOf("println") + 8);
			assertEquals(prefix, null);

			prefix= fEngine.getPrefixString(documents[1], 3);
			assertEquals(prefix, "Thi");

			prefix= fEngine.getPrefixString(documents[1], 0);
			assertEquals(prefix, null);

			prefix= fEngine.getPrefixString(documents[1], documents[1].getLength());
			assertEquals(prefix, "tests");

			prefix= fEngine.getPrefixString(documents[3],
					documents[3].get().indexOf("Copyright") - 2);
			assertEquals(prefix, null);

			prefix= fEngine.getPrefixString(documents[4],
					documents[4].get().indexOf("IDE") + 2);
			assertEquals(prefix, "ID");

			prefix= fEngine.getPrefixString(documents[4],
					documents[4].get().indexOf("$arabic\u20ACDigits") + 8);
			assertEquals(prefix, "$arabic\u20AC");

			prefix= fEngine.getPrefixString(documents[4],
					documents[4].get().indexOf("$arabic\u20AAWord") + 8);
			assertEquals(prefix, "$arabic\u20AA");

			prefix= fEngine.getPrefixString(documents[4],
					documents[4].get().indexOf("\u00A3\u0661\u0662\u0663") + 3);
			assertEquals(prefix, "\u00A3\u0661\u0662");

			prefix= fEngine.getPrefixString(documents[4],
					documents[4].get().indexOf("a\u0300\u0301b") + 3);
			assertEquals(prefix, "a\u0300\u0301");

			prefix= fEngine.getPrefixString(documents[4],
					documents[4].get().indexOf("\u0667\u0668\u0669\u0660") + 2);
			assertEquals(prefix, "\u0667\u0668");

		} catch (BadLocationException e) {
			assertTrue("Got out of document bounds", false);
		}
	}

	@Test
	public void testInternational() {
		IDocument intlDoc= documents[4];

		List<String> result= createSuggestions("\u05D4", intlDoc); // hebrew letter heh
		assertEquals("Number of completions does not match", 4, result.size());
		assertEquals(result.get(0), "\u05DE\u05D7\u05DC\u05E7\u05D4");
		assertEquals(result.get(1), "\u05D6\u05D5");
		assertEquals(result.get(2), "\u05D4\u05E9\u05DC\u05DE\u05D5\u05EA");
		assertEquals(result.get(3), "\u05D4\u05E9");

		result= createSuggestions("\u0661", intlDoc); // arabic digit "1"
		assertEquals("Number of completions does not match", 1, result.size());
		assertEquals(result.get(0), "\u0662\u0663\u0664\u0665\u0666");

		result= createSuggestions("\u0628\u064E", intlDoc); // arabic letter bah and fatha
		assertEquals("Number of completions does not match", 1, result.size());
		assertEquals(result.get(0), "\u0627\u0628\u0650");
		result= createSuggestions("\u0628", intlDoc); // arabic letter bah
		assertEquals("Number of completions does not match", 2, result.size());
		assertEquals(result.get(0), "\u064E\u0627\u0628\u0650");
		assertEquals(result.get(1), "\u0627\u0628");

		result= createSuggestions("$ara", intlDoc);
		assertEquals("Number of completions does not match", 2, result.size());
		assertEquals(result.get(0), "bic\u20ACDigits");
		assertEquals(result.get(1), "bic\u20AAWord");

		result= createSuggestions("\u0441\u0430", intlDoc); // russian letters "s" and "a"
		assertEquals("Number of completions does not match", 2, result.size());
		assertEquals(result.get(0), "\u043C\u044B\u0439");
		assertEquals(result.get(1), "\u043C");

		result= createSuggestions("\u05D1\u05D5", intlDoc); // hebrew letters bet and vav
		assertEquals("Number of completions does not match", 2, result.size());
		assertEquals(result.get(0), "\u05D3\u05E7\u05EA");
		assertEquals(result.get(1), "\u05D3\u05E7");

		result= createSuggestions("a", intlDoc);
		assertEquals("Number of completions does not match", 4, result.size());
		assertEquals(result.get(0), "n");
		assertEquals(result.get(1), "rabic");
		assertEquals(result.get(2), "rgs");
		assertEquals(result.get(3), "\u0300\u0301b");

		result= createSuggestions("\u20AA", intlDoc);  // israeli currency (shekel)
		assertEquals("Number of completions does not match", 1, result.size());
		assertEquals(result.get(0), "129");

		result= createSuggestions("\u20A3", intlDoc);  // french currency (frank)
		assertEquals("Number of completions does not match", 2, result.size());
		assertEquals(result.get(0), "1");
		assertEquals(result.get(1), "1");

		result= createSuggestions("\u044D", intlDoc);  // russial letter "hard e"
		assertEquals("Number of completions does not match", 2, result.size());
		assertEquals(result.get(0), "\u0442\u043E");
		assertEquals(result.get(1), "\u0442");

		result= createSuggestions("\u00A3", intlDoc);  // pound currency sign
		assertEquals("Number of completions does not match", 1, result.size());
		assertEquals(result.get(0), "\u0661\u0662\u0663");

		result= createSuggestions("\u00A5", intlDoc);  // yen currency sign
		assertEquals("Number of completions does not match", 0, result.size());
	}

	@Test
	public void testInternationalBackwards() {
		IDocument intlDoc= documents[4];
		try {
			List<String> list= fEngine.getCompletionsBackwards(intlDoc,
					"\u043B\u0443", intlDoc.get().indexOf("129"));
			assertEquals(2, list.size());
			assertEquals(list.get(0), "\u0447\u0448");
			assertEquals(list.get(1), "\u0447\u0448\u0438\u0439");

			list= fEngine.getCompletionsBackwards(intlDoc,
					"\u05DE", intlDoc.get().lastIndexOf('+'));
			assertEquals(2, list.size());
			assertEquals(list.get(0), "\u05D7");
			assertEquals(list.get(1), "\u05E0\u05D2\u05E0\u05D5\u05DF");

			list= fEngine.getCompletionsBackwards(intlDoc,
					"\u0667", intlDoc.get().indexOf("\u2021\u0667") + 1);
			assertEquals(0, list.size());

			list= fEngine.getCompletionsBackwards(intlDoc,
					"\u0628", intlDoc.get().lastIndexOf("\u0628"));
			assertEquals(1, list.size());
			assertEquals(list.get(0), "\u064E\u0627\u0628\u0650");

		} catch (BadLocationException e) {
			assertTrue("Got out of document bounds", false);
		}
	}

	private Accessor createAccessor(Iterator<String> suggestions, int startOffset) {
		return new Accessor("org.eclipse.ui.texteditor.HippieCompleteAction$CompletionState",
				getClass().getClassLoader(), new Class[] { Iterator.class, int.class }, new
				Object[] { suggestions, Integer.valueOf(startOffset) });
	}

	private String next(Accessor state) {
		return (String)state.invoke("next", new Object[] {});
	}


	/*
	 * Getting completions lazily
	 */
	@Test
	public void testCompletionState() throws Exception {
		ArrayList<String> list= new ArrayList<>();
		Accessor state= null;

		try {
			state= createAccessor(list.iterator(), 0);
			fail("Having no items is not valid (at least the empty completion must be there)");
		} catch (AssertionFailedException ex) {
		}

		list.add("");
		state= createAccessor(list.iterator(), 0);
		assertTrue(state.getBoolean("hasOnly1EmptySuggestion"));
		for (int i= 0; i < 3; i++) {
			assertEquals("", next(state));
		}

		list.add("");
		state= createAccessor(list.iterator(), 0);
		assertTrue(state.getBoolean("hasOnly1EmptySuggestion"));
		for (int i= 0; i < 3; i++) {
			assertEquals("", next(state));
		}


		//only empty and aaaa
		list.add(0, "aaaa");
		state= createAccessor(list.iterator(), 0);
		assertFalse(state.getBoolean("hasOnly1EmptySuggestion"));

		for (int i= 0; i < 3; i++) {
			assertEquals("aaaa", next(state));
			assertEquals("", next(state));
		}

		//empty, aaaa and bbbb
		list.add(1, "bbbb");
		state= createAccessor(list.iterator(), 0);
		assertFalse(state.getBoolean("hasOnly1EmptySuggestion"));

		for (int i= 0; i < 3; i++) {
			assertEquals("aaaa", next(state));
			assertEquals("bbbb", next(state));
			assertEquals("", next(state));
		}


		//empty, aaaa and 2 from 'bbbb' (should make unique)
		list.add(2, "bbbb");
		state= createAccessor(list.iterator(), 0);
		assertFalse(state.getBoolean("hasOnly1EmptySuggestion"));

		for (int i= 0; i < 3; i++) {
			assertEquals("aaaa", next(state));
			assertEquals("bbbb", next(state));
			assertEquals("", next(state));
		}
	}

	/*
	 * Getting completions lazily
	 */
	@Test
	public void testIteration() throws Exception {
		//Check only with current document
		IDocument openDocument= new Document("" +
				"bar\n" +
				"bar1\n" +
				"bar2\n" +
				"");

		Iterator<String> suggestions= fEngine.getMultipleDocumentsIterator(openDocument, new ArrayList<IDocument>(), "bar", 3);
		assertEquals("1", suggestions.next());
		assertEquals("2", suggestions.next());
		assertEquals("", suggestions.next());
		assertFalse(suggestions.hasNext());


		//Check with 2 documents
		List<IDocument> otherDocuments= new ArrayList<>();
		otherDocuments.add(new Document("" +
				"bar3\n" +
				"bar4\n" +
				""));

		suggestions= fEngine.getMultipleDocumentsIterator(openDocument, otherDocuments, "bar", 3);
		assertEquals("1", suggestions.next());
		assertEquals("2", suggestions.next());
		assertEquals("3", suggestions.next());
		assertEquals("4", suggestions.next());
		assertEquals("", suggestions.next());
		assertFalse(suggestions.hasNext());


		//Check with duplicates (duplicates are gotten at this level -- they're removed later -- at the CompletionState)
		suggestions= fEngine.getMultipleDocumentsIterator(openDocument, otherDocuments, "bar", 3);
		otherDocuments.add(new Document());
		otherDocuments.add(new Document("" +
				"bar3\n" +
				"bar4\n" +
				""));
		assertEquals("1", suggestions.next());
		assertEquals("2", suggestions.next());
		assertEquals("3", suggestions.next());
		assertEquals("4", suggestions.next());
		assertEquals("3", suggestions.next());
		assertEquals("4", suggestions.next());
		assertEquals("", suggestions.next());
		assertFalse(suggestions.hasNext());

		//Check with current document with only backward matches
		openDocument= new Document("" +
				"bar0 bar1 bar" +
				"");

		suggestions= fEngine.getMultipleDocumentsIterator(openDocument, new ArrayList<IDocument>(), "bar", openDocument.getLength());
		assertEquals("1", suggestions.next());
		assertEquals("0", suggestions.next());
		assertEquals("", suggestions.next());
		assertFalse(suggestions.hasNext());

	}

	private List<String> createSuggestions(String prefix, IDocument doc) {
		return createSuggestions(prefix, Arrays.asList(new IDocument[]{doc}));
	}

	private List<String> createSuggestions(String prefix, List<IDocument> docsList) {
		ArrayList<String> results= new ArrayList<>();
		for (IDocument doc : docsList) {
			try {
				results.addAll(fEngine.getCompletionsForward(doc, prefix, 0, false));
			} catch (BadLocationException e) {
				assertTrue("No exception should be thrown here", false);
			}
		}
		return results;
	}

}