/* ###
 * IP: GHIDRA
 *
 * 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
 * 
 *      http://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 docking.widgets.table;

import static org.junit.Assert.*;

import java.awt.BorderLayout;
import java.awt.Container;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;

import javax.swing.*;
import javax.swing.table.TableModel;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.junit.*;

import docking.widgets.filter.FilterOptions;
import docking.widgets.table.threaded.ThreadedTableModelStub;
import ghidra.docking.settings.Settings;
import ghidra.framework.plugintool.ServiceProvider;
import ghidra.test.AbstractGhidraHeadedIntegrationTest;
import ghidra.util.datastruct.Accumulator;
import ghidra.util.exception.CancelledException;
import ghidra.util.task.TaskMonitor;

public class SelectionManagerTest extends AbstractGhidraHeadedIntegrationTest {

	private static final int TEST_COLUMN_COUNT = 4;
	private static final int MIN_ROW_COUNT = 10;
	private static final int MAX_ROW_COUNT = 40;
	private static final int MAX_THREAD_SLEEP_DELAY = 100;

	private JFrame frame;
	private GTable table;
	private NonRowObjectFilterTestTableModel model;
	private ThreadedTestTableModel threadedModel;

	private Logger logger;

	@Before
	public void setUp() throws Exception {

		logger = LogManager.getLogger(SelectionManager.class);
//		setLogLevel(SelectionManager.class, Level.DEBUG);

		logger.trace("\n\nsetUp(): " + testName.getMethodName());

		List<StringRowObject> data = createBasicData();
		model = new NonRowObjectFilterTestTableModel(data);

		// must created the threaded model in the swing thread (it's part of the contract)
		runSwing(() -> threadedModel = new ThreadedTestTableModel());
	}

	@After
	public void tearDown() throws Exception {
		threadedModel.dispose();
		frame.dispose();

		logger.trace("tearDown() - leaving: " + testName.getMethodName() + "\n\n");
	}

	@Test
	public void testRestoreSelectionAfterTableChanged() {
		doTestRestoreSelectionAfterTableChanged(false);
		doTestRestoreSelectionAfterTableChanged(true);
	}

	@Test
	public void testSelectionRestoreAfterSortingAndFilteringAndSorting() throws Exception {
		//
		// Sort.  Filter.  Make a selection.  Change the sort.
		// Make sure the same 'row object' is selected.
		// There was a bug found under these series of events (because the full dataset was
		// sorted differently than the filtered dataset)
		//
		createTable(true);
		assertEquals("Table unexpectedly has a selection by default for threaded model", 0,
			table.getSelectedRowCount());

		int startRow = 2; // start with an even row (odd will be filtered-out)
		selectRow(startRow);
		StringRowObject startObject = getSelectedObject();

		changeSort();

		setFilterText("even"); // filter out odd rows

		assertEquals("Incorrect object was re-selected", startObject, getSelectedObject());

		changeSort();

		assertEquals("Incorrect object was re-selected", startObject, getSelectedObject());
	}

	@Test
	public void testSelectionRestoreAfterFiltering_RowObjectMissing() throws Exception {
		//
		// Make a selection.  Filter the selection out.  Remove the filter.
		// Make sure the same 'row object' is selected.
		//
		String threadedDescription = "threaded model";
		createTable(true);
		assertEquals("Table unexpectedly has a selection by default for " + threadedDescription, 0,
			table.getSelectedRowCount());

		int row = 0;
		selectRow(row);

		setFilterText("garbledeegook");

		int selectedRow = getSelectedRow();
		assertEquals("Selection was not filtered out as expected", -1, selectedRow);

		setFilterText("");

		selectedRow = getSelectedRow();
		assertEquals("Selection was not restored", 0, selectedRow);
	}

	@Test
	public void testSelectionRestoreAfterFiltering_RowObjectPresent() throws Exception {
		//
		// Make a selection.  Add a filter.  Make sure the same 'row object' is selected.
		// Remove the filter.  Make sure the same 'row object' is selected.
		//

		createTable(true);
		assertEquals("Table unexpectedly has a selection by default for threaded model", 0,
			table.getSelectedRowCount());

		int startRow = 2; // start with an even row (odd will be filtered-out)
		selectRow(startRow);
		StringRowObject startObject = getSelectedObject();

		setFilterText("even"); // filter out odd rows

		assertEquals("Incorrect object was re-selected", startObject, getSelectedObject());

		setFilterText("");

		assertEquals("Incorrect object was re-selected", startObject, getSelectedObject());
	}

//==================================================================================================
// Private Methods
//==================================================================================================

	private void doTestRestoreSelectionAfterTableChanged(boolean isThreaded) {
		logger.trace("doTestRestoreSelectionAfterTableChanged - start");

		//
		// Make a selection.  Fire a tableDataChanged().  Make sure the selection returns.
		//
		String threadedDescription = isThreaded ? "threaded model" : "non-threaded model";
		createTable(isThreaded);
		assertEquals("Table unexpectedly has a selection by default for " + threadedDescription, 0,
			table.getSelectedRowCount());

		int row = 0;
		StringRowObject rowObject = getRowObject(row);
		selectRow(row);

		logger.trace("\tafter selected row...firing event");
		fireTableDataChanged();
		logger.trace("\tafter firing event...waiting for model");

		waitForTableModel();
		logger.trace("\tafter waiting for model");

		int selectedRow = getSelectedRow();
		if (selectedRow == -1) {
			Assert.fail("Selection not restored after sorting table");
		}

		StringRowObject newRowObject = getRowObject(selectedRow);
		assertEquals("Row not selected after a tableChanged() event for " + threadedDescription,
			rowObject, newRowObject);

		logger.trace("doTestRestoreSelectionAfterTableChanged - end");
	}

	@Test
	public void testDontRestoreSelectionAfterTableChangedAndNewSelection() {
		doTestDontRestoreSelectionAfterTableChangedAndNewSelection(false);
		doTestDontRestoreSelectionAfterTableChangedAndNewSelection(true);
	}

	private void doTestDontRestoreSelectionAfterTableChangedAndNewSelection(boolean isThreaded) {
		//
		// Make a selection.  Fire a tableDataChanged(). Somehow post a new selection before the
		// repair selection is executed on the swing thread.
		//
		String threadedDescription = isThreaded ? "threaded model" : "non-threaded model";
		createTable(isThreaded);
		assertEquals("Table unexpectedly has a selection by default for " + threadedDescription, 0,
			table.getSelectedRowCount());

		selectRow(0);

		int newRow = 1;
		fireTableDataChangedAndChangeSelection(newRow);

		// the tables current selection should remain the newest selection and not the original
		waitForTableModel();

		int selectedRow = getSelectedRow();
		assertEquals("Last selection made was not preserved", newRow, selectedRow);
	}

	@Test
	public void testRestoreSelectionWithMultipleRowsSelected() {
		doTestRestoreSelectionWithMultipleRowsSelected(false);
		doTestRestoreSelectionWithMultipleRowsSelected(true);
	}

	private void doTestRestoreSelectionWithMultipleRowsSelected(boolean isThreaded) {
		//
		// Make a multi-selection.  Fire a tableDataChanged().  Make sure the multi-selection returns.
		//
		String threadedDescription = isThreaded ? "threaded model" : "non-threaded model";
		createTable(isThreaded);
		assertEquals("Table unexpectedly has a selection by default for " + threadedDescription, 0,
			table.getSelectedRowCount());

		int row1 = 0;
		int row2 = 5;
		selectRows(row1, row2);

		fireTableDataChanged();

		waitForTableModel();

		int selectedRow = table.getSelectedRow();
		if (selectedRow == -1) {
			Assert.fail(
				"Now rows selected after a tableChanged() event for " + threadedDescription);
		}

		int[] selectedRows = table.getSelectedRows();
		assertEquals(2, selectedRows.length);
		assertEquals(row1, selectedRows[0]);
		assertEquals(row2, selectedRows[1]);
	}

	@Test
	public void testRestoreSelectionWithDuplicateRows() {
		doTestRestoreSelectionWithDuplicateRows(false);
		doTestRestoreSelectionWithDuplicateRows(true);
	}

	@SuppressWarnings("unchecked")
	private void doTestRestoreSelectionWithDuplicateRows(boolean isThreaded) {
		logger.trace("doTestRestoreSelectionWithDuplicateRows - start - threaded?: " + isThreaded);

		//
		// Test that normal selections are restored when multiple duplicate rows exist in the table
		//
		String[] data = { "Dup Col 1", "Dup Col 2", "Dup Col 3", "Dup Col 4" };
		StringRowObject duplicateRow1 = new StringRowObject(data);
		StringRowObject duplicateRow2 = new StringRowObject(data);
		StringRowObject duplicateRow3 = new StringRowObject(data);

		addRowToModel(duplicateRow1, isThreaded);
		addRowToModel(duplicateRow2, isThreaded);
		addRowToModel(duplicateRow3, isThreaded);
		createTable(isThreaded);
		fireTableDataChanged();
		waitForTableModel();

		String threadedDescription = isThreaded ? "threaded model" : "non-threaded model";
		createTable(isThreaded);
		assertEquals("Table unexpectedly has a selection by default for " + threadedDescription, 0,
			table.getSelectedRowCount());

		AbstractSortedTableModel<StringRowObject> abstractModel =
			(AbstractSortedTableModel<StringRowObject>) table.getModel();
		int dup1Index = abstractModel.getIndexForRowObject(duplicateRow1);
		int secondNonDuplicateRowIndex = getOtherNonDuplicateRowIndex(dup1Index, abstractModel);

		selectRows(dup1Index, secondNonDuplicateRowIndex);

		fireTableDataChanged();

		waitForTableModel();

		int selectedRow = getSelectedRow();
		if (selectedRow == -1) {
			Assert.fail(
				"Now rows selected after a tableChanged() event for " + threadedDescription);
		}

		int[] selectedRows = table.getSelectedRows();
		assertEquals(2, selectedRows.length);
		assertDuplicateRowSelection(duplicateRow1, dup1Index, selectedRows[0]);
		assertEquals(secondNonDuplicateRowIndex, selectedRows[1]);

		//
		// Same test, but now try when the duplicates themselves are selected
		//
		clearSelection();
		assertEquals("Selection not cleared!", 0, table.getSelectedRowCount());

		int dup3Index = dup1Index + 2;
		selectRows(dup1Index, dup3Index);

		fireTableDataChanged();

		waitForTableModel();

		selectedRow = getSelectedRow();
		if (selectedRow == -1) {
			logger.trace("\tpreparing to fail");
			Assert.fail(
				"Now rows selected after a tableChanged() event for " + threadedDescription);
		}

		selectedRows = table.getSelectedRows();
		assertEquals(2, selectedRows.length);
		assertDuplicateRowSelection(duplicateRow1, dup1Index, selectedRows[0]);
		assertDuplicateRowSelection(duplicateRow3, dup3Index, selectedRows[1]);

		logger.trace("doTestRestoreSelectionWithDuplicateRows - end");
	}

	/**
	 * Make sure that either the two given rows are an exact match, or that the row objects that
	 * represent each row are equal()
	 */
	private void assertDuplicateRowSelection(StringRowObject originalRowObject, int originalRow,
			int newRow) {
		if (originalRow == newRow) {
			return;// exact match--good!
		}

		StringRowObject rowObject = getRowObject(newRow);
		assertEquals("Equivalent row object not selected when selection was restored",
			originalRowObject, rowObject);
	}

	@Test
	public void testSelectionRestoreAfterSorting() {
		doTestSelectionRestoreAfterSorting(false);
		doTestSelectionRestoreAfterSorting(true);
	}

	private void doTestSelectionRestoreAfterSorting(boolean isThreaded) {
		//
		// Make a selection.  Change the sort.  Make sure the same 'row object' is selected.
		//
		String threadedDescription = isThreaded ? "threaded model" : "non-threaded model";
		createTable(isThreaded);
		assertEquals("Table unexpectedly has a selection by default for " + threadedDescription, 0,
			table.getSelectedRowCount());

		int startRow = 0;
		selectRow(startRow);
		StringRowObject startObject = getSelectedObject();

		changeSort();

		waitForTableModel();

		StringRowObject endObject = getSelectedObject();
		assertEquals("Incorrect object was re-selected", startObject, endObject);
	}

	@Test
	public void testSelectionRestoreAfterFiltering() throws Exception {
		//
		// Make a selection.  Change add a filter.  Make sure the same 'row object' is selected.
		//
		String threadedDescription = "threaded model";
		createTable(true);
		assertEquals("Table unexpectedly has a selection by default for " + threadedDescription, 0,
			table.getSelectedRowCount());
	}

	private int getSelectedRow() {
		AtomicInteger ref = new AtomicInteger(-1);
		runSwing(() -> {
			ref.set(table.getSelectedRow());
		});
		return ref.get();
	}

//==================================================================================================
// Private Methods
//==================================================================================================

	@SuppressWarnings("unchecked")
	private StringRowObject getSelectedObject() {

		AtomicReference<StringRowObject> ref = new AtomicReference<>();
		runSwing(() -> {
			int row = table.getSelectedRow();
			TableModel tm = table.getModel();
			RowObjectTableModel<StringRowObject> rowModel =
				(RowObjectTableModel<StringRowObject>) tm;
			StringRowObject rowObject = rowModel.getRowObject(row);
			ref.set(rowObject);
		});
		return ref.get();
	}

	private void createTable(boolean isThreaded) {
		if (frame == null) {
			frame = new JFrame("GTree Test");
		}

		if (isThreaded) {
			table = new GTable(threadedModel);
		}
		else {
			table = new GTable(model);
		}

		Container contentPane = frame.getContentPane();
		contentPane.removeAll();
		contentPane.setLayout(new BorderLayout());
		frame.getContentPane().add(new JScrollPane(table), BorderLayout.CENTER);
		frame.setSize(1000, 400);
		frame.setVisible(true);

		waitForTableModel();
	}

	private void waitForTableModel() {
		if (table.getModel() instanceof ThreadedTestTableModel) {
			waitForTableModel(threadedModel);
		}
		else {
			waitForSwing();
		}
	}

	private void setFilterText(final String text) throws Exception {
		final DefaultTableTextFilterFactory<StringRowObject> factory =
			new DefaultTableTextFilterFactory<>(new FilterOptions());
		final DefaultRowFilterTransformer<StringRowObject> transformer =
			new DefaultRowFilterTransformer<>(model, table.getColumnModel());

		SwingUtilities.invokeAndWait(
			() -> threadedModel.setTableFilter(factory.getTableFilter(text, transformer)));

		waitForTableModel();
	}

	private int getOtherNonDuplicateRowIndex(int dup1Index,
			AbstractSortedTableModel<StringRowObject> tableModel) {
		int otherRow = dup1Index;
		while (otherRow == dup1Index) {
			otherRow = getRandomInt(0, table.getRowCount() - 1);
		}

		StringRowObject currentRowObject = tableModel.getRowObject(dup1Index);
		StringRowObject newRowObject = tableModel.getRowObject(otherRow);
		if (currentRowObject.equals(newRowObject)) {
			// try again--we want the new index to be for a row that is NOT a duplicate
			return getOtherNonDuplicateRowIndex(dup1Index, tableModel);
		}

		return otherRow;
	}

	private void changeSort() {
		AbstractSortedTableModel<?> abstractModel = (AbstractSortedTableModel<?>) table.getModel();
		TableSortState sortState = abstractModel.getTableSortState();
		int columnCount = abstractModel.getColumnCount();
		ColumnSortState columnSortState = null;
		for (int i = 0; i < columnCount; i++) {
			columnSortState = sortState.getColumnSortState(i);
			if (columnSortState != null) {
				break;
			}
		}
		assertNotNull("No sorted column!!?!?", columnSortState);

		ColumnSortState newColumnState = columnSortState.createFlipState();
		TableSortState newSortState = new TableSortState(newColumnState);
		abstractModel.setTableSortState(newSortState);

		waitForSwing();
		waitForTableModel();
	}

	@SuppressWarnings("unchecked")
	private StringRowObject getRowObject(int row) {
		AbstractSortedTableModel<StringRowObject> abstractModel =
			(AbstractSortedTableModel<StringRowObject>) table.getModel();

		return abstractModel.getRowObject(row);
	}

	private void addRowToModel(StringRowObject row, boolean isThreaded) {
		if (isThreaded) {
			threadedModel.addRow(row);
		}
		else {
			model.addRow(row);
		}
	}

	private void clearSelection() {
		runSwing(() -> table.clearSelection());
	}

	private void selectRow(final int row) {
		final ListSelectionModel selectionModel = table.getSelectionModel();
		runSwing(() -> selectionModel.setSelectionInterval(row, row));

		int selectedRow = getSelectedRow();
		assertEquals("Row not selected!", row, selectedRow);

		logger.trace("Selected row value: " + getRowObject(selectedRow));
	}

	private void selectRows(final int row1, final int row2) {
		logger.trace("SMT.selectRows(): " + row1 + " and " + row2);
		final ListSelectionModel selectionModel = table.getSelectionModel();
		runSwing(() -> {
			selectionModel.setSelectionInterval(row1, row1);
			selectionModel.addSelectionInterval(row2, row2);
		});

		int[] selectedRows = table.getSelectedRows();
		assertEquals(2, selectedRows.length);

		logger.trace("\tSMT.selectRows() - found selected rows: " + selectedRows[0] + " and " +
			selectedRows[1]);

		// We may be passed the rows in non-sorted order.  The selection manager will give us
		// results in ascending order.  Make sure to compare them correctly.
		if (row1 > row2) {
			assertEquals(row2, selectedRows[0]);
			assertEquals(row1, selectedRows[1]);
		}
		else {
			assertEquals(row1, selectedRows[0]);
			assertEquals(row2, selectedRows[1]);
		}

		logger.trace("Selected row value: " + getRowObject(row1));
		logger.trace("Selected row value: " + getRowObject(row2));
	}

	private void fireTableDataChanged() {
		runSwing(() -> {
			AbstractSortedTableModel<?> abstractModel =
				(AbstractSortedTableModel<?>) table.getModel();
			abstractModel.fireTableDataChanged();
		});
	}

	private void fireTableDataChangedAndChangeSelection(final int row) {
		runSwing(() -> {
			AbstractSortedTableModel<?> abstractModel =
				(AbstractSortedTableModel<?>) table.getModel();
			abstractModel.fireTableDataChanged();

			// change the selection here...we know that the SelectionManager will try to
			// repair selection in an invoke later, so if we change the selection here, then
			// it should invalidate the selection that is posted to be repaired as a result
			// of the preceding call to fireTableDataChanged()
			ListSelectionModel selectionModel = table.getSelectionModel();
			selectionModel.setSelectionInterval(row, row);
		});

	}

	private List<StringRowObject> createBasicData() {
		int rowCount = getRandomInt(MIN_ROW_COUNT, MAX_ROW_COUNT);
		List<StringRowObject> data = new ArrayList<>(rowCount);
		for (int i = 0; i < rowCount; i++) {
			String[] strings = new String[TEST_COLUMN_COUNT];
			for (int j = 0; j < TEST_COLUMN_COUNT; j++) {
				String oddity = (j % 2 == 0) ? " (even)" : " (odd)";
				strings[j] = getRandomString() + oddity;
			}
			data.add(new StringRowObject(strings));
		}
		return data;
	}

//==================================================================================================
// Inner Classes
//==================================================================================================

	private class StringRowObject {
		private final String[] data;

		StringRowObject(String[] data) {
			this.data = data;
		}

		String get(int column) {
			return data[column];
		}

		@Override
		public String toString() {
			StringBuilder buildy = new StringBuilder();
			for (String string : data) {
				buildy.append(string).append(':');
			}
			return buildy.toString();
		}

		@Override
		public boolean equals(Object obj) {
			if (this == obj) {
				return true;
			}

			if (obj == null) {
				return false;
			}

			if (getClass() != obj.getClass()) {
				return false;
			}

			StringRowObject other = (StringRowObject) obj;
			for (int i = 0; i < data.length; i++) {
				// must be same data in same order
				if (!data[i].equals(other.data[i])) {
					return false;
				}
			}
			return true;
		}

		@Override
		public int hashCode() {
			int hashCode = 0;
			for (String element : data) {
				hashCode += element.hashCode();
			}
			return hashCode;
		}
	}

	private class NonRowObjectFilterTestTableModel
			extends AbstractSortedTableModel<StringRowObject> {

		private final List<StringRowObject> data;

		NonRowObjectFilterTestTableModel(List<StringRowObject> data) {
			this.data = data;
			fireTableDataChanged();// let our parent know our data has been set
		}

		@Override
		public String getName() {
			return "Test";
		}

		@Override
		public String getColumnValueForRow(StringRowObject t, int columnIndex) {
			return t.get(columnIndex);
		}

		void addRow(StringRowObject rowObject) {
			data.add(rowObject);
		}

		@Override
		public List<StringRowObject> getModelData() {
			return data;
		}

		@Override
		public boolean isSortable(int columnIndex) {
			return true;
		}

		@Override
		public int getColumnCount() {
			return TEST_COLUMN_COUNT;
		}

		@Override
		public int getRowCount() {
			return data.size();
		}
	}

	private class ThreadedTestTableModel extends ThreadedTableModelStub<StringRowObject> {

		List<StringRowObject> data;

		protected ThreadedTestTableModel() {
			super(ThreadedTestTableModel.class.getName(), null);
		}

		void addRow(StringRowObject rowObject) {
			super.addObject(rowObject);
		}

		@Override
		protected void doLoad(Accumulator<StringRowObject> accumulator, TaskMonitor monitor)
				throws CancelledException {
			data = createBasicData();
			accumulator.addAll(data);
			for (@SuppressWarnings("unused")
			StringRowObject rowObject : data) {
				sleep(getRandomInt(10, MAX_THREAD_SLEEP_DELAY));
			}
		}

		@Override
		protected TableColumnDescriptor<StringRowObject> createTableColumnDescriptor() {
			TableColumnDescriptor<StringRowObject> descriptor = new TableColumnDescriptor<>();

			descriptor.addVisibleColumn(new ATableColumn());
			descriptor.addVisibleColumn(new BTableColumn());
			descriptor.addVisibleColumn(new CTableColumn());
			descriptor.addVisibleColumn(new DTableColumn());

			return descriptor;
		}

		private class ATableColumn extends AbstractDynamicTableColumnStub<StringRowObject, String> {

			@Override
			public String getColumnName() {
				return "A";
			}

			@Override
			public String getValue(StringRowObject rowObject, Settings settings,
					ServiceProvider provider) throws IllegalArgumentException {
				return rowObject.get(0);
			}
		}

		private class BTableColumn extends AbstractDynamicTableColumnStub<StringRowObject, String> {

			@Override
			public String getColumnName() {
				return "B";
			}

			@Override
			public String getValue(StringRowObject rowObject, Settings settings,
					ServiceProvider provider) throws IllegalArgumentException {
				return rowObject.get(0);
			}
		}

		private class CTableColumn extends AbstractDynamicTableColumnStub<StringRowObject, String> {

			@Override
			public String getColumnName() {
				return "C";
			}

			@Override
			public String getValue(StringRowObject rowObject, Settings settings,
					ServiceProvider provider) throws IllegalArgumentException {
				return rowObject.get(0);
			}
		}

		private class DTableColumn extends AbstractDynamicTableColumnStub<StringRowObject, String> {

			@Override
			public String getColumnName() {
				return "D";
			}

			@Override
			public String getValue(StringRowObject rowObject, Settings settings,
					ServiceProvider provider) throws IllegalArgumentException {
				return rowObject.get(0);
			}
		}
	}
}
