/*******************************************************************************
 * Copyright 2014 Federal Chancellery Austria
 * MOA-ID has been developed in a cooperation between BRZ, the Federal
 * Chancellery Austria - ICT staff unit, and Graz University of Technology.
 *
 * Licensed under the EUPL, Version 1.1 or - as soon they will be approved by
 * the European Commission - subsequent versions of the EUPL (the "Licence");
 * You may not use this work except in compliance with the Licence.
 * You may obtain a copy of the Licence at:
 * http://www.osor.eu/eupl/
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the Licence is distributed on an "AS IS" basis,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the Licence for the specific language governing permissions and
 * limitations under the Licence.
 *
 * 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.gv.egovernment.moa.id.configuration.data;

import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import at.gv.egiz.eaaf.core.impl.utils.KeyValueUtils;
import at.gv.egovernment.moa.id.commons.db.dao.config.deprecated.AuthComponentGeneral;
import at.gv.egovernment.moa.id.commons.db.dao.config.deprecated.ChainingModeType;
import at.gv.egovernment.moa.id.commons.db.dao.config.deprecated.ChainingModes;
import at.gv.egovernment.moa.id.commons.db.dao.config.deprecated.ConnectionParameterClientAuthType;
import at.gv.egovernment.moa.id.commons.db.dao.config.deprecated.Contact;
import at.gv.egovernment.moa.id.commons.db.dao.config.deprecated.DefaultBKUs;
import at.gv.egovernment.moa.id.commons.db.dao.config.deprecated.ForeignIdentities;
import at.gv.egovernment.moa.id.commons.db.dao.config.deprecated.GeneralConfiguration;
import at.gv.egovernment.moa.id.commons.db.dao.config.deprecated.LegacyAllowed;
import at.gv.egovernment.moa.id.commons.db.dao.config.deprecated.MOAIDConfiguration;
import at.gv.egovernment.moa.id.commons.db.dao.config.deprecated.MOASP;
import at.gv.egovernment.moa.id.commons.db.dao.config.deprecated.OAuth;
import at.gv.egovernment.moa.id.commons.db.dao.config.deprecated.OnlineMandates;
import at.gv.egovernment.moa.id.commons.db.dao.config.deprecated.Organization;
import at.gv.egovernment.moa.id.commons.db.dao.config.deprecated.PVP2;
import at.gv.egovernment.moa.id.commons.db.dao.config.deprecated.Protocols;
import at.gv.egovernment.moa.id.commons.db.dao.config.deprecated.SAML1;
import at.gv.egovernment.moa.id.commons.db.dao.config.deprecated.SLRequestTemplates;
import at.gv.egovernment.moa.id.commons.db.dao.config.deprecated.SSO;
import at.gv.egovernment.moa.id.commons.db.dao.config.deprecated.STORK;
import at.gv.egovernment.moa.id.commons.db.dao.config.deprecated.SecurityLayer;
import at.gv.egovernment.moa.id.commons.db.dao.config.deprecated.TimeOuts;
import at.gv.egovernment.moa.id.commons.db.dao.config.deprecated.TransformsInfoType;
import at.gv.egovernment.moa.id.commons.db.dao.config.deprecated.TrustAnchor;
import at.gv.egovernment.moa.id.commons.db.dao.config.deprecated.VerifyAuthBlock;
import at.gv.egovernment.moa.id.commons.db.dao.config.deprecated.VerifyIdentityLink;
import at.gv.egovernment.moa.id.config.webgui.exception.ConfigurationException;
import at.gv.egovernment.moa.id.configuration.Constants;
import at.gv.egovernment.moa.id.configuration.config.ConfigurationProvider;
import at.gv.egovernment.moa.id.configuration.data.pvp2.ContactForm;
import at.gv.egovernment.moa.util.MiscUtil;

public class GeneralMOAIDConfig {

  public static final long DEFAULTTIMEOUTASSERTION = 120; // sec
  public static final long DEFAULTTIMEOUTMOASESSIONCREATED = 1200; // sec
  public static final long DEFAULTTIMEOUTMOASESSIONUPDATED = 2700; // sec

  public static final String LINE_DELIMITER = ";";

  private String alternativeSourceID = null;
//	private String certStoreDirectory = null; 
  private boolean trustmanagerrevocationcheck = true;

  private String timeoutAssertion = String.valueOf(DEFAULTTIMEOUTASSERTION);
  private String timeoutMOASessionCreated = String.valueOf(DEFAULTTIMEOUTMOASESSIONCREATED);
  private String timeoutMOASessionUpdated = String.valueOf(DEFAULTTIMEOUTMOASESSIONUPDATED);

  private String moaspssURL = null;
  private String moaspssAuthTrustProfile = null;
  private String moaspssAuthTransformations = "";
  private List<String> authTransformList = null;
  private String moaspssIdlTrustProfile = null;

  private String moaspssIdlTrustProfileTest = null;
  private String moaspssAuthTrustProfileTest = null;

  private String mandateURL = null;
  private String szrgwURL = null;
  private String elgaMandateServiceURL = null;
  private String eidSystemServiceURL = null;

  private boolean protocolActiveSAML1 = false;
  private boolean protocolActivePVP21 = true;
  private boolean protocolActiveOAuth = true;

  private boolean legacy_saml1 = false;
  private boolean legacy_pvp2 = false;

  private String saml1SourceID = null;

  private String pvp2IssuerName = null;
  private String pvp2OrgName = null;
  private String pvp2OrgDisplayName = null;
  private String pvp2OrgURL = null;
  private ContactForm pvp2Contact = null;

  private List<File> fileUpload = null;
  private List<String> fileUploadContentType;
  private List<String> fileUploadFileName = new ArrayList<>();
  private Map<String, byte[]> secLayerTransformation = null;

  private String ssoTarget = null;
  private String ssoFriendlyName = null;
  private String ssoSpecialText = null;
  private String ssoIdentificationNumber = null;

  private String defaultchainigmode = null;
  private static Map<String, String> chainigmodelist;

  private String trustedCACerts = null;

  private String defaultBKUOnline = "";
  private String defaultBKULocal = "https://127.0.0.1:3496/https-security-layer-request";
  private String defaultBKUHandy =
      "https://www.handy-signatur.at/mobile/https-security-layer-request/default.aspx";

  private String SLRequestTemplateOnline = "SLTemplates/template_onlineBKU.html";
  private String SLRequestTemplateLocal = "SLTemplates/template_handyBKU.html";
  private String SLRequestTemplateHandy = "SLTemplates/template_handyBKU.html";

  private String publicURLPrefix = null;
  private boolean virtualPublicURLPrefixEnabled = false;

  private boolean moaidMode = false;

  public GeneralMOAIDConfig() {
    try {
      this.moaidMode = ConfigurationProvider.getInstance().isMOAIDMode();
    } catch (final ConfigurationException e) {
      e.printStackTrace();

    }

    chainigmodelist = new HashMap<>();
    final ChainingModeType[] values = ChainingModeType.values();
    for (final ChainingModeType value : values) {
      chainigmodelist.put(value.value(), value.value());
    }

    try {
      final ConfigurationProvider config = ConfigurationProvider.getInstance();
      if (config != null) {
        final MOAIDConfiguration dbconfig = config.getDbRead().getMOAIDConfiguration();
        final List<TransformsInfoType> authBlockTrans = dbconfig.getAuthComponentGeneral().getSecurityLayer()
            .getTransformsInfo();

        if (authBlockTrans != null && !authBlockTrans.isEmpty()) {
          if (secLayerTransformation == null) {
            secLayerTransformation = new HashMap<>();
          }
          for (final TransformsInfoType el : authBlockTrans) {
            secLayerTransformation.put(el.getFilename(), el.getTransformation());
          }

        }
      }

    } catch (final Exception e) {

    }

  }

  public void parse(MOAIDConfiguration config) {

    if (config != null) {
      final AuthComponentGeneral auth = config.getAuthComponentGeneral();

      // get ELGA mandate service URLs from configuration
      if (MiscUtil.isNotEmpty(config.getEidSystemServiceURLs())) {
        if (KeyValueUtils.isCSVValueString(config.getEidSystemServiceURLs())) {
          eidSystemServiceURL = KeyValueUtils.normalizeCSVValueString(config.getEidSystemServiceURLs());
        } else {
          if (config.getEidSystemServiceURLs().contains(KeyValueUtils.CSV_DELIMITER)) {
            // remove trailing comma if exist
            eidSystemServiceURL = config.getEidSystemServiceURLs().substring(0,
                config.getEidSystemServiceURLs().indexOf(KeyValueUtils.CSV_DELIMITER));

          } else {
            eidSystemServiceURL = config.getEidSystemServiceURLs();
          }

        }
      }

      // get ELGA mandate service URLs from configuration
      if (MiscUtil.isNotEmpty(config.getElgaMandateServiceURLs())) {
        if (KeyValueUtils.isCSVValueString(config.getElgaMandateServiceURLs())) {
          elgaMandateServiceURL = KeyValueUtils.normalizeCSVValueString(config.getElgaMandateServiceURLs());
        } else {
          if (config.getElgaMandateServiceURLs().contains(KeyValueUtils.CSV_DELIMITER)) {
            // remove trailing comma if exist
            elgaMandateServiceURL = config.getElgaMandateServiceURLs().substring(0,
                config.getElgaMandateServiceURLs().indexOf(KeyValueUtils.CSV_DELIMITER));

          } else {
            elgaMandateServiceURL = config.getElgaMandateServiceURLs();
          }

        }
      }

      if (auth != null) {

        final GeneralConfiguration authgen = auth.getGeneralConfiguration();
        if (authgen != null) {
          alternativeSourceID = authgen.getAlternativeSourceID();
          // certStoreDirectory = authgen.getCertStoreDirectory();
          if (authgen.isTrustManagerRevocationChecking() != null) {
            trustmanagerrevocationcheck = authgen.isTrustManagerRevocationChecking();
          }

          virtualPublicURLPrefixEnabled =
              KeyValueUtils.isCSVValueString(authgen.getPublicURLPreFix());

          if (virtualPublicURLPrefixEnabled) {
            // format CSV values with newlines
            publicURLPrefix = KeyValueUtils.normalizeCSVValueString(
                authgen.getPublicURLPreFix());

          } else {
            final String tmp = authgen.getPublicURLPreFix();
            if (tmp.contains(KeyValueUtils.CSV_DELIMITER)) {
              // remove trailing comma if exist
              publicURLPrefix = tmp.substring(0,
                  tmp.indexOf(KeyValueUtils.CSV_DELIMITER));

            } else {
              publicURLPrefix = tmp;
            }
          }

          final TimeOuts timeouts = authgen.getTimeOuts();
          if (timeouts != null) {

            if (timeouts.getAssertion() != null) {
              timeoutAssertion = String.valueOf(timeouts.getAssertion().longValue());
            }
            if (timeouts.getMOASessionCreated() != null) {
              timeoutMOASessionCreated = String.valueOf(timeouts.getMOASessionCreated().longValue());
            }
            if (timeouts.getMOASessionUpdated() != null) {
              timeoutMOASessionUpdated = String.valueOf(timeouts.getMOASessionUpdated().longValue());
            }

          }

          // deactive STORK
          if (isMoaidMode()) {
            final ForeignIdentities foreign = auth.getForeignIdentities();
            if (foreign != null) {
              final ConnectionParameterClientAuthType connect_foreign = foreign.getConnectionParameter();
              if (connect_foreign != null) {
                if (MiscUtil.isNotEmpty(connect_foreign.getURL())) {
                  if (KeyValueUtils.isCSVValueString(connect_foreign.getURL())) {
                    szrgwURL = KeyValueUtils.normalizeCSVValueString(connect_foreign.getURL());
                  } else {
                    if (connect_foreign.getURL().contains(KeyValueUtils.CSV_DELIMITER)) {
                      // remove trailing comma if exist
                      szrgwURL = connect_foreign.getURL().substring(0,
                          connect_foreign.getURL().indexOf(KeyValueUtils.CSV_DELIMITER));

                    } else {
                      szrgwURL = connect_foreign.getURL();
                    }

                  }

                }
              }

              final STORK stork = foreign.getSTORK();
              if (stork != null) {
                // TODO: add Stork config

              }
            }
          }

        }

        if (isMoaidMode()) {
          final MOASP moaspss = auth.getMOASP();
          if (moaspss != null) {
            final ConnectionParameterClientAuthType con = moaspss.getConnectionParameter();
            if (con != null) {
              moaspssURL = con.getURL();
            }

            final VerifyAuthBlock authblock = moaspss.getVerifyAuthBlock();
            if (authblock != null) {
              moaspssAuthTrustProfile = authblock.getTrustProfileID();
              moaspssAuthTrustProfileTest = authblock.getTestTrustProfileID();

              final List<String> list = authblock.getVerifyTransformsInfoProfileID();
              if (list.size() == 1) {
                moaspssAuthTransformations += list.get(0);
              } else {
                for (final String el : list) {
                  moaspssAuthTransformations += el + LINE_DELIMITER + "\n";
                }
              }
            }

            final VerifyIdentityLink idl = moaspss.getVerifyIdentityLink();
            if (idl != null) {
              moaspssIdlTrustProfile = idl.getTrustProfileID();
              moaspssIdlTrustProfileTest = idl.getTestTrustProfileID();
            }
          }

          final OnlineMandates mandates = auth.getOnlineMandates();
          if (mandates != null) {
            final ConnectionParameterClientAuthType con = mandates.getConnectionParameter();
            if (con != null) {
              if (MiscUtil.isNotEmpty(con.getURL())) {
                if (KeyValueUtils.isCSVValueString(con.getURL())) {
                  mandateURL = KeyValueUtils.normalizeCSVValueString(con.getURL());
                } else {
                  if (con.getURL().contains(KeyValueUtils.CSV_DELIMITER)) {
                    // remove trailing comma if exist
                    mandateURL = con.getURL().substring(0,
                        con.getURL().indexOf(KeyValueUtils.CSV_DELIMITER));

                  } else {
                    mandateURL = con.getURL();
                  }

                }

              }

            }
          }
        }

        final Protocols protocols = auth.getProtocols();
        if (protocols != null) {
          final LegacyAllowed legacy = protocols.getLegacyAllowed();

          if (legacy != null) {
            final List<String> list = legacy.getProtocolName();
            if (list.contains(Constants.MOA_CONFIG_PROTOCOL_SAML1)) {
              legacy_saml1 = true;
            }

            if (list.contains(Constants.MOA_CONFIG_PROTOCOL_PVP2)) {
              legacy_pvp2 = true;
            }
          }

          final SAML1 saml1 = protocols.getSAML1();
          if (saml1 != null) {
            protocolActiveSAML1 = saml1.isIsActive();
            saml1SourceID = saml1.getSourceID();

            // TODO: could removed in a later version
            if (MiscUtil.isEmpty(saml1SourceID) && MiscUtil.isNotEmpty(alternativeSourceID)) {
              saml1SourceID = alternativeSourceID;
            }

          }

          if (isMoaidMode()) {
            final OAuth oauth = protocols.getOAuth();
            if (oauth != null) {
              protocolActiveOAuth = oauth.isIsActive();

            }

          }

          final PVP2 pvp2 = protocols.getPVP2();
          if (pvp2 != null) {

            protocolActivePVP21 = pvp2.isIsActive();

            // INFO: only for backup
            if (MiscUtil.isEmpty(publicURLPrefix)) {
              publicURLPrefix = pvp2.getPublicURLPrefix();
            }

            pvp2IssuerName = pvp2.getIssuerName();

            final List<Contact> con = pvp2.getContact();

            // TODO: change to support more contacts
            if (con != null && con.size() > 0) {
              pvp2Contact = new ContactForm(con.get(0));

            }

            final Organization org = pvp2.getOrganization();
            if (org != null) {
              pvp2OrgDisplayName = org.getDisplayName();
              pvp2OrgName = org.getName();
              pvp2OrgURL = org.getURL();
            }
          }

        }

        if (isMoaidMode()) {
          final SecurityLayer seclayer = auth.getSecurityLayer();
          if (seclayer != null) {
            final List<TransformsInfoType> list = seclayer.getTransformsInfo();

            for (final TransformsInfoType el : list) {
              fileUploadFileName.add(el.getFilename());
            }
          }

          final SSO sso = auth.getSSO();
          if (sso != null) {
            ssoFriendlyName = sso.getFriendlyName();

            // IdentificationNumber idl = sso.getIdentificationNumber();
            // if (idl != null)
            // ssoIdentificationNumber = idl.getValue();

            // INFO: only for backup
            if (MiscUtil.isEmpty(publicURLPrefix)) {
              publicURLPrefix = sso.getPublicURL();
            }

            ssoSpecialText = sso.getSpecialText();

            if (MiscUtil.isNotEmpty(sso.getTarget()) &&
                sso.getTarget().startsWith(Constants.PREFIX_WPBK)) {
              ssoTarget = sso.getTarget().substring(Constants.PREFIX_WPBK.length()).replace("+", "");

            } else {
              ssoTarget = sso.getTarget();
            }

          }
        }

        final ChainingModes modes = config.getChainingModes();
        if (modes != null) {
          final ChainingModeType defaultmode = modes.getSystemDefaultMode();
          if (defaultmode != null) {

            defaultchainigmode = defaultmode.value();

          }

          final List<TrustAnchor> trustanchor = modes.getTrustAnchor();
          if (trustanchor != null) {
            // TODO: set addional trust anchors!!!!
          }
        }

        final DefaultBKUs defaultbkus = config.getDefaultBKUs();
        if (defaultbkus != null) {
          defaultBKUHandy = defaultbkus.getHandyBKU();
          defaultBKULocal = defaultbkus.getLocalBKU();
          defaultBKUOnline = defaultbkus.getOnlineBKU();
        }

        final SLRequestTemplates slreq = config.getSLRequestTemplates();
        if (slreq != null) {
          SLRequestTemplateHandy = slreq.getHandyBKU();
          SLRequestTemplateLocal = slreq.getLocalBKU();
          SLRequestTemplateOnline = slreq.getOnlineBKU();
        }

      }

      trustedCACerts = config.getTrustedCACertificates();

    }
  }

  /**
   * @return the szrgwURL
   */
  public String getSzrgwURL() {
    return szrgwURL;
  }

  /**
   * @param szrgwURL the szrgwURL to set
   */
  public void setSzrgwURL(String szrgwURL) {
    if (MiscUtil.isNotEmpty(szrgwURL)) {
      this.szrgwURL = KeyValueUtils.removeAllNewlineFromString(szrgwURL);
    } else {
      this.szrgwURL = szrgwURL;
    }
  }

//	/**
//	 * @return the certStoreDirectory
//	 */
//	public String getCertStoreDirectory() {
//		return certStoreDirectory;
//	}
//
//	/**
//	 * @param certStoreDirectory the certStoreDirectory to set
//	 */
//	public void setCertStoreDirectory(String certStoreDirectory) {
//		this.certStoreDirectory = certStoreDirectory;
//	}

  /**
   * @return the timeoutAssertion
   */
  public String getTimeoutAssertion() {
    return timeoutAssertion;
  }

  /**
   * @param timeoutAssertion the timeoutAssertion to set
   */
  public void setTimeoutAssertion(String timeoutAssertion) {
    this.timeoutAssertion = timeoutAssertion;
  }

  /**
   * @return the timeoutMOASessionCreated
   */
  public String getTimeoutMOASessionCreated() {
    return timeoutMOASessionCreated;
  }

  /**
   * @param timeoutMOASessionCreated the timeoutMOASessionCreated to set
   */
  public void setTimeoutMOASessionCreated(String timeoutMOASessionCreated) {
    this.timeoutMOASessionCreated = timeoutMOASessionCreated;
  }

  /**
   * @return the timeoutMOASessionUpdated
   */
  public String getTimeoutMOASessionUpdated() {
    return timeoutMOASessionUpdated;
  }

  /**
   * @param timeoutMOASessionUpdated the timeoutMOASessionUpdated to set
   */
  public void setTimeoutMOASessionUpdated(String timeoutMOASessionUpdated) {
    this.timeoutMOASessionUpdated = timeoutMOASessionUpdated;
  }

  /**
   * @return the moaspssURL
   */
  public String getMoaspssURL() {
    return moaspssURL;
  }

  /**
   * @param moaspssURL the moaspssURL to set
   */
  public void setMoaspssURL(String moaspssURL) {
    this.moaspssURL = moaspssURL;
  }

  /**
   * @return the moaspssAuthTrustProfile
   */
  public String getMoaspssAuthTrustProfile() {
    return moaspssAuthTrustProfile;
  }

  /**
   * @param moaspssAuthTrustProfile the moaspssAuthTrustProfile to set
   */
  public void setMoaspssAuthTrustProfile(String moaspssAuthTrustProfile) {
    this.moaspssAuthTrustProfile = moaspssAuthTrustProfile;
  }

  /**
   * @return the moaspssAuthTransformations
   */
  public String getMoaspssAuthTransformations() {
    return moaspssAuthTransformations;
  }

  /**
   * @param moaspssAuthTransformations the moaspssAuthTransformations to set
   */
  public void setMoaspssAuthTransformations(String moaspssAuthTransformations) {
    this.moaspssAuthTransformations = moaspssAuthTransformations;
  }

  /**
   * @return the moaspssIdlTrustProfile
   */
  public String getMoaspssIdlTrustProfile() {
    return moaspssIdlTrustProfile;
  }

  /**
   * @param moaspssIdlTrustProfile the moaspssIdlTrustProfile to set
   */
  public void setMoaspssIdlTrustProfile(String moaspssIdlTrustProfile) {
    this.moaspssIdlTrustProfile = moaspssIdlTrustProfile;
  }

  /**
   * @return the mandateURL
   */
  public String getMandateURL() {
    return mandateURL;
  }

  /**
   * @param mandateURL the mandateURL to set
   */
  public void setMandateURL(String mandateURL) {
    if (MiscUtil.isNotEmpty(mandateURL)) {
      this.mandateURL = KeyValueUtils.removeAllNewlineFromString(mandateURL);
    } else {
      this.mandateURL = mandateURL;
    }
  }

  /**
   * @return the legacy_saml1
   */
  public boolean isLegacy_saml1() {
    return legacy_saml1;
  }

  /**
   * @param legacy_saml1 the legacy_saml1 to set
   */
  public void setLegacy_saml1(boolean legacy_saml1) {
    this.legacy_saml1 = legacy_saml1;
  }

  /**
   * @return the legacy_pvp2
   */
  public boolean isLegacy_pvp2() {
    return legacy_pvp2;
  }

  /**
   * @param legacy_pvp2 the legacy_pvp2 to set
   */
  public void setLegacy_pvp2(boolean legacy_pvp2) {
    this.legacy_pvp2 = legacy_pvp2;
  }

  /**
   * @return the pvp2IssuerName
   */
  public String getPvp2IssuerName() {
    return pvp2IssuerName;
  }

  /**
   * @param pvp2IssuerName the pvp2IssuerName to set
   */
  public void setPvp2IssuerName(String pvp2IssuerName) {
    this.pvp2IssuerName = pvp2IssuerName;
  }

  /**
   * @return the pvp2OrgName
   */
  public String getPvp2OrgName() {
    return pvp2OrgName;
  }

  /**
   * @param pvp2OrgName the pvp2OrgName to set
   */
  public void setPvp2OrgName(String pvp2OrgName) {
    this.pvp2OrgName = pvp2OrgName;
  }

  /**
   * @return the pvp2OrgDisplayName
   */
  public String getPvp2OrgDisplayName() {
    return pvp2OrgDisplayName;
  }

  /**
   * @param pvp2OrgDisplayName the pvp2OrgDisplayName to set
   */
  public void setPvp2OrgDisplayName(String pvp2OrgDisplayName) {
    this.pvp2OrgDisplayName = pvp2OrgDisplayName;
  }

  /**
   * @return the pvp2OrgURL
   */
  public String getPvp2OrgURL() {
    return pvp2OrgURL;
  }

  /**
   * @param pvp2OrgURL the pvp2OrgURL to set
   */
  public void setPvp2OrgURL(String pvp2OrgURL) {
    this.pvp2OrgURL = pvp2OrgURL;
  }

  /**
   * @return the pvp2Contact
   */
  public ContactForm getPvp2Contact() {
    return pvp2Contact;
  }

  /**
   * @param pvp2Contact the pvp2Contact to set
   */
  public void setPvp2Contact(ContactForm pvp2Contact) {
    this.pvp2Contact = pvp2Contact;
  }

  /**
   * @return the fileUpload
   */
  public List<File> getFileUpload() {
    return fileUpload;
  }

  /**
   * @param fileUpload the fileUpload to set
   */
  public void setFileUpload(List<File> fileUpload) {
    this.fileUpload = fileUpload;
  }

  /**
   * @return the fileUploadContentType
   */
  public List<String> getFileUploadContentType() {
    return fileUploadContentType;
  }

  /**
   * @param fileUploadContentType the fileUploadContentType to set
   */
  public void setFileUploadContentType(List<String> fileUploadContentType) {
    this.fileUploadContentType = fileUploadContentType;
  }

  /**
   * @return the fileUploadFileName
   */
  public List<String> getFileUploadFileName() {
    return fileUploadFileName;
  }

  /**
   * @param fileUploadFileName the fileUploadFileName to set
   */
  public void setFileUploadFileName(List<String> fileUploadFileName) {
    this.fileUploadFileName = fileUploadFileName;
  }

  /**
   * @return the ssoTarget
   */
  public String getSsoTarget() {
    return ssoTarget;
  }

  /**
   * @param ssoTarget the ssoTarget to set
   */
  public void setSsoTarget(String ssoTarget) {
    this.ssoTarget = ssoTarget;
  }

  /**
   * @return the ssoFriendlyName
   */
  public String getSsoFriendlyName() {
    return ssoFriendlyName;
  }

  /**
   * @param ssoFriendlyName the ssoFriendlyName to set
   */
  public void setSsoFriendlyName(String ssoFriendlyName) {
    this.ssoFriendlyName = ssoFriendlyName;
  }

  /**
   * @return the ssoSpecialText
   */
  public String getSsoSpecialText() {
    return ssoSpecialText;
  }

  /**
   * @param ssoSpecialText the ssoSpecialText to set
   */
  public void setSsoSpecialText(String ssoSpecialText) {
    this.ssoSpecialText = ssoSpecialText;
  }

  /**
   * @return the ssoIdentificationNumber
   */
  public String getSsoIdentificationNumber() {
    return ssoIdentificationNumber;
  }

  /**
   * @param ssoIdentificationNumber the ssoIdentificationNumber to set
   */
  public void setSsoIdentificationNumber(String ssoIdentificationNumber) {
    this.ssoIdentificationNumber = ssoIdentificationNumber;
  }

  /**
   * @return the defaultchainigmode
   */
  public String getDefaultchainigmode() {
    return defaultchainigmode;
  }

  /**
   * @param defaultchainigmode the defaultchainigmode to set
   */
  public void setDefaultchainigmode(String defaultchainigmode) {
    this.defaultchainigmode = defaultchainigmode;
  }

  /**
   * @return the defaultBKUOnline
   */
  public String getDefaultBKUOnline() {
    return defaultBKUOnline;
  }

  /**
   * @param defaultBKUOnline the defaultBKUOnline to set
   */
  public void setDefaultBKUOnline(String defaultBKUOnline) {
    this.defaultBKUOnline = defaultBKUOnline;
  }

  /**
   * @return the defaultBKULocal
   */
  public String getDefaultBKULocal() {
    return defaultBKULocal;
  }

  /**
   * @param defaultBKULocal the defaultBKULocal to set
   */
  public void setDefaultBKULocal(String defaultBKULocal) {
    this.defaultBKULocal = defaultBKULocal;
  }

  /**
   * @return the defaultBKUHandy
   */
  public String getDefaultBKUHandy() {
    return defaultBKUHandy;
  }

  /**
   * @param defaultBKUHandy the defaultBKUHandy to set
   */
  public void setDefaultBKUHandy(String defaultBKUHandy) {
    this.defaultBKUHandy = defaultBKUHandy;
  }

  /**
   * @return the sLRequestTemplateOnline
   */
  public String getSLRequestTemplateOnline() {
    return SLRequestTemplateOnline;
  }

  /**
   * @param sLRequestTemplateOnline the sLRequestTemplateOnline to set
   */
  public void setSLRequestTemplateOnline(String sLRequestTemplateOnline) {
    SLRequestTemplateOnline = sLRequestTemplateOnline;
  }

  /**
   * @return the sLRequestTemplateLocal
   */
  public String getSLRequestTemplateLocal() {
    return SLRequestTemplateLocal;
  }

  /**
   * @param sLRequestTemplateLocal the sLRequestTemplateLocal to set
   */
  public void setSLRequestTemplateLocal(String sLRequestTemplateLocal) {
    SLRequestTemplateLocal = sLRequestTemplateLocal;
  }

  /**
   * @return the sLRequestTemplateHandy
   */
  public String getSLRequestTemplateHandy() {
    return SLRequestTemplateHandy;
  }

  /**
   * @param sLRequestTemplateHandy the sLRequestTemplateHandy to set
   */
  public void setSLRequestTemplateHandy(String sLRequestTemplateHandy) {
    SLRequestTemplateHandy = sLRequestTemplateHandy;
  }

  /**
   * @return the trustmanagerrevocationcheck
   */
  public boolean isTrustmanagerrevocationcheck() {
    return trustmanagerrevocationcheck;
  }

  /**
   * @param trustmanagerrevocationcheck the trustmanagerrevocationcheck to set
   */
  public void setTrustmanagerrevocationcheck(boolean trustmanagerrevocationcheck) {
    this.trustmanagerrevocationcheck = trustmanagerrevocationcheck;
  }

  /**
   * @return the trustedCACerts
   */
  public String getTrustedCACerts() {
    return trustedCACerts;
  }

  /**
   * @param trustedCACerts the trustedCACerts to set
   */
  public void setTrustedCACerts(String trustedCACerts) {
    this.trustedCACerts = trustedCACerts;
  }

  /**
   * @return the chainigmodelist
   */
  public Map<String, String> getChainigmodelist() {
    return chainigmodelist;
  }

  /**
   * @param chainigmodelist the chainigmodelist to set
   */
  public void setChainigmodelist(Map<String, String> chainigmodelist) {
    GeneralMOAIDConfig.chainigmodelist = chainigmodelist;
  }

  /**
   * @return the secLayerTransformation
   */
  public Map<String, byte[]> getSecLayerTransformation() {

    return secLayerTransformation;
  }

  /**
   * @param secLayerTransformation the secLayerTransformation to set
   */
  public void setSecLayerTransformation(Map<String, byte[]> secLayerTransformation) {
    this.secLayerTransformation = secLayerTransformation;
  }

  /**
   * @return the authTransformList
   */
  public List<String> getAuthTransformList() {
    return authTransformList;
  }

  /**
   * @param authTransformList the authTransformList to set
   */
  public void setAuthTransformList(List<String> authTransformList) {
    this.authTransformList = authTransformList;
  }

  public void setFileUpload(File fileUpload) {
    if (this.fileUpload == null) {
      this.fileUpload = new ArrayList<>();
    }
    this.fileUpload.add(fileUpload);
  }

  public void setFileUploadContentType(String fileUploadContentType) {
    if (this.fileUploadContentType == null) {
      this.fileUploadContentType = new ArrayList<>();
    }
    this.fileUploadContentType.add(fileUploadContentType);
  }

  public void setFileUploadFileName(String fileUploadFileName) {
    if (this.fileUploadFileName == null) {
      this.fileUploadFileName = new ArrayList<>();
    }
    this.fileUploadFileName.add(fileUploadFileName);
  }

  /**
   * @return the protocolActiveSAML1
   */
  public boolean isProtocolActiveSAML1() {
    return protocolActiveSAML1;
  }

  /**
   * @param protocolActiveSAML1 the protocolActiveSAML1 to set
   */
  public void setProtocolActiveSAML1(boolean protocolActiveSAML1) {
    this.protocolActiveSAML1 = protocolActiveSAML1;
  }

  /**
   * @return the protocolActivePVP21
   */
  public boolean isProtocolActivePVP21() {
    return protocolActivePVP21;
  }

  /**
   * @param protocolActivePVP21 the protocolActivePVP21 to set
   */
  public void setProtocolActivePVP21(boolean protocolActivePVP21) {
    this.protocolActivePVP21 = protocolActivePVP21;
  }

  /**
   * @return the protocolActiveOAuth
   */
  public boolean isProtocolActiveOAuth() {
    return protocolActiveOAuth;
  }

  /**
   * @param protocolActiveOAuth the protocolActiveOAuth to set
   */
  public void setProtocolActiveOAuth(boolean protocolActiveOAuth) {
    this.protocolActiveOAuth = protocolActiveOAuth;
  }

  /**
   * @return the saml1SourceID
   */
  public String getSaml1SourceID() {
    return saml1SourceID;
  }

  /**
   * @param saml1SourceID the saml1SourceID to set
   */
  public void setSaml1SourceID(String saml1SourceID) {
    this.saml1SourceID = saml1SourceID;
  }

  /**
   * @return the publicURLPrefix
   */
  public String getPublicURLPrefix() {
    return publicURLPrefix;
  }

  /**
   * @param publicURLPrefix the publicURLPrefix to set
   */
  public void setPublicURLPrefix(String publicURLPrefix) {
    if (MiscUtil.isNotEmpty(publicURLPrefix)) {
      this.publicURLPrefix =
          KeyValueUtils.removeAllNewlineFromString(publicURLPrefix);
    } else {
      this.publicURLPrefix = publicURLPrefix;
    }

  }

  /**
   * @return the moaspssIdlTrustProfileTest
   */
  public String getMoaspssIdlTrustProfileTest() {
    return moaspssIdlTrustProfileTest;
  }

  /**
   * @param moaspssIdlTrustProfileTest the moaspssIdlTrustProfileTest to set
   */
  public void setMoaspssIdlTrustProfileTest(String moaspssIdlTrustProfileTest) {
    this.moaspssIdlTrustProfileTest = moaspssIdlTrustProfileTest;
  }

  /**
   * @return the moaspssAuthTrustProfileTest
   */
  public String getMoaspssAuthTrustProfileTest() {
    return moaspssAuthTrustProfileTest;
  }

  /**
   * @param moaspssAuthTrustProfileTest the moaspssAuthTrustProfileTest to set
   */
  public void setMoaspssAuthTrustProfileTest(String moaspssAuthTrustProfileTest) {
    this.moaspssAuthTrustProfileTest = moaspssAuthTrustProfileTest;
  }

  /**
   * @return the virtualPublicURLPrefixEnabled
   */
  public boolean isVirtualPublicURLPrefixEnabled() {
    return virtualPublicURLPrefixEnabled;
  }

  /**
   * @param virtualPublicURLPrefixEnabled the virtualPublicURLPrefixEnabled to set
   */
  public void setVirtualPublicURLPrefixEnabled(
      boolean virtualPublicURLPrefixEnabled) {
    this.virtualPublicURLPrefixEnabled = virtualPublicURLPrefixEnabled;
  }

  /**
   * @return the elgaMandateServiceURL
   */
  public String getElgaMandateServiceURL() {
    return elgaMandateServiceURL;
  }

  /**
   * @param elgaMandateServiceURL the elgaMandateServiceURL to set
   */
  public void setElgaMandateServiceURL(String elgaMandateServiceURL) {
    if (MiscUtil.isNotEmpty(elgaMandateServiceURL)) {
      this.elgaMandateServiceURL = KeyValueUtils.removeAllNewlineFromString(elgaMandateServiceURL);
    } else {
      this.elgaMandateServiceURL = elgaMandateServiceURL;
    }
  }

  /**
   * @return the eidSystemServiceURL
   */
  public String getEidSystemServiceURL() {
    return eidSystemServiceURL;
  }

  public boolean isMoaidMode() {
    return moaidMode;
  }

  /**
   * @param eidSystemServiceURL the E-ID Service URL to set
   */
  public void setEidSystemServiceURL(String eidSystemServiceURL) {
    if (MiscUtil.isNotEmpty(eidSystemServiceURL)) {
      this.eidSystemServiceURL = KeyValueUtils.removeAllNewlineFromString(eidSystemServiceURL);
    } else {
      this.eidSystemServiceURL = eidSystemServiceURL;
    }
  }

}