import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLEngine;
import javax.net.ssl.SSLParameters;
import javax.net.ssl.TrustManagerFactory;
import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpServer;
import com.sun.net.httpserver.HttpsConfigurator;
import com.sun.net.httpserver.HttpsParameters;
import com.sun.net.httpserver.HttpsServer;
import org.bouncycastle.asn1.ASN1Encodable;
import org.bouncycastle.asn1.DERSequence;
import org.bouncycastle.asn1.pkcs.PrivateKeyInfo;
import org.bouncycastle.asn1.x509.BasicConstraints;
import org.bouncycastle.asn1.x509.ExtendedKeyUsage;
import org.bouncycastle.asn1.x509.Extension;
import org.bouncycastle.asn1.x509.GeneralName;
import org.bouncycastle.asn1.x509.KeyPurposeId;
import org.bouncycastle.asn1.x509.KeyUsage;
import org.bouncycastle.cert.X509CertificateHolder;
import org.bouncycastle.cert.X509v3CertificateBuilder;
import org.bouncycastle.cert.jcajce.JcaX509CertificateConverter;
import org.bouncycastle.cert.jcajce.JcaX509v3CertificateBuilder;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.operator.ContentSigner;
import org.bouncycastle.operator.OperatorCreationException;
import org.bouncycastle.operator.jcajce.JcaContentSignerBuilder;

public class ClassPathServer extends java.lang.Object
{
	private final static org.slf4j.Logger CLASS_LOGGER =org.slf4j.LoggerFactory.getLogger(ClassPathServer.class);
	private final static org.slf4j.Logger EXCEPTION_LOGGER =org.slf4j.LoggerFactory.getLogger("ExceptionCatcher");
	private final de.elbosso.util.ClassLoaderProvider classLoaderProvider;

    public ClassPathServer(de.elbosso.util.ClassLoaderProvider classLoaderProvider, int port)throws java.lang.Exception
    {
        super();
        this.classLoaderProvider=classLoaderProvider;
        
        HttpServer server = HttpServer.create(new InetSocketAddress(port), 0);

        server.createContext("/", new MyHandler());
        server.setExecutor(null); // creates a default executor
        server.start();
    }
    public ClassPathServer(de.elbosso.util.ClassLoaderProvider classLoaderProvider,int port,java.security.KeyStore ks, char[] passwd)throws java.lang.Exception
    {
        super();
        this.classLoaderProvider=classLoaderProvider;

        // setup the key manager factory
        KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
        kmf.init(ks, passwd);

        // setup the trust manager factory
        TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
        tmf.init(ks);

        // setup the HTTPS context and parameters
        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);

        HttpsServer server = HttpsServer.create(new InetSocketAddress(port), 0);

        server.setHttpsConfigurator(new HttpsConfigurator(sslContext) {
                public void configure(HttpsParameters params) {
                    try {
                        // initialise the SSL context
                        SSLContext context = getSSLContext();
                        SSLEngine engine = context.createSSLEngine();
                        params.setNeedClientAuth(false);
                        params.setCipherSuites(engine.getEnabledCipherSuites());
                        params.setProtocols(engine.getEnabledProtocols());

                        // Set the SSL parameters
                        SSLParameters sslParameters = context.getSupportedSSLParameters();
                        params.setSSLParameters(sslParameters);

                    } catch (Exception ex) {
                        EXCEPTION_LOGGER.error(ex.getMessage(), ex);
                    }
                }
            });

        server.createContext("/", new MyHandler());
        server.setExecutor(null); // creates a default executor
        server.start();
    }
    class MyHandler implements HttpHandler 
    {
        @Override
        public void handle(HttpExchange t) throws IOException 
        {
            CLASS_LOGGER.debug(t.getRequestURI().toString());
            try
            {
                java.lang.String resNm=t.getRequestURI().toString().substring(1);
                CLASS_LOGGER.debug("trying to fetch resource "+resNm);
                java.io.InputStream is=classLoaderProvider.getClassLoader().getResourceAsStream(resNm);
                java.io.ByteArrayOutputStream baos=new java.io.ByteArrayOutputStream();
                de.elbosso.util.io.Utilities.copyBetweenStreams(is,baos,true);
                t.sendResponseHeaders(200, baos.toByteArray().length);
                is=new java.io.ByteArrayInputStream(baos.toByteArray());
                de.elbosso.util.io.Utilities.copyBetweenStreams(is,t.getResponseBody(),false);
            }
            catch(java.lang.Throwable th)
            {
                EXCEPTION_LOGGER.error(th.getMessage(),th);
                String response = th.getMessage();
                t.sendResponseHeaders(404, response.length());
                OutputStream os = t.getResponseBody();
                os.write(response.getBytes());
            }
            t.getResponseBody().close();;
        }
    }
}