package org.eclipse.basyx.testsuite.regression.aas.registration;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.fail;

import java.util.List;

import org.eclipse.basyx.aas.metamodel.api.parts.asset.IAsset;
import org.eclipse.basyx.aas.metamodel.map.descriptor.AASDescriptor;
import org.eclipse.basyx.aas.metamodel.map.descriptor.ModelUrn;
import org.eclipse.basyx.aas.metamodel.map.descriptor.SubmodelDescriptor;
import org.eclipse.basyx.aas.metamodel.map.parts.Asset;
import org.eclipse.basyx.aas.registration.api.IAASRegistryService;
import org.eclipse.basyx.submodel.metamodel.api.identifier.IIdentifier;
import org.eclipse.basyx.submodel.metamodel.api.identifier.IdentifierType;
import org.eclipse.basyx.submodel.metamodel.api.reference.enums.KeyElements;
import org.eclipse.basyx.submodel.metamodel.map.identifier.Identifier;
import org.eclipse.basyx.submodel.metamodel.map.qualifier.Referable;
import org.eclipse.basyx.submodel.metamodel.map.reference.Reference;
import org.eclipse.basyx.vab.exception.provider.ResourceNotFoundException;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**
 * Integration test for a registry. All registry provider implementations have to pass these tests.
 * 
 * @author espen
 * 
 */
public abstract class TestRegistryProviderSuite {
	// The registry proxy that is used to access the sql servlet
	protected final IAASRegistryService proxy = getRegistryService();

	// Ids, shortIds and endpoints for registered AAS and submodel
	protected IIdentifier aasId1 = new ModelUrn("urn:de.FHG:devices.es.iese/test:aas:1.0:1:registryAAS#001");
	protected IIdentifier aasId2 = new ModelUrn("urn:de.FHG:devices.es.iese/test:aas:1.0:1:registryAAS#002");
	protected IIdentifier smId1 = new ModelUrn("urn:de.FHG:devices.es.iese/test:aas:1.0:1:statusSM#001");
	protected IIdentifier smId2 = new ModelUrn("urn:de.FHG:devices.es.iese/test:aas:1.0:1:testSM#001");
	protected String aasIdShort1 = "aasIdShort1";
	protected String aasIdShort2 = "aasIdShort2";
	protected String smIdShort1 = "smIdShort1";
	protected String smIdShort2 = "smIdShort2";
	protected String aasEndpoint1 = "http://www.registrytest.de/aas01/aas";
	protected String aasEndpoint2 = "http://www.registrytest.de/aas02/aas";
	protected String smEndpoint1 = "http://www.registrytest.de/aas01/aas/submodels/" + smIdShort1 + "/submodel";
	protected String smEndpoint2 = "http://www.registrytest.de/aas01/aas/submodels/" + smIdShort2 + "/submodel";
	protected Asset asset1;
	protected Asset asset2;
	/**
	 * Getter for the tested registry provider. Tests for actual registry provider
	 * have to realize this method.
	 */
	protected abstract IAASRegistryService getRegistryService();

	/**
	 * Before each test, clean entries are created in the registry using a proxy
	 */
	@Before
	public void setUp() {
		// Create assets
		asset1 = new Asset(new Reference(new Identifier(IdentifierType.CUSTOM, "asset001"), KeyElements.ASSET, false));
		asset1.setIdentification(IdentifierType.CUSTOM, "asset001");
		asset1.setIdShort("asset001");
		asset2 = new Asset(new Reference(new Identifier(IdentifierType.CUSTOM, "asset002"), KeyElements.ASSET, false));
		asset2.setIdentification(IdentifierType.CUSTOM, "asset002");
		asset2.setIdShort("asset002");
		// Create descriptors for AAS and submodels
		AASDescriptor aasDesc1 = new AASDescriptor(aasIdShort1, aasId1, asset1, aasEndpoint1);
		aasDesc1.addSubmodelDescriptor(new SubmodelDescriptor(smIdShort1, smId1, smEndpoint1));
		AASDescriptor aasDesc2 = new AASDescriptor(aasIdShort2, aasId2, asset2, aasEndpoint2);
		
		// Register Asset Administration Shells
		proxy.register(aasDesc1);
		proxy.register(aasDesc2);
	}
	
	/**
	 * Remove registry entries after each test
	 */
	@After
	public void tearDown() {
		try {
			proxy.delete(aasId1);
		} catch (ResourceNotFoundException e) {
			// Does not matter
		}
		try {
			proxy.delete(aasId2);
		} catch (ResourceNotFoundException e) {
			// Does not matter
		}
	}

	/**
	 * Tests getting single entries from the registry and validates the result.
	 */
	@Test
	public void testGetSingleAAS() {
		// Retrieve and check the first AAS
		AASDescriptor descriptor = proxy.lookupAAS(aasId1);
		validateDescriptor1(descriptor);
	}


	/**
	 * Tests getting all entries from the registry and validates the result.
	 */
	@Test
	public void testGetMultiAAS() {
		// Get all registered AAS
		List<AASDescriptor> result = proxy.lookupAll();
		// Check, if both AAS are registered. Ordering does not matter
		assertEquals(2, result.size());
		if (result.get(0).getIdShort().equals(aasIdShort1)) {
			validateDescriptor1(result.get(0));
			validateDescriptor2(result.get(1));
		} else {
			validateDescriptor2(result.get(0));
			validateDescriptor1(result.get(1));
		}
	}

	/**
	 * Checks, if the given descriptor is valid. Should contain the values of the first descriptor
	 * as given by the test setup
	 */
	protected void validateDescriptor1(AASDescriptor descriptor) {
		assertEquals(aasId1.getId(), descriptor.getIdentifier().getId());
		assertEquals(aasId1.getIdType(), descriptor.getIdentifier().getIdType());
		IAsset asset = descriptor.getAsset();
		assertEquals(asset1.getIdentification(), asset.getIdentification());
		assertEquals(aasEndpoint1, descriptor.getFirstEndpoint());

		// Check, if the SM descriptor in the AASDescriptor is correct
		SubmodelDescriptor smDescriptor = descriptor.getSubModelDescriptorFromIdentifierId(smId1.getId());
		assertEquals(smId1.getId(), smDescriptor.getIdentifier().getId());
		assertEquals(smId1.getIdType(), smDescriptor.getIdentifier().getIdType());
		assertEquals(smIdShort1, smDescriptor.get(Referable.IDSHORT));
		assertEquals(smEndpoint1, smDescriptor.getFirstEndpoint());
	}

	/**
	 * Checks, if the given descriptor is valid. Should contain the values of the second descriptor
	 * as given by the test setup
	 */
	protected void validateDescriptor2(AASDescriptor descriptor) {
		assertEquals(aasId2.getId(), descriptor.getIdentifier().getId());
		assertEquals(aasId2.getIdType(), descriptor.getIdentifier().getIdType());
		IAsset asset = descriptor.getAsset();
		assertEquals(asset2.getIdentification(), asset.getIdentification());
		assertEquals(aasEndpoint2, descriptor.getFirstEndpoint());
	}

	@Test
	public void testDeleteWithAssetExtension() {
		// After the setup, both AAS should have been inserted to the registry
		assertNotNull(proxy.lookupAAS(aasId1));
		assertNotNull(proxy.lookupAAS(aasId2));

		proxy.delete(aasId2);

		// After aas2 has been deleted, only aas1 should be registered
		assertNotNull(proxy.lookupAAS(asset1.getIdentification()));

		// Reference of asset-id to the AAS descriptor should also to deleted
		try {
			proxy.lookupAAS(asset2.getIdentification());
			fail();
		} catch (ResourceNotFoundException e) {
			// expected
		}

		proxy.delete(aasId1);

		// Reference of both asset-ids to the AAS descriptors should also to deleted
		try {
			proxy.lookupAAS(asset1.getIdentification());
			fail();
		} catch (ResourceNotFoundException e) {
			// expected
		}
		try {
			proxy.lookupAAS(asset2.getIdentification());
			fail();
		} catch (ResourceNotFoundException e) {
			// expected
		}
	}

	/**
	 * Tests deletion for aas entries
	 */
	@Test
	public void testDeleteCall() {
		// After the setup, both AAS should have been inserted to the registry
		assertNotNull(proxy.lookupAAS(aasId1));
		assertNotNull(proxy.lookupAAS(aasId2));
		
		proxy.delete(aasId2);
		
		// After aas2 has been deleted, only aas1 should be registered
		assertNotNull(proxy.lookupAAS(aasId1));
		try {
			proxy.lookupAAS(aasId2);
			fail();
		} catch (ResourceNotFoundException e) {
			// expected
		}

		proxy.delete(aasId1);

		// After aas1 has been deleted, both should not be registered any more
		try {
			proxy.lookupAAS(aasId1);
			fail();
		} catch (ResourceNotFoundException e) {
			// expected
		}
		try {
			proxy.lookupAAS(aasId2);
			fail();
		} catch (ResourceNotFoundException e) {
			// expected
		}
	}

	/**
	 * Tests deletion for aas entries
	 */
	@Test
	public void testDeleteByAssetIdCall() {
		proxy.delete(asset1.getIdentification());

		// After aas1 has been deleted, only aas2 should be registered
		assertNotNull(proxy.lookupAAS(aasId2));
		assertNotNull(proxy.lookupAAS(asset2.getIdentification()));
		try {
			proxy.lookupAAS(aasId1);
			fail();
		} catch (ResourceNotFoundException e) {
			// expected
		}

		try {
			proxy.lookupAAS(asset1.getIdentification());
			fail();
		} catch (ResourceNotFoundException e) {
			// expected
		}
	}

	@Test(expected = ResourceNotFoundException.class)
	public void testDeleteNotExistingSubmodelFromNotExistingAAS() {
		proxy.delete(new Identifier(IdentifierType.CUSTOM, "nonExistent"), new Identifier(IdentifierType.CUSTOM, "nonExistentSubModelId"));
	}

	@Test(expected = ResourceNotFoundException.class)
	public void testDeleteNotExistingSubModel() {
		proxy.delete(aasId1, new Identifier(IdentifierType.CUSTOM, "nonExistentSubModelId"));
	}

	@Test(expected = ResourceNotFoundException.class)
	public void testDeleteNotExistingAAS() {
		proxy.delete(new Identifier(IdentifierType.CUSTOM, "nonExistent"));
	}

	@Test
	public void testRetrieveSubmodelDescriptors() {
		List<SubmodelDescriptor> descs = proxy.lookupSubmodels(aasId1);
		assertEquals(1, descs.size());
		assertEquals(smIdShort1, descs.get(0).getIdShort());
	}

	@Test
	public void testRetrieveSpecificSubmodelDescriptor() {
		SubmodelDescriptor desc = proxy.lookupSubmodel(aasId1, smId1);
		assertEquals(smIdShort1, desc.getIdShort());
	}

	/**
	 * Tests overwriting the descriptor of an AAS
	 */
	@Test
	public void testOverwritingAASDescriptor() {
		AASDescriptor aasDesc2 = new AASDescriptor(aasIdShort2, aasId2, asset2, "http://testendpoint2/");
		proxy.register(aasDesc2);
		AASDescriptor retrieved = proxy.lookupAAS(aasId2);
		assertEquals(aasDesc2.getFirstEndpoint(), retrieved.getFirstEndpoint());
	}

	/**
	 * Tests addition, retrieval and removal of submodels
	 */
	@Test
	public void testSubmodelCalls() {
		// Add descriptor
		SubmodelDescriptor smDesc = new SubmodelDescriptor(smIdShort2, smId2, smEndpoint2);
		proxy.register(aasId1, smDesc);

		// Ensure that the submodel is correctly stored in the aas descriptor
		AASDescriptor aasDesc = proxy.lookupAAS(aasId1);
		assertEquals(smDesc, aasDesc.getSubmodelDescriptorFromIdShort(smIdShort2));

		// Test overwriting an SM descriptor
		SubmodelDescriptor smDescNew = new SubmodelDescriptor(smIdShort2, smId2, "http://testendpoint2/submodel/");
		proxy.register(aasId1, smDescNew);
		AASDescriptor aasDescNew = proxy.lookupAAS(aasId1);
		assertEquals(smDescNew.getFirstEndpoint(), aasDescNew.getSubmodelDescriptorFromIdShort(smIdShort2).getFirstEndpoint());

		// Remove Submodel
		proxy.delete(aasId1, smId2);

		// Ensure that the submodel was correctly removed
		aasDesc = proxy.lookupAAS(aasId1);
		assertNotNull(aasDesc.getSubmodelDescriptorFromIdShort(smIdShort1));
		assertNull(aasDesc.getSubmodelDescriptorFromIdShort(smIdShort2));
	}
	
	@Test(expected = ResourceNotFoundException.class)
	public void testRegisterSubmodelToNotExistingAAS() {
		proxy.register(new Identifier(IdentifierType.CUSTOM, "nonExistent"), new SubmodelDescriptor(smIdShort1, smId1, smEndpoint1));
	}
}