content: /**
   * Copyright (C) 2010 EdgyTech LLC.
   *
   * 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 com.edgytech.umongo;
  
  import com.edgytech.swingfast.FormDialog;
  import com.mongodb.MongoClientOptions;
  import com.mongodb.MongoClientOptions;
  import com.mongodb.ReadPreference;
  import com.mongodb.WriteConcern;
  import java.io.IOException;
  import java.net.*;
  import javax.net.SocketFactory;
  import javax.net.ssl.SSLContext;
  import javax.net.ssl.SSLSocketFactory;
  import javax.net.ssl.TrustManager;
  import javax.net.ssl.X509TrustManager;
  
  /**
   *
   * @author antoine
   */
  public class ConnectDialog extends FormDialog {
  
      enum Item {
          name,
          uri,
          servers,
          connectionMode,
          databases,
          user,
          password,
          connectionsPerHost,
          blockingThreadMultiplier,
          maxWaitTime,
          socketType,
          connectTimeout,
          socketTimeout,
          safeWrites,
          secondaryReads,
          proxyType,
          proxyHost,
          proxyPort,
          proxyUser,
          proxyPassword
      }
  
      public ConnectDialog() {
          setEnumBinding(Item.values(), null);
      }
  
      MongoClientOptions getMongoClientOptions() {
          MongoClientOptions.Builder builder = MongoClientOptions.builder();
  //        moptions.connectionsPerHost = getIntFieldValue(Item.connectionsPerHost);
  //        moptions.threadsAllowedToBlockForConnectionMultiplier = getIntFieldValue(Item.blockingThreadMultiplier);
  //        moptions.maxWaitTime = getIntFieldValue(Item.maxWaitTime);
          builder.connectTimeout(getIntFieldValue(Item.connectTimeout));
          builder.socketTimeout(getIntFieldValue(Item.socketTimeout));
  //        moptions.autoConnectRetry = getBooleanFieldValue(Item.autoConnectRetry);
          if (!getBooleanFieldValue(Item.safeWrites)) {
              builder.writeConcern(WriteConcern.NONE);
          }
          
  //        moptions.slaveOk = getBooleanFieldValue(Item.secondaryReads);
          if (getBooleanFieldValue(Item.secondaryReads)) {
              builder.readPreference(ReadPreference.secondaryPreferred());
          }
          
          int stype = getIntFieldValue(Item.socketType);
          int proxy = getIntFieldValue(Item.proxyType);
          if (proxy == 1) {
              // SOCKS proxy
              final String host = getStringFieldValue(Item.proxyHost);
              final int port = getIntFieldValue(Item.proxyPort);
              builder.socketFactory(new SocketFactory() {
  
                  @Override
                  public Socket createSocket() throws IOException {
                      SocketAddress addr = new InetSocketAddress(host, port);
                      Proxy proxy = new Proxy(Proxy.Type.SOCKS, addr);
                      Socket socket = new Socket(proxy);
                      return socket;
                  }
  
                  @Override
                  public Socket createSocket(String string, int i) throws IOException, UnknownHostException {
                      SocketAddress addr = new InetSocketAddress(host, port);
                      Proxy proxy = new Proxy(Proxy.Type.SOCKS, addr);
                      Socket socket = new Socket(proxy);
                      InetSocketAddress dest = new InetSocketAddress(string, i);
                      socket.connect(dest);
                      return socket;
                  }
  
                  @Override
                  public Socket createSocket(String string, int i, InetAddress ia, int i1) throws IOException, UnknownHostException {
                      throw new UnsupportedOperationException("Not supported yet.");
                  }
  
                  @Override
                  public Socket createSocket(InetAddress ia, int i) throws IOException {
                      SocketAddress addr = new InetSocketAddress(host, port);
                      Proxy proxy = new Proxy(Proxy.Type.SOCKS, addr);
                      Socket socket = new Socket(proxy);
                      InetSocketAddress dest = new InetSocketAddress(ia, i);
                      socket.connect(dest);
                      return socket;
                  }
  
                  @Override
                  public Socket createSocket(InetAddress ia, int i, InetAddress ia1, int i1) throws IOException {
                      throw new UnsupportedOperationException("Not supported yet.");
                  }
              });
  
  //            // authentication.. only supports 1 global for all proxies :(
  //            final String user = getStringFieldValue(Item.proxyUser);
  //            final String pwd = getStringFieldValue(Item.proxyPassword);
  //            if (!user.isEmpty()) {
  //                Authenticator.setDefault(new Authenticator() {
  //                    @Override
  //                    protected PasswordAuthentication getPasswordAuthentication() {
  //                        PasswordAuthentication p = new PasswordAuthentication(user, pwd.toCharArray());
  //                        return p;
  //                    }
  //                });
  //            }
          }
          
          if (stype == 1) {
              builder.socketFactory(SSLSocketFactory.getDefault());
          } else if (stype == 2) {
              // Create a trust manager that does not validate certificate chains
              TrustManager[] trustAllCerts = new TrustManager[]{
                  new X509TrustManager() {
  
                      public java.security.cert.X509Certificate[] getAcceptedIssuers() {
                          return null;
                      }
  
                      public void checkClientTrusted(
                              java.security.cert.X509Certificate[] certs, String authType) {
                      }
  
                      public void checkServerTrusted(
                              java.security.cert.X509Certificate[] certs, String authType) {
                      }
                  }
              };
              try {
                  SSLContext sc = SSLContext.getInstance("SSL");
                  sc.init(null, trustAllCerts, new java.security.SecureRandom());
                  builder.socketFactory(sc.getSocketFactory());
              } catch (Exception e) {
              }
          }
  
          return builder.build();
      }
      
      void setName(String name) {
          setStringFieldValue(Item.name, name);
      }
      
      String getName() {
          return getStringFieldValue(Item.name);
      }
  }
  