/*
 * Copyright (c) 2015, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * 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.
 */

package org.apache.synapse.transport.passthru.core.ssl;


import org.apache.axiom.om.OMAbstractFactory;
import org.apache.axiom.om.OMElement;
import org.apache.axiom.om.OMFactory;
import org.apache.axiom.om.util.AXIOMUtil;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.synapse.transport.nhttp.NhttpConstants;

import javax.xml.stream.XMLStreamException;

public class SSLConfiguration {

    private Log log = LogFactory.getLog(SSLConfiguration.class);

    private String keyStore;
    private String trustStore;
    private String clientAuthEl;
    private String httpsProtocolsEl;
    private String revocationVerifier;
    private String sslProtocol;
    private String preferredCiphersEl;


    private OMElement keyStoreElement;
    private OMElement trustStoreElement;
    private OMElement clientAuthElement;
    private OMElement revocationVerifierElement;
    private OMElement httpsProtocolElement;
    /** Config of Preferred cipher suites **/
    private OMElement preferredCiphersElement;


    public SSLConfiguration(String keyStore, String trustStore, String clientAuthEl,
                            String httpsProtocolsEl, String revocationVerifier,
                            String sslProtocol, String preferredCiphersEl) {
        this.keyStore = keyStore;
        this.trustStore = trustStore;
        this.clientAuthEl = clientAuthEl;
        this.httpsProtocolsEl = httpsProtocolsEl;
        this.revocationVerifier = revocationVerifier;
        this.sslProtocol = sslProtocol;
        this.preferredCiphersEl = preferredCiphersEl;
    }



    public OMElement getKeyStoreElement() {
        if (keyStore != null) {
            try {
                keyStoreElement = AXIOMUtil.stringToOM(keyStore);
            } catch (XMLStreamException e) {
                log.error("Keystore may not be well formed XML", e);
            }
        }
        return keyStoreElement;
    }

    public OMElement getClientAuthElement() {
        if (clientAuthEl != null) {
            OMFactory fac = OMAbstractFactory.getOMFactory();
            clientAuthElement = fac.createOMElement("SSLVerifyClient", "", "");
            clientAuthElement.setText(clientAuthEl);
        }
        return clientAuthElement;
    }

    public OMElement getTrustStoreElement() {
        if (trustStore != null) {
            try {
                trustStoreElement = AXIOMUtil.stringToOM(trustStore);
            } catch (XMLStreamException e) {
                log.error("TrustStore may not be well formed XML", e);
            }
        }
        return trustStoreElement;
    }


    public OMElement getRevocationVerifierElement() {
        if (revocationVerifier != null) {
            try {
                revocationVerifierElement = AXIOMUtil.stringToOM(revocationVerifier);
            } catch (XMLStreamException e) {
                log.error("CertificateRevocationVerifier may not be well formed XML", e);
            }
        }
        return revocationVerifierElement;
    }

    public OMElement getHttpsProtocolElement() {
        if (httpsProtocolsEl != null) {
            OMFactory fac = OMAbstractFactory.getOMFactory();
            httpsProtocolElement = fac.createOMElement("HttpsProtocols", "", "");
            httpsProtocolElement.setText(httpsProtocolsEl);
        }
        return httpsProtocolElement;
    }

    public String getPreferredCiphersEl() {
        return preferredCiphersEl;
    }

    /**
     * Return a OMElement of preferred ciphers parameter values.
     * @return OMElement
     */
    public OMElement getPreferredCiphersElement() {
        if (preferredCiphersEl != null) {
            OMFactory fac = OMAbstractFactory.getOMFactory();
            preferredCiphersElement = fac.createOMElement(NhttpConstants.PREFERRED_CIPHERS, "", "");
            preferredCiphersElement.setText(preferredCiphersEl);
        }
        return preferredCiphersElement;
    }

    public String getSslProtocol() {
        return sslProtocol;
    }

    public String getKeyStore() {
        return keyStore;
    }

    public String getTrustStore() {
        return trustStore;
    }

    public String getClientAuthEl() {
        return clientAuthEl;
    }

    public String getHttpsProtocolsEl() {
        return httpsProtocolsEl;
    }

    public String getRevocationVerifier() {
        return revocationVerifier;
    }


}
