/********************************************************************************
 * Copyright (c) 2015-2019 Contributors to the Eclipse Foundation
 *
 * See the NOTICE file(s) distributed with this work for additional
 * information regarding copyright ownership.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 ********************************************************************************/

package org.eclipse.mdm.shoppingbasket.boundary;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import static org.mockito.Mockito.when;

import java.io.InputStream;
import java.io.StringReader;
import java.net.URISyntaxException;
import java.util.Arrays;
import java.util.Optional;

import javax.ws.rs.client.Entity;
import javax.ws.rs.core.Application;
import javax.ws.rs.core.UriBuilder;
import javax.xml.XMLConstants;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;
import javax.xml.validation.Validator;

import org.assertj.core.groups.Tuple;
import org.eclipse.mdm.api.base.model.Measurement;
import org.eclipse.mdm.api.base.model.TestStep;
import org.eclipse.mdm.api.base.query.DataAccessException;
import org.eclipse.mdm.api.dflt.ApplicationContext;
import org.eclipse.mdm.api.dflt.EntityManager;
import org.eclipse.mdm.connector.boundary.ConnectorService;
import org.eclipse.mdm.shoppingbasket.entity.MDMItem;
import org.eclipse.mdm.shoppingbasket.entity.ShoppingBasket;
import org.eclipse.mdm.shoppingbasket.entity.ShoppingBasketRequest;
import org.glassfish.hk2.api.Factory;
import org.glassfish.hk2.utilities.binding.AbstractBinder;
import org.glassfish.jersey.jackson.JacksonFeature;
import org.glassfish.jersey.server.ResourceConfig;
import org.glassfish.jersey.test.JerseyTest;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;

import com.google.common.collect.ImmutableMap;

public class ShoppingBasketResourceTest extends JerseyTest {

	private static ApplicationContext context = Mockito.mock(ApplicationContext.class);
	private static EntityManager em = Mockito.mock(EntityManager.class);
	private static ConnectorService connectorService = Mockito.mock(ConnectorService.class);

	private static TestStep testStep = Mockito.mock(TestStep.class);
	private static Measurement measurement = Mockito.mock(Measurement.class);

	public static class ConnectorServiceFactory implements Factory<ConnectorService> {
		@Override
		public void dispose(ConnectorService connectorService) {
			// nothing to do here
		}

		@Override
		public ConnectorService provide() {
			return connectorService;
		}
	}

	@Override
	public Application configure() {
		ResourceConfig config = new ResourceConfig();

		config.register(new AbstractBinder() {
			@Override
			protected void configure() {
				bindFactory(ConnectorServiceFactory.class).to(ConnectorService.class);
			}
		});

		config.register(ShoppingBasketResource.class);
		config.register(JacksonFeature.class);
		return config;
	}

	@Before
	public void init() {

		when(testStep.getSourceName()).thenReturn("MDMTEST");
		when(testStep.getTypeName()).thenReturn("TestStep");
		when(testStep.getID()).thenReturn("1");

		when(measurement.getSourceName()).thenReturn("MDMTEST");
		when(measurement.getTypeName()).thenReturn("Measurement");
		when(measurement.getID()).thenReturn("2");

		when(connectorService.getContextByName("MDMTEST")).thenReturn(context);
		when(context.getEntityManager()).thenReturn(Optional.of(em));
		when(em.load(TestStep.class, "1")).thenReturn(testStep);
		when(context.getAdapterType()).thenReturn("ods");
		when(em.getLinks(Mockito.anyList())).thenReturn(ImmutableMap.of(testStep, "servicename/asampath"));
	}

	@Test
	public void testEmptyShoppingBasketRequest() {
		ShoppingBasketRequest request = new ShoppingBasketRequest();

		ShoppingBasket basket = target("shoppingbasket").request().post(Entity.json(request), ShoppingBasket.class);
		assertThat(basket.getItems()).isEmpty();
	}

	@Test
	public void testShoppingBasket() throws DataAccessException, URISyntaxException {
		when(em.getLinks(Mockito.anyList())).thenReturn(ImmutableMap.of(testStep, "servicename/asampath/testStep",
				measurement, "servicename/asampath/measurement"));

		ShoppingBasket basket = target("shoppingbasket").request().post(Entity.json(getShoppingBasketRequest()),
				ShoppingBasket.class);

		assertThat(basket.getName()).isEqualTo("my shopping basket (<äöüß\\/>)");
		assertThat(basket.getItems()).extracting(i -> Tuple.tuple(i.getSource(), i.getLink(), i.getRestURI()))
				.containsExactly(
						Tuple.tuple("ods", "servicename/asampath/testStep",
								UriBuilder.fromUri(this.getBaseUri()).path("/environments/MDMTEST/teststeps/1")
										.build()),
						Tuple.tuple("ods", "servicename/asampath/measurement", UriBuilder.fromUri(this.getBaseUri())
								.path("/environments/MDMTEST/measurements/2").build()));
	}

	@Test
	public void testValidateShoppingBasketXml() {
		String xml = target("shoppingbasket").request().post(Entity.json(getShoppingBasketRequest()), String.class);
		validateAgainstXSD(xml, ShoppingBasketResourceTest.class.getResourceAsStream("/shoppingbasket1.0.xsd"));
		System.out.println(xml);
	}

	private ShoppingBasketRequest getShoppingBasketRequest() {
		MDMItem item1 = new MDMItem();
		item1.setSource("MDMTEST");
		item1.setType("TestStep");
		item1.setId("1");

		MDMItem item2 = new MDMItem();
		item2.setSource("MDMTEST");
		item2.setType("Measurement");
		item2.setId("2");

		ShoppingBasketRequest request = new ShoppingBasketRequest();
		request.setName("my shopping basket (<äöüß\\/>)");
		request.setItems(Arrays.asList(item1, item2));
		return request;
	}

	private void validateAgainstXSD(String xml, InputStream xsd) {
		try {
			SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
			Schema schema = factory.newSchema(new StreamSource(xsd));
			Validator validator = schema.newValidator();
			validator.validate(new StreamSource(new StringReader(xml)));
		} catch (Exception ex) {
			fail("XML could not be validated: " + xml, ex);
		}
	}

}