package at.gv.egovernment.moa.spss.test.integration;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.Date;
import java.util.List;
import java.util.Map;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.apache.commons.lang3.time.DateFormatUtils;
import org.junit.AfterClass;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;

import at.gv.egovernment.moa.sig.tsl.database.DatabaseServiceFactory;
import at.gv.egovernment.moa.sig.tsl.database.SQLiteDBService;
import at.gv.egovernment.moa.spss.MOAApplicationException;
import at.gv.egovernment.moa.spss.api.cmsverify.VerifyCMSSignatureRequest;
import at.gv.egovernment.moa.spss.api.impl.VerifyCMSSignatureRequestImpl;
import at.gv.egovernment.moa.spss.api.xmlbind.VerifyXMLSignatureRequestParser;
import at.gv.egovernment.moa.spss.api.xmlverify.VerifyXMLSignatureRequest;
import at.gv.egovernment.moa.spss.server.config.ConfigurationException;
import at.gv.egovernment.moa.spss.server.config.ConfigurationProvider;
import at.gv.egovernment.moa.spss.server.init.StartupConfigurationHolder;
import at.gv.egovernment.moa.spss.server.transaction.TransactionContext;
import at.gv.egovernment.moa.spss.server.transaction.TransactionContextManager;
import at.gv.egovernment.moa.spss.tsl.TSLServiceFactory;
import at.gv.egovernment.moaspss.logging.LoggingContext;
import at.gv.egovernment.moaspss.logging.LoggingContextManager;
import at.gv.egovernment.moaspss.util.Base64Utils;
import at.gv.egovernment.moaspss.util.Constants;
import iaik.esi.sva.ConfigurationAdapter;
import iaik.pki.Configurator;
import iaik.pki.PKIFactory;
import iaik.pki.store.certstore.CertStoreFactory;
import iaik.pki.store.truststore.TrustStoreFactory;

public abstract class AbstractIntegrationTest {

  private static final String XMLNS_NS_URI = Constants.XMLNS_NS_URI;
  private static final String MOA_NS_URI = Constants.MOA_NS_URI;
  private static final String DSIG = Constants.DSIG_PREFIX + ":";
  protected static final String DEFAULT_XPATH_SIGNATURE_LOCATION = "//" + DSIG + "Signature";

  public static final String PATTERN_ISSUE_INSTANT = "yyyy-MM-dd'T'HH:mm:ssXXX";

  protected static StartupConfigurationHolder moaSpssCore;

  @AfterClass
  public static void jvmStateReset() throws NoSuchFieldException,
      SecurityException, IllegalArgumentException, IllegalAccessException {

    System.setProperty("moa.spss.server.configuration", "");
    System.setProperty("iaik.esi.sva.configuration.location", "");
    
    TrustStoreFactory.reset();
    
    // reset TSL client
    final Field field1 = TSLServiceFactory.class.getDeclaredField("tslClient");
    field1.setAccessible(true);
    field1.set(null, null);

    final Field field5 = SQLiteDBService.class.getDeclaredField("conn");
    field5.setAccessible(true);
    field5.set(null, null);
    
    final Field field6 = DatabaseServiceFactory.class.getDeclaredField("dbServices");
    field6.setAccessible(true);
    field6.set(null, null);
            
    // reset MOA-SPSS configuration object
    final Field field2 = ConfigurationProvider.class.getDeclaredField("instance");
    field2.setAccessible(true);
    field2.set(null, null);
    
    final Field field8 = TransactionContextManager.class.getDeclaredField("instance");
    field8.setAccessible(true);
    field8.set(null, null);
    
    // reset PKI module configuration
    resetClassState(PKIFactory.class, "instance_", null);

    // reset IAIK MOA configuration
    resetClassState(Configurator.class, "C", false);
    
    //reset ESI-SVA configuration
    resetClassState(ConfigurationAdapter.class, "a", null);
    resetClassState(ConfigurationAdapter.class, "instance", null);
    //resetClassState(ConfigurationAdapter.class, "config", null);
    //resetClassState(ConfigurationAdapter.class, "libraryConfig", null);
    
  }

  private static void resetClassState(Class clazz, String fieldName, Object value) {
    try {
      Field field7 = clazz.getDeclaredField(fieldName);
      if (field7 != null) {
        field7.setAccessible(true);
        field7.set(null, value);       
      }
      
    } catch (NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException e) {
      e.printStackTrace();
    }
    
  }
  
  
  protected VerifyXMLSignatureRequest buildVerifyXmlRequest(final byte[] signature,
      final String trustProfileID, boolean extValFlag,
      final List<String> verifyTransformsInfoProfileID, final String xpathSignatureLocation,
      Date sigValDate, final Map<String, byte[]> supplementContent) throws IOException,
      ParserConfigurationException, MOAApplicationException {
    // build empty document
    final Document requestDoc_ = getNewDocumentBuilder();

    final Element requestElem_ =
        requestDoc_.createElementNS(MOA_NS_URI, "VerifyXMLSignatureRequest");
    requestElem_.setAttributeNS(XMLNS_NS_URI, "xmlns", MOA_NS_URI);
    requestElem_.setAttributeNS(XMLNS_NS_URI, "xmlns:" + Constants.DSIG_PREFIX,
        Constants.DSIG_NS_URI);
    requestDoc_.appendChild(requestElem_);

    // build the request

    // build set signing time
    if (sigValDate != null) {
      final Element dateTimeElem = requestDoc_.createElementNS(MOA_NS_URI, "DateTime");
      requestElem_.appendChild(dateTimeElem);
      final Node dateTime = requestDoc_.createTextNode(
          DateFormatUtils.format(sigValDate, PATTERN_ISSUE_INSTANT));
      dateTimeElem.appendChild(dateTime);

    }

    // extended validation flag
    final Element extVal = requestDoc_.createElementNS(MOA_NS_URI, "ExtendedValidation");
    requestElem_.appendChild(extVal);
    final Node extValElement = requestDoc_.createTextNode(String.valueOf(extValFlag));
    extVal.appendChild(extValElement);

    // set other parameters
    final Element verifiySignatureInfoElem =
        requestDoc_.createElementNS(MOA_NS_URI, "VerifySignatureInfo");
    requestElem_.appendChild(verifiySignatureInfoElem);
    final Element verifySignatureEnvironmentElem =
        requestDoc_.createElementNS(MOA_NS_URI, "VerifySignatureEnvironment");
    verifiySignatureInfoElem.appendChild(verifySignatureEnvironmentElem);
    final Element base64ContentElem = requestDoc_.createElementNS(MOA_NS_URI, "Base64Content");
    verifySignatureEnvironmentElem.appendChild(base64ContentElem);

    // insert the base64 encoded signature
    String base64EncodedAssertion = Base64Utils.encode(signature);
    // replace all '\r' characters by no char.
    final StringBuffer replaced = new StringBuffer();
    for (int i = 0; i < base64EncodedAssertion.length(); i++) {
      final char c = base64EncodedAssertion.charAt(i);
      if (c != '\r') {
        replaced.append(c);
      }
    }
    base64EncodedAssertion = replaced.toString();
    final Node base64Content = requestDoc_.createTextNode(base64EncodedAssertion);
    base64ContentElem.appendChild(base64Content);

    // specify the signature location
    final Element verifySignatureLocationElem =
        requestDoc_.createElementNS(MOA_NS_URI, "VerifySignatureLocation");
    verifiySignatureInfoElem.appendChild(verifySignatureLocationElem);
    final Node signatureLocation = requestDoc_.createTextNode(xpathSignatureLocation);
    verifySignatureLocationElem.appendChild(signatureLocation);

    // signature manifest params
    if (verifyTransformsInfoProfileID != null && !verifyTransformsInfoProfileID.isEmpty()) {
      final Element signatureManifestCheckParamsElem =
          requestDoc_.createElementNS(MOA_NS_URI, "SignatureManifestCheckParams");
      requestElem_.appendChild(signatureManifestCheckParamsElem);
      signatureManifestCheckParamsElem.setAttribute("ReturnReferenceInputData", "false");

      // verify transformations
      final Element referenceInfoElem = requestDoc_.createElementNS(MOA_NS_URI, "ReferenceInfo");
      signatureManifestCheckParamsElem.appendChild(referenceInfoElem);
      for (final String element : verifyTransformsInfoProfileID) {
        final Element verifyTransformsInfoProfileIdElem =
            requestDoc_.createElementNS(MOA_NS_URI, "VerifyTransformsInfoProfileID");
        referenceInfoElem.appendChild(verifyTransformsInfoProfileIdElem);
        verifyTransformsInfoProfileIdElem.appendChild(requestDoc_.createTextNode(element));

      }
    }

    // hashinput data
    final Element returnHashInputDataElem =
        requestDoc_.createElementNS(MOA_NS_URI, "ReturnHashInputData");
    requestElem_.appendChild(returnHashInputDataElem);

    // add trustProfileID
    final Element trustProfileIdElem = requestDoc_.createElementNS(MOA_NS_URI, "TrustProfileID");
    trustProfileIdElem.appendChild(requestDoc_.createTextNode(trustProfileID));
    requestElem_.appendChild(trustProfileIdElem);

    // add supplement profile
    if (!supplementContent.isEmpty()) {

      final Element supplementProfile = requestDoc_.createElementNS(MOA_NS_URI, "SupplementProfile");

      for (final Map.Entry<String, byte[]> entry : supplementContent.entrySet()) {
        final String reference = entry.getKey();
        final byte[] contentBytes = entry.getValue();
        final Element content = requestDoc_.createElementNS(MOA_NS_URI, "Content");
        content.setAttribute("Reference", reference);
        final Element b64content = requestDoc_.createElementNS(MOA_NS_URI, "Base64Content");
        b64content.setTextContent(Base64Utils.encode(contentBytes));
        content.appendChild(b64content);
        supplementProfile.appendChild(content);
      }

      requestElem_.appendChild(supplementProfile);
    }

    return new VerifyXMLSignatureRequestParser().parse(requestElem_);

  }

  protected VerifyCMSSignatureRequest buildVerfifyCmsRequest(final byte[] signature,
      final String trustProfileID, final boolean isPdfSignature,
      final boolean performExtendedValidation) {
    final VerifyCMSSignatureRequestImpl verifyCmsSignatureRequest =
        new VerifyCMSSignatureRequestImpl();
    verifyCmsSignatureRequest.setDateTime(null);
    verifyCmsSignatureRequest.setCMSSignature(new ByteArrayInputStream(signature));
    verifyCmsSignatureRequest.setDataObject(null);
    verifyCmsSignatureRequest.setTrustProfileId(trustProfileID);
    verifyCmsSignatureRequest.setSignatories(VerifyCMSSignatureRequest.ALL_SIGNATORIES);
    verifyCmsSignatureRequest.setPDF(isPdfSignature);
    verifyCmsSignatureRequest.setExtended(performExtendedValidation);
    return verifyCmsSignatureRequest;

  }

  protected synchronized Document getNewDocumentBuilder() throws ParserConfigurationException {
    final DocumentBuilder docBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
    return docBuilder.newDocument();

  }

  protected final void setUpContexts(final String transactionID) throws ConfigurationException {
    final TransactionContextManager txMgr = TransactionContextManager.getInstance();
    final LoggingContextManager logMgr = LoggingContextManager.getInstance();

    if (txMgr.getTransactionContext() == null) {
      final TransactionContext ctx =
          new TransactionContext(transactionID, null, moaSpssCore.getMoaSpssConfig());
      txMgr.setTransactionContext(ctx);

    }

    // set Logging context into MOA-Sig
    if (logMgr.getLoggingContext() == null) {
      final LoggingContext ctx = new LoggingContext(transactionID);
      logMgr.setLoggingContext(ctx);

    }

    // new IaikConfigurator().configure(moaSigConfig.getMoaSigConfig());

  }
}