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

import static at.asitplus.eidas.specific.connector.MsEidasNodeConstants.PROP_CONFIG_SP_NEW_EID_MODE;

import java.net.URISyntaxException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

import org.apache.commons.lang3.RandomStringUtils;
import org.jetbrains.annotations.NotNull;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
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.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import at.asitplus.eidas.specific.connector.MsEidasNodeConstants;
import at.asitplus.eidas.specific.connector.test.config.dummy.MsConnectorDummyConfigMap;
import at.asitplus.eidas.specific.connector.test.config.dummy.MsConnectorDummySpConfiguration;
import at.asitplus.eidas.specific.modules.auth.eidas.v2.Constants;
import at.asitplus.eidas.specific.modules.auth.eidas.v2.service.EidasAttributeRegistry;
import at.asitplus.eidas.specific.modules.auth.eidas.v2.tasks.CreateIdentityLinkTask;
import at.asitplus.eidas.specific.modules.auth.eidas.v2.tasks.ReceiveAuthnResponseTask;
import at.gv.egiz.eaaf.core.api.IRequest;
import at.gv.egiz.eaaf.core.api.IRequestStorage;
import at.gv.egiz.eaaf.core.api.data.EaafConfigConstants;
import at.gv.egiz.eaaf.core.api.data.EaafConstants;
import at.gv.egiz.eaaf.core.api.idp.process.ExecutionContext;
import at.gv.egiz.eaaf.core.exceptions.EaafException;
import at.gv.egiz.eaaf.core.exceptions.EaafStorageException;
import at.gv.egiz.eaaf.core.exceptions.PendingReqIdValidationException;
import at.gv.egiz.eaaf.core.exceptions.TaskExecutionException;
import at.gv.egiz.eaaf.core.impl.idp.auth.data.EidAuthProcessDataWrapper;
import at.gv.egiz.eaaf.core.impl.idp.module.test.TestRequestImpl;
import at.gv.egiz.eaaf.core.impl.idp.process.ExecutionContextImpl;
import at.gv.egiz.eaaf.core.impl.utils.Random;
import eu.eidas.auth.commons.attribute.AttributeDefinition;
import eu.eidas.auth.commons.attribute.ImmutableAttributeMap;
import eu.eidas.auth.commons.protocol.impl.AuthenticationResponse;
import lombok.val;

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

  @Autowired(required = true)
  private ReceiveAuthnResponseTask task;

  @Autowired(required = true)
  private MsConnectorDummyConfigMap basicConfig;
  @Autowired
  protected EidasAttributeRegistry attrRegistry;
  
  @Autowired private IRequestStorage storage;
  
  final ExecutionContext executionContext = new ExecutionContextImpl();
  private MockHttpServletRequest httpReq;
  private MockHttpServletResponse httpResp;
  private TestRequestImpl pendingReq;
  private MsConnectorDummySpConfiguration oaParam;
  
  /**
   * jUnit test set-up.
   */
  @Before
  public void setUp() throws EaafStorageException, URISyntaxException {

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

    basicConfig.putConfigValue("eidas.ms.auth.eIDAS.szrclient.debug.useDummySolution", "false");
    basicConfig.putConfigValue("eidas.ms.auth.eIDAS.eid.testidentity.default", "false");
    
    final Map<String, String> spConfig = new HashMap<>();
    spConfig.put(EaafConfigConstants.SERVICE_UNIQUEIDENTIFIER, "testSp");
    spConfig.put("target", "urn:publicid:gv.at:cdid+XX");
    spConfig.put(PROP_CONFIG_SP_NEW_EID_MODE, "true");
    oaParam = new MsConnectorDummySpConfiguration(spConfig, basicConfig);
    oaParam.setLoa(Arrays.asList(EaafConstants.EIDAS_LOA_HIGH));
    pendingReq = new TestRequestImpl();

    pendingReq.setSpConfig(oaParam);
    pendingReq.setPendingReqId(at.gv.egiz.eaaf.core.impl.utils.Random.nextProcessReferenceValue());
    pendingReq.setAuthUrl("http://test.com/");
    pendingReq.setTransactionId("avaasbav");
    pendingReq.setPiiTransactionId(RandomStringUtils.randomAlphanumeric(10));
        
    executionContext.put(MsEidasNodeConstants.REQ_PARAM_SELECTED_COUNTRY, "LU");
    executionContext.put(EaafConstants.PROCESS_ENGINE_REQUIRES_NO_POSTAUTH_REDIRECT, true);

  }
  
  @Test
  public void missingEidasResponse() {    
    try {
      task.execute(pendingReq, executionContext);
      Assert.fail("No eIDAS response not detected");
      
    } catch (TaskExecutionException e) {
      Assert.assertEquals("ErrorId", "eidas.01", 
          ((EaafException) e.getOriginalException()).getErrorId());
      
    }        
  }
  
  @Test
  public void notSuccessEidasResponse() throws URISyntaxException {    
    String statusCode = RandomStringUtils.randomAlphabetic(10);
    httpReq.setAttribute(Constants.DATA_FULL_EIDAS_RESPONSE, 
        buildDummyAuthResponse(statusCode));
    
    
    try {
      task.execute(pendingReq, executionContext);
      Assert.fail("No eIDAS response not detected");
      
    } catch (TaskExecutionException e) {
      Assert.assertEquals("ErrorId", "eidas.02", 
          ((EaafException) e.getOriginalException()).getErrorId());
      Assert.assertEquals("wrong parameter size", 2, ((EaafException) e.getOriginalException())
          .getParams().length);
      Assert.assertEquals("wrong errorMsg", statusCode, ((EaafException) e
          .getOriginalException()).getParams()[0]);

    }        
  }
    
  @Test
  public void success() throws URISyntaxException, TaskExecutionException, PendingReqIdValidationException {    
    @NotNull
    AuthenticationResponse eidasResponse = buildDummyAuthResponse(Constants.SUCCESS_URI);
    httpReq.setAttribute(Constants.DATA_FULL_EIDAS_RESPONSE, eidasResponse);
    executionContext.put(MsEidasNodeConstants.REQ_PARAM_SELECTED_COUNTRY, "LU");    
      
    //execute test
    task.execute(pendingReq, executionContext);
    
    //validate state
    IRequest storedReq = storage.getPendingRequest(pendingReq.getPendingRequestId());
    Assert.assertNotNull("pendingReq not stored", storedReq);
    
    final EidAuthProcessDataWrapper authProcessData = storedReq.getSessionData(EidAuthProcessDataWrapper.class);
    Assert.assertEquals("LoA", eidasResponse.getLevelOfAssurance(), authProcessData.getQaaLevel());
    Assert.assertNotNull("eIDAS response", 
        authProcessData.getGenericDataFromSession(Constants.DATA_FULL_EIDAS_RESPONSE));
    Assert.assertEquals("eIDAS response", eidasResponse, 
        authProcessData.getGenericDataFromSession(Constants.DATA_FULL_EIDAS_RESPONSE));
    Assert.assertFalse("testIdentity flag", authProcessData.isTestIdentity());
        
  }
  
  @Test
  public void successWithTestIdentity() throws URISyntaxException, TaskExecutionException, PendingReqIdValidationException {    
    basicConfig.putConfigValue("eidas.ms.auth.eIDAS.eid.testidentity.default", "true");
    
    @NotNull        
    AuthenticationResponse eidasResponse = buildDummyAuthResponse(Constants.SUCCESS_URI);
    httpReq.setAttribute(Constants.DATA_FULL_EIDAS_RESPONSE, eidasResponse);
    executionContext.put(MsEidasNodeConstants.REQ_PARAM_SELECTED_COUNTRY, "LU");    
      
    //execute test
    task.execute(pendingReq, executionContext);
    
    //validate state
    IRequest storedReq = storage.getPendingRequest(pendingReq.getPendingRequestId());
    Assert.assertNotNull("pendingReq not stored", storedReq);
    
    final EidAuthProcessDataWrapper authProcessData = storedReq.getSessionData(EidAuthProcessDataWrapper.class);
    Assert.assertEquals("LoA", eidasResponse.getLevelOfAssurance(), authProcessData.getQaaLevel());
    Assert.assertNotNull("eIDAS response", 
        authProcessData.getGenericDataFromSession(Constants.DATA_FULL_EIDAS_RESPONSE));
    Assert.assertEquals("eIDAS response", eidasResponse, 
        authProcessData.getGenericDataFromSession(Constants.DATA_FULL_EIDAS_RESPONSE));
    Assert.assertTrue("testIdentity flag", authProcessData.isTestIdentity());
        
  }
  
  
  
  @NotNull
  private AuthenticationResponse buildDummyAuthResponse(String statusCode) throws URISyntaxException {
    final AttributeDefinition attributeDef = attrRegistry.getCoreAttributeRegistry().getByFriendlyName(
        Constants.eIDAS_ATTR_PERSONALIDENTIFIER).first();
    final AttributeDefinition attributeDef2 = attrRegistry.getCoreAttributeRegistry().getByFriendlyName(
        Constants.eIDAS_ATTR_CURRENTFAMILYNAME).first();
    final AttributeDefinition attributeDef3 = attrRegistry.getCoreAttributeRegistry().getByFriendlyName(
        Constants.eIDAS_ATTR_CURRENTGIVENNAME).first();
    final AttributeDefinition attributeDef4 = attrRegistry.getCoreAttributeRegistry().getByFriendlyName(
        Constants.eIDAS_ATTR_DATEOFBIRTH).first();
   
    final ImmutableAttributeMap attributeMap = ImmutableAttributeMap.builder()
        .put(attributeDef, "LU/AT/" + RandomStringUtils.randomNumeric(64))
        .put(attributeDef2, RandomStringUtils.randomAlphabetic(10))
        .put(attributeDef3, RandomStringUtils.randomAlphabetic(10)).put(attributeDef4, "2001-01-01").build();

    val b = new AuthenticationResponse.Builder();
    return b.id("_".concat(Random.nextHexRandom16()))
        .issuer(RandomStringUtils.randomAlphabetic(10))
        .subject(RandomStringUtils.randomAlphabetic(10))
        .statusCode(statusCode)
        .inResponseTo("_".concat(Random.nextHexRandom16()))
        .subjectNameIdFormat("afaf")
        .levelOfAssurance(EaafConstants.EIDAS_LOA_HIGH)
        .attributes(attributeMap)
        .build();
  }
  
}