/*
 * Copyright 2020 A-SIT Plus GmbH
 * AT-specific eIDAS Connector has been developed in a cooperation between EGIZ,
 * A-SIT Plus GmbH, A-SIT, and Graz University of Technology.
 *
 * Licensed under the EUPL, Version 1.2 or - as soon they will be approved by
 * the European Commission - subsequent versions of the EUPL (the "License");
 * You may not use this work except in compliance with the License.
 * You may obtain a copy of the License at:
 * https://joinup.ec.europa.eu/news/understanding-eupl-v12
 *
 * 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.
 *
 * This product combines work with different licenses. See the "NOTICE" text
 * file for details on the various modules and licenses.
 * The "NOTICE" text file is part of the distribution. Any derivative works
 * that you distribute must include a readable copy of the "NOTICE" text file.
 */

package at.asitplus.eidas.specific.modules.auth.eidas.v2.test.tasks;

import static org.apache.commons.lang3.RandomStringUtils.randomAlphabetic;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;

import java.math.BigInteger;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Collections;
import java.util.List;
import java.util.Map;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBElement;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
import javax.xml.namespace.QName;

import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.RandomStringUtils;
import org.jetbrains.annotations.NotNull;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.annotation.DirtiesContext.ClassMode;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import com.github.skjolber.mockito.soap.SoapServiceRule;

import at.asitplus.eidas.specific.modules.auth.eidas.v2.Constants;
import at.asitplus.eidas.specific.modules.auth.eidas.v2.clients.ernp.IErnpClient;
import at.asitplus.eidas.specific.modules.auth.eidas.v2.clients.zmr.IZmrClient;
import at.asitplus.eidas.specific.modules.auth.eidas.v2.clients.zmr.ZmrSoapClient.ZmrRegisterResult;
import at.asitplus.eidas.specific.modules.auth.eidas.v2.dao.MatchedPersonResult;
import at.asitplus.eidas.specific.modules.auth.eidas.v2.dao.RegisterResult;
import at.asitplus.eidas.specific.modules.auth.eidas.v2.dao.SimpleEidasData;
import at.asitplus.eidas.specific.modules.auth.eidas.v2.exception.EidPostProcessingException;
import at.asitplus.eidas.specific.modules.auth.eidas.v2.exception.EidPreProcessingException;
import at.asitplus.eidas.specific.modules.auth.eidas.v2.exception.EidasAttributeException;
import at.asitplus.eidas.specific.modules.auth.eidas.v2.exception.EidasSAuthenticationException;
import at.asitplus.eidas.specific.modules.auth.eidas.v2.exception.WorkflowException;
import at.asitplus.eidas.specific.modules.auth.eidas.v2.handler.CountrySpecificDetailSearchProcessor;
import at.asitplus.eidas.specific.modules.auth.eidas.v2.handler.GenericEidProcessor;
import at.asitplus.eidas.specific.modules.auth.eidas.v2.service.ICcSpecificEidProcessingService;
import at.asitplus.eidas.specific.modules.auth.eidas.v2.service.RegisterSearchService;
import at.asitplus.eidas.specific.modules.auth.eidas.v2.service.RegisterSearchService.RegisterStatusResults;
import at.asitplus.eidas.specific.modules.auth.eidas.v2.tasks.InitialSearchTask;
import at.asitplus.eidas.specific.modules.auth.eidas.v2.test.clients.ErnpRestClientTest;
import at.asitplus.eidas.specific.modules.auth.eidas.v2.test.clients.ZmrClientTest;
import at.asitplus.eidas.specific.modules.auth.eidas.v2.utils.MatchingTaskUtils;
import at.asitplus.eidas.specific.modules.core.eidas.EidasConstants;
import at.gv.bmi.namespace.zmr_su.base._20040201.RequestType;
import at.gv.bmi.namespace.zmr_su.base._20040201.ResponseType;
import at.gv.bmi.namespace.zmr_su.base._20040201_.ServicePort;
import at.gv.egiz.eaaf.core.api.IRequest;
import at.gv.egiz.eaaf.core.api.idp.process.ExecutionContext;
import at.gv.egiz.eaaf.core.exceptions.EaafStorageException;
import at.gv.egiz.eaaf.core.exceptions.TaskExecutionException;
import at.gv.egiz.eaaf.core.impl.idp.auth.data.AuthProcessDataWrapper;
import at.gv.egiz.eaaf.core.impl.idp.module.test.TestRequestImpl;
import at.gv.egiz.eaaf.core.impl.idp.process.ExecutionContextImpl;
import eu.eidas.auth.commons.attribute.AttributeDefinition;
import eu.eidas.auth.commons.attribute.ImmutableAttributeMap;
import eu.eidas.auth.commons.attribute.PersonType;
import eu.eidas.auth.commons.light.impl.LightRequest;
import eu.eidas.auth.commons.protocol.impl.AuthenticationResponse;
import lombok.SneakyThrows;
import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {
    "/SpringTest-context_tasks_test.xml",
    "/SpringTest-context_basic_mapConfig.xml",
    "/SpringTest-context_ccSearchProcessor_test.xml"
})
@DirtiesContext(classMode = ClassMode.BEFORE_CLASS)
public class InitialSearchTaskWithRegistersTest {

  private static final String EE = "EE";
  private static final String DE = "DE";

  @Rule
  public SoapServiceRule soap = SoapServiceRule.newInstance();

  @Autowired IErnpClient ernpClient;   
  @Autowired IZmrClient zmrClient;
  @Autowired List<CountrySpecificDetailSearchProcessor> handlers;
  
  private RegisterSearchService registerSearchService;

  private ServicePort zmrMock = null;

  private static MockWebServer mockWebServer;
  
  private final ICcSpecificEidProcessingService eidPostProcessor = createEidPostProcessor();
  private InitialSearchTask task;

  final ExecutionContext executionContext = new ExecutionContextImpl();
  private TestRequestImpl pendingReq;
  private static JAXBContext jaxbContext;

  /**
   * Initialize jUnit class.
   */
  @BeforeClass
  @SneakyThrows
  public static void classInitializer() {
    jaxbContext = JAXBContext.newInstance(
        at.gv.bmi.namespace.zmr_su.zmr._20040201.ObjectFactory.class,
        at.gv.bmi.namespace.zmr_su.gis._20070725.ObjectFactory.class,
        at.gv.bmi.namespace.zmr_su.base._20040201.ObjectFactory.class);
    
    mockWebServer = new MockWebServer();
    mockWebServer.start(1718);
    
  }

  @AfterClass
  @SneakyThrows
  public static void resetTestEnviroment() {
    mockWebServer.shutdown();

  }

  /**
   * jUnit test set-up.
   */
  @Before
  @SneakyThrows
  public void setUp() throws URISyntaxException, EaafStorageException {
    if (zmrMock == null) {
      zmrMock = soap.mock(ServicePort.class, "http://localhost:1234/demozmr");

    }

    registerSearchService = new RegisterSearchService(handlers, zmrClient, ernpClient);
    task = new InitialSearchTask(registerSearchService, eidPostProcessor);

    MockHttpServletRequest httpReq = new MockHttpServletRequest("POST", "https://localhost/authhandler");
    MockHttpServletResponse httpResp = new MockHttpServletResponse();
    RequestContextHolder.resetRequestAttributes();
    RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(httpReq, httpResp));

    pendingReq = new TestRequestImpl();
    
  }

  /**
   * One match, but register update needed
   * <p>
   * <b>Check if ZMR update request is NOT executed in case of MDS change!</b>
   * </p>
   */
  @Test
  @DirtiesContext
  public void singlePersonalIdMatchUpdateNecessary_ZmrNotDone() throws Exception {

    String oldGivenName = "XXXClaus - Maria";

    //inject eIDAS data
    pendingReq.getSessionData(AuthProcessDataWrapper.class).setGenericDataToSession(
        Constants.DATA_FULL_EIDAS_RESPONSE,
        buildDummyAuthResponse("XXXKlaus - Maria", "XXXvon Brandenburg",
            "DE/AT/7cEYWithDEElementsasdfsafsaf4CDVzNT4E7cjkU4VqForjUnit", "1994-12-31"));

    final ArgumentCaptor<RequestType> zmrReq = ArgumentCaptor.forClass(RequestType.class);

    // inject response
    when(zmrMock.service(zmrReq.capture(), any()))
        .thenReturn(loadResponseFromFile("/data/zmr/seq_1-8_search_with_personalId_only_resp.xml"))
        
        //perform prepair-update request  
        .thenReturn(loadResponseFromFile("/data/zmr/seq_1-8_search_with_personalId_only_resp.xml"))         

        //do not make an update because, MDS update is not allowed and no other data has been changed
        .thenThrow(new RuntimeException("This request is not needed any more"));                       

    mockWebServer.enqueue(new MockResponse().setResponseCode(200)
        .setBody("{}")
        .setHeader("Content-Type", "application/json;charset=utf-8"));
    

    // execute test
    task.execute(pendingReq, executionContext);

    // validate state
    //INFO: has to be the old givenName because ZMR allows no update of MDS information
    checkMatchingSuccessState(pendingReq, "UgeknNsc26lVuB7U/uYGVmWtnnA=", "XXXvon Brandenburg",
        oldGivenName, "1994-12-31", DE);

    // validate request
    assertEquals("wrong number of req.", 2, zmrReq.getAllValues().size());
    assertNotNull("Personensuche req.", zmrReq.getValue().getPersonSuchenRequest());
    checkBasicRequestParameters(zmrReq.getValue(), ZmrClientTest.PROCESS_TASK_SEARCH, 
        new BigInteger("367100000000079"), "jUnit123456");

  }

  /**
   * One match, but register update needed
   * <p>
   * <b>Check if ZMR update request is executed in case of other data than MDS change!</b>
   * </p>
   */
  @Test
  @DirtiesContext
  public void singlePersonalIdMatchUpdateNecessary_ZmrDone() throws Exception {

    String oldGivenName = "XXXClaus - Maria";
    String placeOfBirth = RandomStringUtils.randomAlphabetic(5);
    
    //inject eIDAS data
    pendingReq.getSessionData(AuthProcessDataWrapper.class).setGenericDataToSession(
        Constants.DATA_FULL_EIDAS_RESPONSE,
        buildDummyAuthResponse(oldGivenName, "XXXvon Brandenburg",
            "DE/AT/7cEYWithDEElementsasdfsafsaf4CDVzNT4E7cjkU4VqForjUnit", "1994-12-31", null, placeOfBirth, null));

    final ArgumentCaptor<RequestType> zmrReq = ArgumentCaptor.forClass(RequestType.class);

    // inject response
    when(zmrMock.service(zmrReq.capture(), any()))
        .thenReturn(loadResponseFromFile("/data/zmr/seq_1-8_search_with_personalId_only_resp_no_additional_attributes.xml"))
        
        //perform prepair-update request  
        .thenReturn(loadResponseFromFile("/data/zmr/seq_1-8_search_with_personalId_only_resp_no_additional_attributes.xml"))         

        //do make an update because, MDS DOES NOT change, but additional attribute was available
        .thenReturn(loadResponseFromFile("/data/zmr/seq_3-6_kitt_update_resp.xml"));    

    mockWebServer.enqueue(new MockResponse().setResponseCode(200)
        .setBody("{}")
        .setHeader("Content-Type", "application/json;charset=utf-8"));

    // execute test
    task.execute(pendingReq, executionContext);

    // validate state
    //INFO: has to be the old givenName because ZMR allows no update of MDS information
    checkMatchingSuccessState(pendingReq, "UgeknNsc26lVuB7U/uYGVmWtnnA=", "XXXvon Brandenburg",
        oldGivenName, "1994-12-31", DE);

    // validate request
    assertEquals("wrong number of req.", 3, zmrReq.getAllValues().size());
    assertNotNull("Personensuche req.", zmrReq.getAllValues().get(0).getPersonSuchenRequest());
    checkBasicRequestParameters(zmrReq.getAllValues().get(0), ZmrClientTest.PROCESS_TASK_SEARCH, null, "jUnit123456");

    assertNotNull("Personenupdate req.", zmrReq.getAllValues().get(2).getPersonAendernRequest());
    checkBasicRequestParameters(zmrReq.getAllValues().get(2), ZmrClientTest.PROCESS_TASK_UPDATE, 
        new BigInteger("367100000000079"), "jUnit123456");
    assertEquals("eIDAS attribute to add", 4, 
       zmrReq.getAllValues().get(2).getPersonAendernRequest().getEidasIdentitaetAnlage().size());       
    assertNull("ZMR update MDS", zmrReq.getAllValues().get(2).getPersonAendernRequest().getPersonAenderung());
        
  }
  
  
  /**
   * Two matches by PersonalId found in ZMR
   *
   * @throws EidasSAuthenticationException
   */
  @Test
  @DirtiesContext
  @SneakyThrows
  public void multiPersonalIdMatch_Zmr() throws EidasSAuthenticationException {
    //inject eIDAS data
    pendingReq.getSessionData(AuthProcessDataWrapper.class).setGenericDataToSession(
        Constants.DATA_FULL_EIDAS_RESPONSE,
        buildDummyAuthResponse("XXXKlaus - Maria", "XXXvon Brandenburg",
            "DE/AT/7cEYWithDEElementsasdfsafsaf4CDVzNT4E7cjkU4VqForjUnit", "1994-12-31"));

    // inject response
    when(zmrMock.service(any(), any()))
        .thenReturn(loadResponseFromFile("/data/zmr/search_with_personalId_only_resp_moreThanOne.xml"))
        .thenThrow(new RuntimeException("This request is not needed any more"));

    // execute task
    TaskExecutionException exception = assertThrows(TaskExecutionException.class,
        () -> task.execute(pendingReq, executionContext));

    // validate state
    assertTrue("Wrong exception", (exception.getOriginalException() instanceof WorkflowException));
    assertTrue("Wrong flag 'manualFixNeeded'",
        ((WorkflowException) exception.getOriginalException()).isRequiresManualFix());

  }

  /**
   * Find single person in ZMR by country specifics.
   */
  @Test
  @DirtiesContext
  public void singlePersonFindWithCountySpecifics_Ernp() throws Exception {
    //inject eIDAS data
    pendingReq.getSessionData(AuthProcessDataWrapper.class).setGenericDataToSession(
        Constants.DATA_FULL_EIDAS_RESPONSE,
        buildDummyAuthResponse("vdqZZIaA", "mRjMKAQc",
            "DE/AT/nj1m79jm9z", "1996-01-01",
            null, "VRNCAylF", "miEklFHC"));

    final ArgumentCaptor<RequestType> zmrReq = ArgumentCaptor.forClass(RequestType.class);
    BigInteger processId = new BigInteger("367100000000079");

    // inject response
    when(zmrMock.service(zmrReq.capture(), any()))
        .thenReturn(loadResponseFromFile("/data/zmr/empty_zmr_result.xml"))   //personalId search
        .thenReturn(loadResponseFromFile("/data/zmr/empty_zmr_result.xml"))  //CC specific search
        .thenThrow(new RuntimeException("This request is not needed any more"));

    mockWebServer.enqueue(new MockResponse().setResponseCode(200)         //personalId search
        .setBody("{}")                                                    
        .setHeader("Content-Type", "application/json;charset=utf-8"));
    mockWebServer.enqueue(new MockResponse().setResponseCode(200)         //CC specific search  
        .setBody(IOUtils.toString(
            ErnpRestClientTest.class.getResourceAsStream("/data/ernp/2_search_with_cc_specific_resp.json"), "UTF-8"))
        .setHeader("Content-Type", "application/json;charset=utf-8"));    
    mockWebServer.enqueue(new MockResponse().setResponseCode(200)         //KITT search  
        .setBody(IOUtils.toString(
            ErnpRestClientTest.class.getResourceAsStream("/data/ernp/2_kitt_search_latest_resp.json"), "UTF-8"))
        .setHeader("Content-Type", "application/json;charset=utf-8"));
    mockWebServer.enqueue(new MockResponse().setResponseCode(200)         //KITT update  
        .setBody(IOUtils.toString(
            ErnpRestClientTest.class.getResourceAsStream("/data/ernp/2_kitt_update_resp.json"), "UTF-8"))
        .setHeader("Content-Type", "application/json;charset=utf-8"));
        
    // execute test
    task.execute(pendingReq, executionContext);

    // validate state
    checkMatchingSuccessState(pendingReq, "TBGoMlirU881e2jMGETa9WLx1+A=", "mRjMKAQc",
        "vdqZZIaA", "1996-01-01", DE);

    // validate request
    assertEquals("wrong number of req.", 2, zmrReq.getAllValues().size());
    checkBasicRequestParameters(zmrReq.getAllValues().get(0), ZmrClientTest.PROCESS_TASK_SEARCH, null, "jUnit123456");
    checkBasicRequestParameters(zmrReq.getAllValues().get(1), ZmrClientTest.PROCESS_TASK_SEARCH, processId, "jUnit123456");

  }
  

  /**
   * Find single person in ZMR by country specifics.
   */
  @Test
  @DirtiesContext
  public void singlePersonFindWithCountySpecifics_Zmr() throws Exception {
    //inject eIDAS data
    pendingReq.getSessionData(AuthProcessDataWrapper.class).setGenericDataToSession(
        Constants.DATA_FULL_EIDAS_RESPONSE,
        buildDummyAuthResponse("XXXClaus - Maria", "XXXvon Brandenburg",
            "DE/AT/7cEYWithDEElementsasdfsafsaf4CDVzNT4E7cjkU4VqForjUnit_with_New_ID", "1994-12-31",
            null, "Hintergigritzpotschn", "XXXvon Heuburg"));

    final ArgumentCaptor<RequestType> zmrReq = ArgumentCaptor.forClass(RequestType.class);
    BigInteger processId = new BigInteger("367100000000079");

    // inject response
    when(zmrMock.service(zmrReq.capture(), any()))
        .thenReturn(loadResponseFromFile("/data/zmr/empty_zmr_result.xml"))   //personalId search
        .thenReturn(loadResponseFromFile("/data/zmr/seq_1-8_search_with_personalId_only_resp.xml"))  //CC specific search
        .thenReturn(loadResponseFromFile("/data/zmr/seq_1-4_kitt_get_latest_version_resp.xml"))  //KITT latest version
        .thenReturn(loadResponseFromFile("/data/zmr/seq_1-6_kitt_update_resp.xml"))  //KITT update
        .thenThrow(new RuntimeException("This request is not needed any more"));

    mockWebServer.enqueue(new MockResponse().setResponseCode(200)
        .setBody("{}")
        .setHeader("Content-Type", "application/json;charset=utf-8"));
    
    mockWebServer.enqueue(new MockResponse().setResponseCode(200)         //CC specific search  
        .setBody("{}")
        .setHeader("Content-Type", "application/json;charset=utf-8"));
    
    
    // execute test
    task.execute(pendingReq, executionContext);

    // validate state
    checkMatchingSuccessState(pendingReq, "UgeknNsc26lVuB7U/uYGVmWtnnA=", "XXXvon Brandenburg",
        "XXXClaus - Maria", "1994-12-31", DE);

    // validate request
    assertEquals("wrong number of req.", 4, zmrReq.getAllValues().size());
    checkBasicRequestParameters(zmrReq.getAllValues().get(0), ZmrClientTest.PROCESS_TASK_SEARCH, null, "jUnit123456");
    checkBasicRequestParameters(zmrReq.getAllValues().get(1), ZmrClientTest.PROCESS_TASK_SEARCH, processId, "jUnit123456");
    checkBasicRequestParameters(zmrReq.getAllValues().get(2), ZmrClientTest.PROCESS_TASK_SEARCH, processId, "jUnit123456");
    checkBasicRequestParameters(zmrReq.getAllValues().get(3), ZmrClientTest.PROCESS_TASK_UPDATE, processId, "jUnit123456");

  }

  /**
   * Find one match with MDS search in ZMR.
   */
  @Test
  @DirtiesContext
  @SneakyThrows
  public void resultByMdsSearch_Zmr() throws TaskExecutionException, EidasSAuthenticationException {
    //inject eIDAS data
    pendingReq.getSessionData(AuthProcessDataWrapper.class).setGenericDataToSession(
        Constants.DATA_FULL_EIDAS_RESPONSE,
        buildDummyAuthResponse("XXXClaus - Maria", "XXXvon Brandenburg",
            "DE/AT/7cEYWithDEElementsasdfsafsaf4CDVzNT4E7cjkU4VqForjUnit_with_New_ID", "1994-12-31"));

    final ArgumentCaptor<RequestType> zmrReq = ArgumentCaptor.forClass(RequestType.class);
    BigInteger processId = new BigInteger("367100000000079");

    // inject response
    when(zmrMock.service(zmrReq.capture(), any()))
        .thenReturn(loadResponseFromFile("/data/zmr/empty_zmr_result.xml"))   //personalId search
        //CC-specific will be ignored because CC is DE but BirthName and PlaceOfBirth is 'null'
        .thenReturn(loadResponseFromFile("/data/zmr/seq_1-2_search_with_mds_resp.xml"))  //MDS specific search
        .thenThrow(new RuntimeException("This request is not needed any more"));
    
    mockWebServer.enqueue(new MockResponse().setResponseCode(200)
        .setBody("{}")
        .setHeader("Content-Type", "application/json;charset=utf-8"));
    mockWebServer.enqueue(new MockResponse().setResponseCode(200)         //MDS specific search
        .setBody("{}")
        .setHeader("Content-Type", "application/json;charset=utf-8"));

    // execute test
    task.execute(pendingReq, executionContext);

    // validate state
    checkIntermediateResult(1);

    // validate request
    assertEquals("wrong number of req.", 2, zmrReq.getAllValues().size());
    checkBasicRequestParameters(zmrReq.getAllValues().get(0), ZmrClientTest.PROCESS_TASK_SEARCH, null, "jUnit123456");
    checkBasicRequestParameters(zmrReq.getAllValues().get(1), ZmrClientTest.PROCESS_TASK_SEARCH, processId, "jUnit123456");

  }

  /**
   * Find one match with MDS search in ZMR.
   */
  @Test
  @DirtiesContext
  @SneakyThrows
  public void resultByMdsSearch_Zmr_Second() throws TaskExecutionException, EidasSAuthenticationException {
    //inject eIDAS data
    pendingReq.getSessionData(AuthProcessDataWrapper.class).setGenericDataToSession(
        Constants.DATA_FULL_EIDAS_RESPONSE,
        buildDummyAuthResponse("XXXClaus - Maria", "XXXvon Brandenburg",
            "DE/AT/7cEYWithDEElementsasdfsafsaf4CDVzNT4E7cjkU4VqForjUnit_with_New_ID", "1994-12-31",
            null, "Hintergigritzpotschn", "XXXvon Heuburg"));

    final ArgumentCaptor<RequestType> zmrReq = ArgumentCaptor.forClass(RequestType.class);
    BigInteger processId = new BigInteger("367100000000079");

    // inject response
    when(zmrMock.service(zmrReq.capture(), any()))
        .thenReturn(loadResponseFromFile("/data/zmr/empty_zmr_result.xml"))   //personalId search
        .thenReturn(loadResponseFromFile("/data/zmr/empty_zmr_result.xml"))   //CC-specific search
        .thenReturn(loadResponseFromFile("/data/zmr/search_with_personalId_only_resp_moreThanOne.xml"))  //MDS specific search
        .thenThrow(new RuntimeException("This request is not needed any more"));


    mockWebServer.enqueue(new MockResponse().setResponseCode(200)
        .setBody("{}")
        .setHeader("Content-Type", "application/json;charset=utf-8"));
    mockWebServer.enqueue(new MockResponse().setResponseCode(200)         //CC specific search  
        .setBody("{}")
        .setHeader("Content-Type", "application/json;charset=utf-8"));
    mockWebServer.enqueue(new MockResponse().setResponseCode(200)         //MDS specific search
        .setBody(IOUtils.toString(
            ErnpRestClientTest.class.getResourceAsStream("/data/ernp/3_search_with_mds_resp.json"), "UTF-8"))
        .setHeader("Content-Type", "application/json;charset=utf-8"));
    
    
    // execute test
    task.execute(pendingReq, executionContext);

    // validate state
    checkIntermediateResult(3);

    // validate request
    assertEquals("wrong number of req.", 3, zmrReq.getAllValues().size());
    checkBasicRequestParameters(zmrReq.getAllValues().get(0), ZmrClientTest.PROCESS_TASK_SEARCH, null, "jUnit123456");
    checkBasicRequestParameters(zmrReq.getAllValues().get(1), ZmrClientTest.PROCESS_TASK_SEARCH, processId, "jUnit123456");
    checkBasicRequestParameters(zmrReq.getAllValues().get(2), ZmrClientTest.PROCESS_TASK_SEARCH, processId, "jUnit123456");

  }



  @NotNull
  private ICcSpecificEidProcessingService createEidPostProcessor() {
    return new ICcSpecificEidProcessingService() {

      private final GenericEidProcessor genericEidProcessor = new GenericEidProcessor();

      @Override
      public SimpleEidasData postProcess(Map<String, Object> eidasAttrMap) throws EidPostProcessingException, EidasAttributeException {
        return genericEidProcessor.postProcess(eidasAttrMap);
      }

      @Override
      public void preProcess(String selectedCC, IRequest pendingReq, LightRequest.Builder authnRequestBuilder) 
          throws EidPreProcessingException {
        genericEidProcessor.preProcess(pendingReq, authnRequestBuilder, selectedCC);
      }
    };
  }

  @NotNull
  private ZmrRegisterResult zmrRegisterResult(RegisterResult registerResult, BigInteger processId) {
    return new ZmrRegisterResult(Collections.singletonList(registerResult), processId);
  }

  @NotNull
  private ZmrRegisterResult zmrRegisterResult(RegisterResult registerResult) {
    return zmrRegisterResult(registerResult, generateRandomProcessId());
  }


  private BigInteger generateRandomProcessId() {
    return new BigInteger(RandomStringUtils.randomNumeric(10));

  }

  private void checkMatchingSuccessState(IRequest pendingReq, String bpk, String familyName, String givenName,
                                         String birhday, String countryCode) {
    assertNull("Find intermediate matching data but matching should be finished",
        MatchingTaskUtils.getIntermediateMatchingResult(pendingReq));
    assertNotNull("find no eIDAS inbut data", MatchingTaskUtils.getInitialEidasData(pendingReq));

    MatchedPersonResult personInfo = MatchingTaskUtils.getFinalMatchingResult(pendingReq);
    assertNotNull("no final matching result", personInfo);
    assertEquals("wrong bpk", bpk, personInfo.getBpk());
    assertEquals("wrong givenName", givenName, personInfo.getGivenName());
    assertEquals("wrong familyName", familyName, personInfo.getFamilyName());
    assertEquals("wrong dateOfBirth", birhday, personInfo.getDateOfBirth());
    assertEquals("wrong countryCode", countryCode, personInfo.getCountryCode());

  }

  private void checkIntermediateResult(int resultSize) {
    Boolean transitionGUI = (Boolean) executionContext.get(Constants.TRANSITION_TO_GENERATE_OTHER_LOGIN_METHOD_GUI_TASK);
    Assert.assertTrue("Wrong transition", transitionGUI);
    Boolean transitionErnb = (Boolean) executionContext.get(Constants.TRANSITION_TO_CREATE_NEW_ERNP_ENTRY_TASK);
    Assert.assertNull("Wrong transition", transitionErnb);

    assertNotNull("find no eIDAS inbut data", MatchingTaskUtils.getInitialEidasData(pendingReq));
    assertNull("Find final matching data but no match sould be found",
        MatchingTaskUtils.getFinalMatchingResult(pendingReq));

    RegisterStatusResults result = MatchingTaskUtils.getIntermediateMatchingResult(pendingReq);
    assertNotNull("Find no intermediate matching data", result);
    assertEquals("wrong intermediate result size", resultSize, result.getResultCount());

  }

  @NotNull
  private AuthenticationResponse buildDummyAuthResponse(String givenName, String familyName, String identifier,
                                                        String dateOfBirth) throws URISyntaxException {
    return buildDummyAuthResponse(givenName, familyName, identifier, dateOfBirth, null, null, null);
  }

  @NotNull
  private AuthenticationResponse buildDummyAuthResponseDE(String givenName, String familyName, String identifier,
                                                          String dateOfBirth, String placeOfBirth,
                                                          String birthName) throws URISyntaxException {
    return buildDummyAuthResponse(givenName, familyName, identifier, dateOfBirth, null, placeOfBirth, birthName);
  }

  @NotNull
  private AuthenticationResponse buildDummyAuthResponse(String givenName, String familyName, String identifier,
                                                        String dateOfBirth, String taxNumber, String placeOfBirth,
                                                        String birthName) throws URISyntaxException {
    ImmutableAttributeMap.Builder builder = ImmutableAttributeMap.builder()
        .put(generateStringAttribute(EidasConstants.eIDAS_ATTR_PERSONALIDENTIFIER,
            randomAlphabetic(2), randomAlphabetic(2)), identifier)
        .put(generateStringAttribute(EidasConstants.eIDAS_ATTR_CURRENTFAMILYNAME,
            randomAlphabetic(3), randomAlphabetic(3)), familyName)
        .put(generateStringAttribute(EidasConstants.eIDAS_ATTR_CURRENTGIVENNAME,
            randomAlphabetic(4), randomAlphabetic(4)), givenName)
        .put(generateDateTimeAttribute(EidasConstants.eIDAS_ATTR_DATEOFBIRTH,
            randomAlphabetic(5), randomAlphabetic(5)), dateOfBirth);
    if (taxNumber != null) {
      builder.put(generateStringAttribute(EidasConstants.eIDAS_ATTR_TAXREFERENCE,
          randomAlphabetic(6), randomAlphabetic(6)), taxNumber);
    }
    if (birthName != null) {
      builder.put(generateStringAttribute(EidasConstants.eIDAS_ATTR_BIRTHNAME,
          randomAlphabetic(7), randomAlphabetic(7)), birthName);
    }
    if (placeOfBirth != null) {
      builder.put(generateStringAttribute(EidasConstants.eIDAS_ATTR_PLACEOFBIRTH,
          randomAlphabetic(8), randomAlphabetic(8)), placeOfBirth);
    }
    final ImmutableAttributeMap attributeMap = builder.build();

    return new AuthenticationResponse.Builder().id(randomAlphabetic(5))
        .issuer(randomAlphabetic(5)).subject(randomAlphabetic(5)).statusCode("200")
        .inResponseTo(randomAlphabetic(5)).subjectNameIdFormat(randomAlphabetic(5))
        .attributes(attributeMap).build();
  }

  private AttributeDefinition<Object> generateStringAttribute(String friendlyName, String fragment, String prefix)
      throws URISyntaxException {
    return generateAttribute(friendlyName, fragment, prefix, "eu.eidas.auth.commons.attribute.impl" +
        ".LiteralStringAttributeValueMarshaller");
  }

  @SuppressWarnings("SameParameterValue")
  private AttributeDefinition<Object> generateDateTimeAttribute(String friendlyName, String fragment, String prefix)
      throws URISyntaxException {
    return generateAttribute(friendlyName, fragment, prefix, "eu.eidas.auth.commons.attribute.impl" +
        ".DateTimeAttributeValueMarshaller");
  }

  private AttributeDefinition<Object> generateAttribute(String friendlyName, String fragment, String prefix,
                                                        String marshaller) throws URISyntaxException {
    return AttributeDefinition.builder()
        .friendlyName(friendlyName).nameUri(new URI("ad", "sd", fragment))
        .personType(PersonType.LEGAL_PERSON).xmlType(new QName("http://saf", "as", prefix))
        .attributeValueMarshaller(marshaller).build();
  }

  private ResponseType loadResponseFromFile(String filepath) throws JAXBException {
    final Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
    JAXBElement<?> resp = (JAXBElement<?>) unmarshaller.unmarshal(ZmrClientTest.class.getResourceAsStream(
        filepath));
    return (ResponseType) resp.getValue();

  }

  private void checkBasicRequestParameters(RequestType requestType, String vorgangName, BigInteger processId,
      String behoerdennummer) {
    assertNotNull("no workflow infos", requestType.getWorkflowInfoClient());
    assertEquals("processName",  ZmrClientTest.PROCESS_GENERAL, requestType.getWorkflowInfoClient().getProzessName());
    assertEquals("vorgangsName", vorgangName, requestType.getWorkflowInfoClient().getVorgangName());

    if (processId != null) {
      assertEquals("processId", processId, requestType.getWorkflowInfoClient().getProzessInstanzID());
    } else {
      assertNull("processId", requestType.getWorkflowInfoClient().getProzessInstanzID());
    }

    assertNotNull("no client infos", requestType.getClientInfo());
    assertEquals("behoerdennummer", behoerdennummer, requestType.getClientInfo().getOrganisation()
        .getBehoerdenNr());
  }
}