/*******************************************************************************
 * Copyright (C) 2021 the Eclipse BaSyx Authors
 * 
 * This program and the accompanying materials are made
 * available under the terms of the Eclipse Public License 2.0
 * which is available at https://www.eclipse.org/legal/epl-2.0/
 * 
 * SPDX-License-Identifier: EPL-2.0
 ******************************************************************************/
package org.eclipse.basyx.testsuite.regression.vab.modelprovider;

import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;

import org.eclipse.basyx.vab.modelprovider.VABPathTools;
import org.junit.Test;

/**
 * Tests the functionality of the VABPathTools utility class
 * 
 * @author espen
 *
 */
public class VABPathToolsTest {
	// test all cases of "empty" paths
	String[] empty = new String[] { "/", "" };

	// test all cases of /-placement for single elements
	String[] single = new String[] { "element", "/element", "element/", "/element/" };

	// test all cases of /-placement for multiple elements
	String[] pair = new String[] { "parent/child", "/parent/child", "parent/child/", "/parent/child/" };

	// Test strings
	String pathWithoutAddress = "a/b/c";
	String pathWithOneAddress = "http://AASServer//a/b/c";
	String pathWithTwoAddress = "basyx://127.0.0.1:6889//http://AASServer//a/b/c";
	String onlyAddress = "basyx://127.0.0.1:6889";
	String pathWithoutAddressMultislash = "a//b///c";

	@Test
	public void testStripSlashes() {
		assertEquals("test", VABPathTools.stripSlashes("/test"));
		assertEquals("test", VABPathTools.stripSlashes("//test"));
		assertEquals("test", VABPathTools.stripSlashes("test/"));
		assertEquals("test", VABPathTools.stripSlashes("/test//"));
		assertEquals("test", VABPathTools.stripSlashes("/test/"));
		assertEquals("test", VABPathTools.stripSlashes("//test//"));
	}

	/**
	 * Tests remove address
	 */
	@Test
	public void testRemoveAddress() {
		assertEquals(pathWithoutAddress, VABPathTools.removeFirstEndpoint(pathWithoutAddress));
		assertEquals(pathWithoutAddress, VABPathTools.removeFirstEndpoint(pathWithOneAddress));
		assertEquals("", VABPathTools.removeFirstEndpoint(onlyAddress));
		assertNull(VABPathTools.removeFirstEndpoint(null));
	}

	/**
	 * Tests get address
	 */
	@Test
	public void testGetAddress() {
		assertEquals("", VABPathTools.getFirstEndpoint(pathWithoutAddress));
		assertEquals("basyx://127.0.0.1:6889", VABPathTools.getFirstEndpoint(pathWithTwoAddress));
		assertEquals(onlyAddress, VABPathTools.getFirstEndpoint(onlyAddress));
		assertNull(VABPathTools.getFirstEndpoint(null));
	}

	/**
	 * For each element in the path, exactly one string element should be present in
	 * the resulting array
	 */
	@Test
	public void testSplitPath() {
		for (String test : empty) {
			assertEquals(0, VABPathTools.splitPath(test).length);
		}
		for (String test : single) {
			assertEquals(1, VABPathTools.splitPath(test).length);
			assertEquals("element", VABPathTools.splitPath(test)[0]);
		}
		for (String test : pair) {
			assertEquals(2, VABPathTools.splitPath(test).length);
			assertEquals("parent", VABPathTools.splitPath(test)[0]);
			assertEquals("child", VABPathTools.splitPath(test)[1]);
		}
		assertNull(VABPathTools.splitPath(null));

		// Assert that independent of number of slashs, splitting is always handled the
		// same
		assertArrayEquals(VABPathTools.splitPath(pathWithoutAddressMultislash), VABPathTools.splitPath(pathWithoutAddress));
	}

	/**
	 * Test concenating multiple paths
	 */
	@Test
	public void concatenatePaths() {
		for (String a : single) {
			assertEquals("element", VABPathTools.concatenatePaths(a));
			for (String b : pair) {
				assertEquals("element/parent/child", VABPathTools.concatenatePaths(a, b));
			}
		}
		assertEquals("", VABPathTools.concatenatePaths(""));
		assertNull(VABPathTools.concatenatePaths());
		assertNull(VABPathTools.concatenatePaths(null, ""));
		assertNull(VABPathTools.concatenatePaths("", null));
	}

	@Test
	public void testGetParentPath() {
		for (String test : empty) {
			assertEquals("", VABPathTools.getParentPath(test));
		}
		for (String test : single) {
			assertEquals("", VABPathTools.getParentPath(test));
		}
		for (String test : pair) {
			assertEquals("parent", VABPathTools.getParentPath(test));
		}
		assertNull(VABPathTools.getParentPath(null));
	}

	@Test
	public void testGetLastElement() {
		for (String test : empty) {
			assertEquals("", VABPathTools.getLastElement(test));
		}
		for (String test : single) {
			assertEquals("element", VABPathTools.getLastElement(test));
		}
		for (String test : pair) {
			assertEquals("child", VABPathTools.getLastElement(test));
		}
		assertNull(VABPathTools.getLastElement(null));
	}

	@Test
	public void testRemovePrefix() {
		for (String test : empty) {
			assertEquals("", VABPathTools.removePrefix(test, "/"));
		}
		for (String test : single) {
			assertTrue(VABPathTools.removePrefix(test, "/").startsWith("element"));
		}
		for (String test : pair) {
			assertTrue(VABPathTools.removePrefix(test, "/").startsWith("parent"));
		}
		assertNull(VABPathTools.removePrefix(null, "/"));
	}

	@Test
	public void testBuildPath() {
		assertEquals("", VABPathTools.buildPath(new String[] {}, 0));
		assertEquals("b", VABPathTools.buildPath(new String[] { "a", "b" }, 1));
		assertEquals("b/c", VABPathTools.buildPath(new String[] { "a", "b", "c" }, 1));
		assertEquals("a/b/c", VABPathTools.buildPath(new String[] { "a", "b", "c" }, 0));
		assertNull(VABPathTools.buildPath(null, 0));
	}

	@Test
	public void testAppend() {
		assertEquals("/parent/child", VABPathTools.append("/parent", "child"));
		assertEquals("/parent/child", VABPathTools.append("/parent/", "child"));
		assertEquals("/parent/x/child", VABPathTools.append("/parent/x", "child"));
		assertEquals("/parent/x/child", VABPathTools.append("/parent/x/", "child"));
		assertNull(VABPathTools.append(null, ""));
		assertNull(VABPathTools.append("", null));
	}

	@Test
	public void testIsOperationPath() {
		String[] positive = { "submodelElements/id/invoke", "submodelElements/id/invoke/",
				"operations/id/invoke", "operations/id/invoke/", "operations/test", "elem/operations/id" };
		String[] negative = { "", "/submodelElementsX/", "/myoperations/", "/submodelElementsFake/",
				"/submodelElementsFake/operationX/", "submodelElements/id/" };
		for (String test : positive) {
			assertTrue(test, VABPathTools.isOperationInvokationPath(test));
		}
		for (String test : negative) {
			assertFalse(test, VABPathTools.isOperationInvokationPath(test));
		}
		assertFalse(VABPathTools.isOperationInvokationPath(null));
	}
	
	@Test
	public void testStripInvokeFromPath() {
		assertEquals("id", VABPathTools.stripInvokeFromPath("id/invoke"));
		assertEquals("", VABPathTools.stripInvokeFromPath("invoke"));
		assertEquals("", VABPathTools.stripInvokeFromPath("/invoke"));
		assertEquals("id/value", VABPathTools.stripInvokeFromPath("id/value"));
		assertEquals("", VABPathTools.stripInvokeFromPath(""));
	}
	
	@Test
	public void testGetPathFromURL() {
		
		String[] urls = {"http://localhost:8080/test/elem.aasx", "http://localhost/test/elem.aasx",
				"basyx://127.0.0.1:4000//http://localhost:8080/test/elem.aasx", "/test/elem.aasx", "test/elem.aasx"};
		
		for(String url: urls) {
			assertEquals("/test/elem.aasx", VABPathTools.getPathFromURL(url));
		}
	}

	@Test
	public void testHarmonizePathWithSuffix() {
		String expected = "http://localhost:8080/server/subserver/suffix";
		String[] toTest = { expected, 
							"http://localhost:8080/server/subserver/suffix/", 
							"http://localhost:8080/server/subserver/", 
				"http://localhost:8080/server/subserver", };

		for (String t : toTest) {
			String harmonized = VABPathTools.harmonizePathWithSuffix(t, "suffix");
			assertEquals(expected, harmonized);

			// Check also for suffixes with a leading slash
			String harmonizedLeadingSlash = VABPathTools.harmonizePathWithSuffix(t, "/suffix");
			assertEquals(expected, harmonizedLeadingSlash);

			// Check also for suffixes with a ending slash
			String harmonizedEndingSlash = VABPathTools.harmonizePathWithSuffix(t, "suffix/");
			assertEquals(expected, harmonizedEndingSlash);
		}

		// Check for edge case where a path is ending with the suffix, but not on its
		// own
		String edgeCaseExpected = "http://localhost:8080/server/subserversuffix/suffix";
		assertEquals(edgeCaseExpected, VABPathTools.harmonizePathWithSuffix("http://localhost:8080/server/subserversuffix/", "suffix"));
	}
}