/*******************************************************************************
 * Copyright (c) 2000, 2020 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.ui.workbench.texteditor.tests;

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

import java.util.Random;

import org.junit.FixMethodOrder;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TestName;
import org.junit.runners.MethodSorters;

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

/**
 * Tests the FindReplaceDialog.
 *
 * @since 3.1
 */
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class TextEditorPluginTest {

	@Rule
	public TestName testName = new TestName();

	Random rand = new Random(55); //pseudo-random for repeatability

	@Test
	public void testEditPositionHistory() {
		HistoryTracker<Integer> history= new HistoryTracker<>(3,
				Integer.class,
				(a, b) -> Math.abs(a - b) < 5, true);

		assertEquals(0, history.getSize());
		history.addOrReplace(10);
		assertEquals(1, history.getSize());
		assertEquals(10, history.getCurrentBrowsePoint().intValue());

		history.addOrReplace(20);
		assertEquals(2, history.getSize());
		assertEquals(20, history.getCurrentBrowsePoint().intValue());

		history.addOrReplace(30);
		assertEquals(3, history.getSize());
		assertEquals(30, history.getCurrentBrowsePoint().intValue());

		checkContent(history, new Integer[] { 10, 20, 30 });


		int replaced= history.addOrReplace(40).intValue();
		assertEquals(3, history.getSize());
		assertEquals(10, replaced);
		assertEquals(Integer.valueOf(40), history.getCurrentBrowsePoint());

		HistoryTracker.Navigator<Integer> nav = history.navigator();
		assertEquals(Integer.valueOf(40), nav.currentItem());
		assertEquals(Integer.valueOf(30), nav.priorItem());
		assertEquals(Integer.valueOf(20), nav.priorItem());
		assertEquals(Integer.valueOf(40), nav.priorItem());
		checkContent(history, new Integer[] { 20, 30, 40 });

		assertFalse(history.contains(10));

		replaced = history.addOrReplace(22);
		assertTrue(history.contains(22));
		assertFalse(history.contains(20));
		assertEquals(20, replaced);
		checkContent(history, new Integer[] { 30, 40, 22 });
		//assertTrue(22 == history.getCurrentBrowsePoint());

		replaced = history.addOrReplace(31);
		assertTrue(history.contains(31));
		assertFalse(history.contains(30));
		assertEquals(30, replaced);
		assertEquals(31, history.getCurrentBrowsePoint().intValue());
		checkContent(history, new Integer[] { 40, 22, 31 });

		replaced = history.addOrReplace(60);
		assertTrue(history.contains(60));
		assertEquals(60, history.getCurrentBrowsePoint().intValue());
		assertEquals(3, history.getSize());
		checkContent(history, new Integer[] { 22, 31, 60 });

		assertEquals(31, history.browseBackward().intValue());
		assertEquals(31, history.getCurrentBrowsePoint().intValue());
		assertEquals(3, history.getSize());

		//consuming size times should bring you full circle back to origin
		testBacktrackCycle(history);

		//try editing after backtracking less than full cycle
		history.browseBackward();
		Integer last = history.getCurrentBrowsePoint();
		assertEquals(Integer.valueOf(22), last);
		history.addOrReplace(11);
		checkContent(history, new Integer[] { 31, 60, 11 });

		testBacktrackCycle(history);
		history.browseBackward();
		assertEquals(Integer.valueOf(60), history.getCurrentBrowsePoint());
	}

	<T> void checkContent(HistoryTracker<T> history, T[] data) {
		HistoryTracker.Navigator<T> nav = history.navigator();
		assertEquals(data[data.length - 1], nav.currentItem());

		for(int i=data.length - 2; i>0; i--) {
			assertEquals(data[i], nav.priorItem());
		}
		assertEquals(history.getSize(), data.length);
	}

	@Test
	public void testEditPositionHistory2() {
		HistoryTracker<Integer> history= new HistoryTracker<>(3,
				Integer.class,
				(a, b) -> Math.abs(a - b) < 5, true);

		assertEquals(0, history.getSize());
		history.addOrReplace(10);
		assertEquals(1, history.getSize());
		assertEquals(10, history.getCurrentBrowsePoint().intValue());

		history.addOrReplace(20);
		assertEquals(2, history.getSize());
		assertEquals(20, history.getCurrentBrowsePoint().intValue());

		history.addOrReplace(30);
		assertEquals(3, history.getSize());
		assertEquals(30, history.getCurrentBrowsePoint().intValue());

		int replaced= history.addOrReplace(22).intValue();
		assertEquals(3, history.getSize());
		assertEquals(20, replaced);
		assertEquals(Integer.valueOf(22), history.getCurrentBrowsePoint());

		assertEquals(Integer.valueOf(30), history.browseBackward());
		assertEquals(Integer.valueOf(10), history.browseBackward());
		assertEquals(Integer.valueOf(22), history.browseBackward());

		testBacktrackCycle(history);
	}

	@Test
	public void testHistoryEviction() {
		HistoryTracker<Integer> history= new HistoryTracker<>(3,
				Integer.class,
				(a, b) -> Math.abs(a - b) < 5,
				true);

		assertEquals(0, history.getSize());
		history.addOrReplace(10);
		assertEquals(1, history.getSize());
		assertEquals(10, history.getCurrentBrowsePoint().intValue());

		history.addOrReplace(10);
		assertEquals(1, history.getSize());
		assertEquals(10, history.getCurrentBrowsePoint().intValue());

		history.addOrReplace(11);
		assertEquals(1, history.getSize());
		assertEquals(11, history.getCurrentBrowsePoint().intValue());
	}

	@Test
	public void testHistoryEviction2() {
		HistoryTracker<Integer> history= new HistoryTracker<>(3,
				Integer.class,
				(a, b) -> Math.abs(a - b) < 5,
				true);

		history.addOrReplace(10);
		history.addOrReplace(20);
		history.addOrReplace(30);
		assertEquals(Integer.valueOf(20), history.browseBackward());
		assertEquals(Integer.valueOf(10), history.addOrReplace(40));
	}

	@Test
	public void testHistoryEviction3() {
		HistoryTracker<Integer> history= new HistoryTracker<>(3,
				Integer.class,
				(a, b) -> Math.abs(a - b) < 5,
				true);

		history.addOrReplace(10);
		history.addOrReplace(11);
		history.addOrReplace(20);
		history.addOrReplace(21);
		history.addOrReplace(12);
		checkContent(history, new Integer[] { 21, 12 });
	}

	@Test
	public void testLinearEditPositionHistory() {
		HistoryTracker<Integer> history= new HistoryTracker<>(3,
				Integer.class,
				(a, b) -> Math.abs(a - b) < 5,
				false);

		assertEquals(0, history.getSize());
		history.addOrReplace(10);
		assertEquals(1, history.getSize());
		assertEquals(10, history.getCurrentBrowsePoint().intValue());

		history.addOrReplace(20);
		assertEquals(2, history.getSize());
		assertEquals(20, history.getCurrentBrowsePoint().intValue());

		history.addOrReplace(30);
		assertEquals(3, history.getSize());
		assertEquals(30, history.getCurrentBrowsePoint().intValue());

		int replaced = history.addOrReplace(22);
		assertEquals(3, history.getSize());
		assertEquals(20, replaced);
		assertEquals(Integer.valueOf(22), history.getCurrentBrowsePoint());

		assertEquals(Integer.valueOf(30), history.browseBackward());
		assertEquals(Integer.valueOf(10), history.browseBackward());
		assertEquals(Integer.valueOf(10), history.browseBackward());

		assertEquals(Integer.valueOf(30), history.browseForward());
		assertEquals(Integer.valueOf(22), history.browseForward());
		assertEquals(Integer.valueOf(22), history.browseForward());

	}

	@Test
	public void testLinearEditPositionHistory2() {
		HistoryTracker<Integer> history= new HistoryTracker<>(3,
				Integer.class,
				(a, b) -> Math.abs(a - b) < 5,
				false);

		history.addOrReplace(10);
		history.addOrReplace(20);
		history.addOrReplace(30);

		int replaced= history.addOrReplace(22).intValue();
		assertEquals(3, history.getSize());
		assertEquals(20, replaced);
		assertEquals(Integer.valueOf(22), history.getCurrentBrowsePoint());

		//end reached, go no further
		assertEquals(Integer.valueOf(22), history.getNext());

		assertEquals(Integer.valueOf(30), history.browseBackward());
		assertEquals(Integer.valueOf(10), history.browseBackward());

		//beginning reached, go no further
		assertEquals(Integer.valueOf(10), history.browseBackward());
	}

	@Test
	public void testMRUOrderAlwaysPreserved() {
		HistoryTracker<Integer> history= new HistoryTracker<>(3,
				Integer.class,
				(a, b) -> Math.abs(a - b) < 5,
				false);

		history.addOrReplace(10);
		history.addOrReplace(20);
		history.addOrReplace(30);

		assertEquals(Integer.valueOf(20), history.browseBackward());
		history.addOrReplace(11);
		assertEquals(Integer.valueOf(11), history.getCurrentBrowsePoint());

		assertEquals(Integer.valueOf(30), history.browseBackward());
		assertEquals(Integer.valueOf(20), history.browseBackward());
	}

	@Test
	public void testMRUOrderAlwaysPreserved2() {
		HistoryTracker<Integer> history= new HistoryTracker<>(3,
				Integer.class,
				(a, b) -> Math.abs(a - b) < 5,
				false);

		history.addOrReplace(10);
		history.addOrReplace(20);
		history.addOrReplace(30);

		assertEquals(Integer.valueOf(20), history.browseBackward());
		history.addOrReplace(40);
		assertEquals(Integer.valueOf(40), history.getCurrentBrowsePoint());

		assertEquals(Integer.valueOf(30), history.browseBackward());
		assertEquals(Integer.valueOf(20), history.browseBackward());
		assertEquals(Integer.valueOf(20), history.browseBackward());

	}

	private <T> void testBacktrackCycle(HistoryTracker<T> history) {
		T last = history.getCurrentBrowsePoint();
		for(int i=0; i<history.getSize() -1; i++) {
			history.browseBackward();
			assertNotEquals(last, history.getCurrentBrowsePoint());
		}
		history.browseBackward();
		assertEquals(last, history.getCurrentBrowsePoint());
	}

	@Test
	public void testEditPositionHistoryChaos() {
		final int HISTORY_SIZE= 10;
		HistoryTracker<Integer> history= new HistoryTracker<>(HISTORY_SIZE,
				Integer.class,
				(a, b) -> Math.abs(a - b) < 5, true);

		for(int i=0;i<100;i++) {
			if(rand.nextBoolean()) {
				addRandom(history);
			} else {
				goBack(history);
			}
			assertTrue(history.isHealthy());
			assertTrue(history.getSize() <= HISTORY_SIZE);
		}
	}

	@Test
	public void testLinearEditPositionHistoryChaos() {
		final int HISTORY_SIZE= 10;
		HistoryTracker<Integer> history= new HistoryTracker<>(HISTORY_SIZE,
				Integer.class,
				(a,b) -> Math.abs(a - b) < 5,
				false
				);

		int backsInARow = 0;
		for(int i=0;i<100;i++) {
			if(rand.nextBoolean()) {
				backsInARow = 0;
				addRandom(history);
			} else {
				backsInARow ++;
				goBackLinear(history, backsInARow < history.getSize());
			}
			assertTrue(history.isHealthy());
			assertTrue(history.getSize() <= HISTORY_SIZE);
		}
	}


	private void addRandom(HistoryTracker<Integer> history) {
		Integer latest = rand.nextInt(50);
		history.addOrReplace(latest);
		assertEquals(latest, history.getCurrentBrowsePoint());
	}

	private void goBack(HistoryTracker<Integer> history) {
		int size = history.getSize();
		Integer latest = history.getCurrentBrowsePoint();
		Integer prior = history.browseBackward();
		if (size > 1) {
			assertNotEquals(latest, prior);
		}
	}

	private void goBackLinear(HistoryTracker<Integer> history, boolean shouldMove) {
		Integer latest= history.getCurrentBrowsePoint();
		Integer prior = history.browseBackward();
		if(shouldMove)
			assertNotEquals(latest, prior);
		else
			assertEquals(latest, prior);
	}

}