package art.servers.controller;

import art.library.utils.resources.Resources;
import art.servers.Shared;
import art.servers.configuration.ConfigurationListenerHttp;
import com.sun.net.httpserver.HttpsConfigurator;
import com.sun.net.httpserver.HttpsParameters;
import com.sun.net.httpserver.HttpsServer;
import java.io.File;
import java.io.FileInputStream;
import java.net.InetSocketAddress;
import java.security.KeyStore;
import java.util.concurrent.Executors;
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;



public class ControllerListenerHttps extends ControllerListenerHttp
{
    // keytool -genkey -v -keystore x:\test\https\artic_key.keystore -alias artic -keyalg RSA -keysize 2048 -validity 10000 
    
    public ControllerListenerHttps(ConfigurationListenerHttp configuration)
    {
        super(configuration);
        this.name = Shared.getMessage("Listener https");
        this.setName(this.getClass().getName() + " : " + name);
    }
        
    
    public void run()
    {
        Shared.traceInformation(name, "Starting");

        while ((isInterrupted() == false) && (exit == false))
        {
            try
            {
                if (server == null)
                {
                    connect();
                }
                
                sleep(1000);
            }
            catch (Exception e)
            {
            }
        }
        
        Shared.traceInformation(name, "Finishing");
    }
    
    
    
    
    
    
    protected void connect()
    {
        try
        {
            // Setup the socket address
            
            InetSocketAddress address = new InetSocketAddress(configuration.port);

            // initialise the HTTPS server
            server = HttpsServer.create(address, 0);
            SSLContext sslContext = SSLContext.getInstance("TLS");
            
            // initialise the keystore
            char[] password = configuration.keystorePassword.toCharArray();
            KeyStore ks = KeyStore.getInstance("JKS");
            
            if ((new File(configuration.keystoreLocation)).exists() == true)
            {
                ks.load(new FileInputStream(configuration.keystoreLocation), password);
            }
            else
            {
                ks.load(Resources.getResourceStream(configuration.keystoreLocation), password);
            }

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

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


            // setup the HTTPS context and parameters
            
            sslContext.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
            
            ((HttpsServer)server).setHttpsConfigurator(new HttpsConfigurator(sslContext) 
            {
                public void configure(HttpsParameters params) 
                {
                    try 
                    {
                        // initialise the SSL context
                        SSLContext c = SSLContext.getDefault();
                        SSLEngine engine = c.createSSLEngine();
                        params.setNeedClientAuth(false);
                        params.setCipherSuites(engine.getEnabledCipherSuites());
                        params.setProtocols(engine.getEnabledProtocols());

                        // get the default parameters
                        SSLParameters defaultSSLParameters = c.getDefaultSSLParameters();
                        params.setSSLParameters(defaultSSLParameters);

                    } 
                    catch (Exception e) 
                    {
                    }
                }
            });

            
            contexts();
            server.setExecutor(Executors.newCachedThreadPool());
            server.start();    
            Shared.traceInformation(name, "Listening",  Shared.getMessage("Port") + " = " + configuration.port);
            return;
            
        }
        catch (Exception exception)
        {
            Shared.traceError(name, "Listening",  Shared.getMessage("Port") + " = " + configuration.port, exception);
        }        
        
    }
    
    
    

}