/*
    * This file is part of Waarp Project (named also Waarp or GG).
    *
    *  Copyright (c) 2019, Waarp SAS, and individual contributors by the @author
    *  tags. See the COPYRIGHT.txt in the distribution for a full listing of
    * individual contributors.
    *
    *  All Waarp Project is free software: you can redistribute it and/or
    * modify it under the terms of the GNU General Public License as published by
   * the Free Software Foundation, either version 3 of the License, or (at your
   * option) any later version.
   *
   * Waarp is distributed in the hope that it will be useful, but WITHOUT ANY
   * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
   * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
   *
   *  You should have received a copy of the GNU General Public License along with
   * Waarp . If not, see <http://www.gnu.org/licenses/>.
   */
  package org.waarp.openr66.database.data;
  
  import com.fasterxml.jackson.core.Base64Variants;
  import com.fasterxml.jackson.databind.JsonNode;
  import com.fasterxml.jackson.databind.node.ArrayNode;
  import com.fasterxml.jackson.databind.node.ObjectNode;
  import org.waarp.common.database.DbConstant;
  import org.waarp.common.database.DbPreparedStatement;
  import org.waarp.common.database.DbSession;
  import org.waarp.common.database.exception.WaarpDatabaseException;
  import org.waarp.common.database.exception.WaarpDatabaseNoConnectionException;
  import org.waarp.common.database.exception.WaarpDatabaseNoDataException;
  import org.waarp.common.database.exception.WaarpDatabaseSqlException;
  import org.waarp.common.digest.FilesystemBasedDigest;
  import org.waarp.common.json.JsonHandler;
  import org.waarp.common.logging.WaarpLogger;
  import org.waarp.common.logging.WaarpLoggerFactory;
  import org.waarp.common.role.RoleDefault;
  import org.waarp.common.utility.ParametersChecker;
  import org.waarp.common.utility.WaarpStringUtils;
  import org.waarp.openr66.context.R66Session;
  import org.waarp.openr66.dao.AbstractDAO;
  import org.waarp.openr66.dao.DAOFactory;
  import org.waarp.openr66.dao.Filter;
  import org.waarp.openr66.dao.HostDAO;
  import org.waarp.openr66.dao.database.DBHostDAO;
  import org.waarp.openr66.dao.database.StatementExecutor;
  import org.waarp.openr66.dao.exception.DAOConnectionException;
  import org.waarp.openr66.dao.exception.DAONoDataException;
  import org.waarp.openr66.pojo.Host;
  import org.waarp.openr66.protocol.configuration.Configuration;
  import org.waarp.openr66.protocol.networkhandler.NetworkTransaction;
  
  import java.net.InetSocketAddress;
  import java.net.SocketAddress;
  import java.sql.SQLException;
  import java.sql.Types;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  /**
   * Host Authentication Table object
   */
  public class DbHostAuth extends AbstractDbDataDao<Host> {
    private static final String CHECKED = "checked";
  
    private static final String CANNOT_FIND_HOST = "Cannot find host";
  
    public static final String DEFAULT_CLIENT_ADDRESS = "0.0.0.0";
  
    /**
     * Internal Logger
     */
    private static final WaarpLogger logger =
        WaarpLoggerFactory.getLogger(DbHostAuth.class);
    private static final byte[] VALUE_0_BYTE = {};
    private static final DbHostAuth[] DBHOSTAUTH_0_SIZE = new DbHostAuth[0];
    private static final Pattern BACKSLASH =
        Pattern.compile("\"", Pattern.LITERAL);
    private static final Pattern COMMA = Pattern.compile(",", Pattern.LITERAL);
  
    public enum Columns {
      ADDRESS, PORT, ISSSL, HOSTKEY, ADMINROLE, ISCLIENT, ISACTIVE, ISPROXIFIED,
      UPDATEDINFO, HOSTID
    }
  
    public static final int[] dbTypes = {
        Types.NVARCHAR, Types.INTEGER, Types.BIT, Types.VARBINARY, Types.BIT,
        Types.BIT, Types.BIT, Types.BIT, Types.INTEGER, Types.NVARCHAR
    };
  
    public static final String table = " HOSTS ";
  
    protected static final String selectAllFields =
        Columns.ADDRESS.name() + ',' + Columns.PORT.name() + ',' +
        Columns.ISSSL.name() + ',' + Columns.HOSTKEY.name() + ',' +
        Columns.ADMINROLE.name() + ',' + Columns.ISCLIENT.name() + ',' +
        Columns.ISACTIVE.name() + ',' + Columns.ISPROXIFIED.name() + ',' +
       Columns.UPDATEDINFO.name() + ',' + Columns.HOSTID.name();
 
   public static final Columns[] indexes = {
       Columns.UPDATEDINFO
   };
 
   @Override
   protected final void initObject() {
     //nothing
   }
 
   @Override
   protected final String getTable() {
     return table;
   }
 
   @Override
   protected final AbstractDAO<Host> getDao(final boolean isCacheable)
       throws DAOConnectionException {
     return DAOFactory.getInstance().getHostDAO(isCacheable);
   }
 
   @Override
   protected final String getPrimaryKey() {
     if (pojo != null) {
       return pojo.getHostid();
     }
     throw new IllegalArgumentException("pojo is null");
   }
 
   @Override
   protected final String getPrimaryField() {
     return Columns.HOSTID.name();
   }
 
   /**
    * @param hostid
    * @param address
    * @param port
    * @param isSSL
    * @param hostkey
    * @param adminrole
    * @param isClient
    */
   public DbHostAuth(final String hostid, final String address, final int port,
                     final boolean isSSL, final byte[] hostkey,
                     final boolean adminrole, final boolean isClient)
       throws WaarpDatabaseSqlException {
     pojo = new Host(hostid, address, port, hostkey, isSSL, isClient, false,
                     adminrole);
     if (hostkey != null) {
       try {
         // Save as crypted with the local Key and HEX
         pojo.setHostkey(
             Configuration.configuration.getCryptoKey().cryptToHex(hostkey)
                                        .getBytes(WaarpStringUtils.UTF8));
       } catch (final Exception e) {
         logger.warn("Error while cyphering hostkey" + " : {}", e.getMessage());
         pojo.setHostkey(VALUE_0_BYTE);
       }
     }
     if (port < 0) {
       pojo.setClient(true);
       pojo.setAddress(DEFAULT_CLIENT_ADDRESS);
     }
     checkValues();
     isSaved = false;
   }
 
   private DbHostAuth(final Host host) {
     if (host == null) {
       throw new IllegalArgumentException(
           "Argument in constructor cannot be null");
     }
     this.pojo = host;
   }
 
   public DbHostAuth(final ObjectNode source) throws WaarpDatabaseSqlException {
     pojo = new Host();
     setFromJson(source, false);
   }
 
   @Override
   protected final void checkValues() throws WaarpDatabaseSqlException {
     pojo.checkValues();
   }
 
   @Override
   public final void setFromJson(final ObjectNode node,
                                 final boolean ignorePrimaryKey)
       throws WaarpDatabaseSqlException {
     super.setFromJson(node, ignorePrimaryKey);
     if (pojo.getHostkey() == null || pojo.getHostkey().length == 0 ||
         ParametersChecker.isEmpty(pojo.getAddress()) ||
         ParametersChecker.isEmpty(pojo.getHostid())) {
       throw new WaarpDatabaseSqlException(
           "Not enough argument to create the object");
     }
     if (pojo.getHostkey() != null) {
       try {
         // Save as crypted with the local Key and Base64
         pojo.setHostkey(Configuration.configuration.getCryptoKey().cryptToHex(
             pojo.getHostkey()).getBytes(WaarpStringUtils.UTF8));
       } catch (final Exception e) {
         pojo.setHostkey(VALUE_0_BYTE);
       }
       isSaved = false;
     }
     if (pojo.getPort() < 0) {
       pojo.setClient(true);
       pojo.setAddress(DEFAULT_CLIENT_ADDRESS);
       isSaved = false;
     }
     if (!ignorePrimaryKey) {
       try {
         insert();
       } catch (final WaarpDatabaseException e) {
         try {
           update();
         } catch (final WaarpDatabaseException ex) {
           logger.error("Cannot save item: {}", ex.getMessage());
         }
       }
     }
   }
 
   @Override
   protected final void setFromJson(final String field, final JsonNode value) {
     if (value == null) {
       return;
     }
     for (final Columns column : Columns.values()) {
       if (column.name().equalsIgnoreCase(field)) {
         switch (column) {
           case ADDRESS:
             pojo.setAddress(value.asText());
             break;
           case ADMINROLE:
             pojo.setAdmin(value.asBoolean());
             break;
           case HOSTKEY:
             // Change from Base64 to Byte for HostKey
             try {
               final byte[] key =
                   Base64Variants.getDefaultVariant().decode(value.asText());
               pojo.setHostkey(key);
             } catch (final IllegalArgumentException e) {
               logger.warn("HostKey not in Base64 from Jackson: {}",
                           e.getMessage());
               pojo.setHostkey(value.asText().getBytes(WaarpStringUtils.UTF8));
             }
             break;
           case ISACTIVE:
             pojo.setActive(value.asBoolean());
             break;
           case ISCLIENT:
             pojo.setClient(value.asBoolean());
             break;
           case ISPROXIFIED:
             pojo.setProxified(value.asBoolean());
             break;
           case ISSSL:
             pojo.setSSL(value.asBoolean());
             break;
           case PORT:
             pojo.setPort(value.asInt());
             break;
           case UPDATEDINFO:
             pojo.setUpdatedInfo(
                 org.waarp.openr66.pojo.UpdatedInfo.valueOf(value.asInt()));
             break;
           case HOSTID:
             pojo.setHostid(value.asText());
             break;
         }
       }
     }
   }
 
   /**
    * @param hostid
    *
    * @throws WaarpDatabaseException
    */
   public DbHostAuth(final String hostid) throws WaarpDatabaseException {
     if (hostid == null) {
       throw new WaarpDatabaseException("No host id passed");
     }
     HostDAO hostAccess = null;
     try {
       hostAccess = DAOFactory.getInstance().getHostDAO(true);
       pojo = hostAccess.select(hostid);
     } catch (final DAOConnectionException e) {
       throw new WaarpDatabaseException(e);
     } catch (final DAONoDataException e) {
       throw new WaarpDatabaseNoDataException(CANNOT_FIND_HOST, e);
     } finally {
       DAOFactory.closeDAO(hostAccess);
     }
   }
 
   /**
    * Delete all entries (used when purge and reload)
    *
    * @return the previous existing array of DbRule
    *
    * @throws WaarpDatabaseException
    */
   public static DbHostAuth[] deleteAll() throws WaarpDatabaseException {
     HostDAO hostAccess = null;
     final List<DbHostAuth> res = new ArrayList<DbHostAuth>();
     List<Host> hosts;
     try {
       hostAccess = DAOFactory.getInstance().getHostDAO(false);
       hosts = hostAccess.getAll();
       hostAccess.deleteAll();
     } catch (final DAOConnectionException e) {
       throw new WaarpDatabaseException(e);
     } finally {
       DAOFactory.closeDAO(hostAccess);
     }
     for (final Host host : hosts) {
       final DbHostAuth hostAuth = new DbHostAuth(host);
       hostAuth.isSaved = false;
       res.add(hostAuth);
     }
     return res.toArray(new DbHostAuth[0]);
   }
 
   /**
    * Private constructor for Commander only
    */
   private DbHostAuth() {
     pojo = new Host();
   }
 
   /**
    * Get All DbHostAuth from database or from internal hashMap in case of no
    * database support
    *
    * @return the array of DbHostAuth
    *
    * @throws WaarpDatabaseNoConnectionException
    * @throws WaarpDatabaseSqlException
    */
   public static DbHostAuth[] getAllHosts()
       throws WaarpDatabaseNoConnectionException {
     HostDAO hostAccess = null;
     final List<DbHostAuth> res = new ArrayList<DbHostAuth>();
     List<Host> hosts;
     try {
       hostAccess = DAOFactory.getInstance().getHostDAO(false);
       hosts = hostAccess.getAll();
     } catch (final DAOConnectionException e) {
       throw new WaarpDatabaseNoConnectionException(e);
     } finally {
       DAOFactory.closeDAO(hostAccess);
     }
     for (final Host host : hosts) {
       final DbHostAuth dbHostAuth = new DbHostAuth(host);
       dbHostAuth.isSaved = true;
       res.add(dbHostAuth);
     }
     return res.toArray(DBHOSTAUTH_0_SIZE);
   }
 
   /**
    * For instance from Commander when getting updated information
    *
    * @param preparedStatement
    *
    * @return the next updated DbHostAuth
    *
    * @throws WaarpDatabaseNoConnectionException
    * @throws WaarpDatabaseSqlException
    */
   public static DbHostAuth getFromStatement(
       final DbPreparedStatement preparedStatement)
       throws WaarpDatabaseNoConnectionException, WaarpDatabaseSqlException {
     final DbHostAuth dbHostAuth = new DbHostAuth();
     AbstractDAO<Host> hostDAO = null;
     try {
       hostDAO = dbHostAuth.getDao(false);
       dbHostAuth.pojo = ((StatementExecutor<Host>) hostDAO).getFromResultSet(
           preparedStatement.getResultSet());
       return dbHostAuth;
     } catch (final SQLException e) {
       DbConstant.error(e);
       throw new WaarpDatabaseSqlException("Getting values in error", e);
     } catch (final DAOConnectionException e) {
       throw new WaarpDatabaseSqlException("Getting values in error", e);
     } finally {
       DAOFactory.closeDAO(hostDAO);
     }
   }
 
   public static DbHostAuth[] getUpdatedPreparedStatement()
       throws WaarpDatabaseNoConnectionException {
     final List<Filter> filters = new ArrayList<Filter>(1);
     filters.add(new Filter(DBHostDAO.UPDATED_INFO_FIELD, "=",
                            org.waarp.openr66.pojo.UpdatedInfo.fromLegacy(
                                UpdatedInfo.TOSUBMIT).ordinal()));
     HostDAO hostAccess = null;
     List<Host> hosts;
     try {
       hostAccess = DAOFactory.getInstance().getHostDAO(false);
       hosts = hostAccess.find(filters);
     } catch (final DAOConnectionException e) {
       throw new WaarpDatabaseNoConnectionException(e);
     } finally {
       DAOFactory.closeDAO(hostAccess);
     }
     final DbHostAuth[] res = new DbHostAuth[hosts.size()];
     int i = 0;
     for (final Host host : hosts) {
       res[i] = new DbHostAuth(host);
       i++;
     }
     return res;
   }
 
   /**
    * @param session
    * @param host
    * @param addr
    * @param ssl
    * @param active
    *
    * @return the DbPreparedStatement according to the filter
    *
    * @throws WaarpDatabaseNoConnectionException
    * @throws WaarpDatabaseSqlException
    */
   public static DbPreparedStatement getFilterPrepareStament(
       final DbSession session, final String host, final String addr,
       final boolean ssl, final boolean active)
       throws WaarpDatabaseNoConnectionException, WaarpDatabaseSqlException {
     final DbPreparedStatement preparedStatement =
         new DbPreparedStatement(session);
     final String request =
         "SELECT " + selectAllFields + " FROM " + table + " WHERE ";
     String condition = null;
     if (ParametersChecker.isNotEmpty(host)) {
       condition = Columns.HOSTID.name() + " = '" + host + "' ";
     }
     if (ParametersChecker.isNotEmpty(addr)) {
       if (condition != null) {
         condition += " AND ";
       } else {
         condition = "";
       }
       condition += Columns.ADDRESS.name() + " = '" + addr + "' ";
     }
     if (condition != null) {
       condition += " AND ";
     } else {
       condition = "";
     }
     condition += Columns.ISSSL.name() + " = ? AND ";
     condition += Columns.ISACTIVE.name() + " = ? ";
     preparedStatement.createPrepareStatement(
         request + condition + " ORDER BY " + Columns.HOSTID.name());
     try {
       preparedStatement.getPreparedStatement().setBoolean(1, ssl);
       preparedStatement.getPreparedStatement().setBoolean(2, active);
     } catch (final SQLException e) {
       preparedStatement.realClose();
       throw new WaarpDatabaseSqlException(e);
     }
     return preparedStatement;
   }
 
   /**
    * @param session
    * @param host
    * @param addr
    *
    * @return the DbPreparedStatement according to the filter
    *
    * @throws WaarpDatabaseNoConnectionException
    * @throws WaarpDatabaseSqlException
    */
   public static DbPreparedStatement getFilterPrepareStament(
       final DbSession session, final String host, final String addr)
       throws WaarpDatabaseNoConnectionException, WaarpDatabaseSqlException {
     final DbPreparedStatement preparedStatement =
         new DbPreparedStatement(session);
     final String request = "SELECT " + selectAllFields + " FROM " + table;
     String condition = null;
     if (ParametersChecker.isNotEmpty(host)) {
       condition = Columns.HOSTID.name() + " = '" + host + "' ";
     }
     if (ParametersChecker.isNotEmpty(addr)) {
       if (condition != null) {
         condition += " AND ";
       } else {
         condition = "";
       }
       condition += Columns.ADDRESS.name() + " = '" + addr + "' ";
     }
     if (condition != null) {
       condition = " WHERE " + condition;
     } else {
       condition = "";
     }
     preparedStatement.createPrepareStatement(
         request + condition + " ORDER BY " + Columns.HOSTID.name());
     return preparedStatement;
   }
 
   @Override
   public final void changeUpdatedInfo(final UpdatedInfo info) {
     isSaved = false;
     pojo.setUpdatedInfo(org.waarp.openr66.pojo.UpdatedInfo.fromLegacy(info));
   }
 
   /**
    * @return the isActive
    */
   public final boolean isActive() {
     return pojo.isActive();
   }
 
   /**
    * @param isActive the isActive to set
    */
   public final void setActive(final boolean isActive) {
     isSaved = false;
     pojo.setActive(isActive);
   }
 
   /**
    * @return the isProxified
    */
   public final boolean isProxified() {
     return pojo.isProxified();
   }
 
   /**
    * @param isProxified the isProxified to set
    */
   public final void setProxified(final boolean isProxified) {
     isSaved = false;
     pojo.setProxified(isProxified);
   }
 
   /**
    * Is the given key a valid one
    *
    * @param newkey
    *
    * @return True if the key is valid (or any key is valid)
    */
   public final boolean isKeyValid(final byte[] newkey) {
     // It is valid to not have a key
     // Check before if any key is passed or if account is active
     if (pojo.getHostkey() == null) {
       return true;
     }
     // Check before if any key is passed or if account is active
     if (newkey == null || !isActive()) {
       return false;
     }
     try {
       return FilesystemBasedDigest.equalPasswd(
           Configuration.configuration.getCryptoKey()
                                      .decryptHexInBytes(pojo.getHostkey()),
           newkey);
     } catch (final Exception e) {
       logger.info("Error while checking key", e);
       return false;
     }
   }
 
   /**
    * @return the hostkey
    */
   public final byte[] getHostkey() {
     if (pojo.getHostkey() == null) {
       return null;
     }
     try {
       return Configuration.configuration.getCryptoKey()
                                         .decryptHexInBytes(pojo.getHostkey());
     } catch (final Exception e) {
       logger.info("Error while checking key", e);
       return VALUE_0_BYTE;
     }
   }
 
   /**
    * @return the adminrole
    */
   public final boolean isAdminrole() {
     return pojo.isAdmin();
   }
 
   /**
    * Test if the address is 0.0.0.0 for a client or isClient
    *
    * @return True if the address is a client address (0.0.0.0) or isClient
    */
   public final boolean isClient() {
     return pojo.isClient() || isNoAddress();
   }
 
   /**
    * True if the address is a client address (0.0.0.0) or if the port is < 0
    *
    * @return True if the address is a client address (0.0.0.0) or if the port
    *     is < 0
    */
   public final boolean isNoAddress() {
     return pojo.getAddress().equals(DEFAULT_CLIENT_ADDRESS) ||
            pojo.getPort() < 0;
   }
 
   /**
    * @return the SocketAddress from the address and port
    *
    * @throws IllegalArgumentException when the address is for a Client
    *     and
    *     therefore cannot be checked
    */
   public final SocketAddress getSocketAddress()
       throws IllegalArgumentException {
     if (isNoAddress()) {
       throw new IllegalArgumentException("Not a server");
     }
     return new InetSocketAddress(pojo.getAddress(), pojo.getPort());
   }
 
   /**
    * @return True if this Host ref is with SSL support
    */
   public final boolean isSsl() {
     return pojo.isSSL();
   }
 
   /**
    * @return the hostid
    */
   public final String getHostid() {
     return pojo.getHostid();
   }
 
   /**
    * @return the address
    */
   public final String getAddress() {
     return pojo.getAddress();
   }
 
   /**
    * @return the port
    */
   public final int getPort() {
     return pojo.getPort();
   }
 
   private static String getVersion(final String host) {
     String remoteHost = host;
     String alias = "";
     if (Configuration.configuration.getAliases().containsKey(remoteHost)) {
       remoteHost = Configuration.configuration.getAliases().get(remoteHost);
       alias += "(Alias: " + remoteHost + ") ";
     }
     if (Configuration.configuration.getReverseAliases()
                                    .containsKey(remoteHost)) {
       final StringBuilder alias2 = new StringBuilder("(ReverseAlias: ");
       final String[] list =
           Configuration.configuration.getReverseAliases().get(remoteHost);
       boolean found = false;
       for (final String string : list) {
         if (string.equals(host)) {
           continue;
         }
         found = true;
         alias2.append(string).append(' ');
       }
       if (found) {
         alias += alias2 + ") ";
       }
     }
     if (Configuration.configuration.getBusinessWhiteSet()
                                    .contains(remoteHost)) {
       alias += "(Business: Allowed) ";
     }
     if (Configuration.configuration.getRoles().containsKey(remoteHost)) {
       final RoleDefault item =
           Configuration.configuration.getRoles().get(remoteHost);
       alias += "(Role: " + item + ") ";
     }
     return alias +
            (Configuration.configuration.getVersions().containsKey(remoteHost)?
                Configuration.configuration.getVersions().get(remoteHost)
                                           .toString() : "Version Unknown");
   }
 
   @Override
   public final String toString() {
     return "HostAuth: " + getHostid() + " address: " + getAddress() + ':' +
            getPort() + " isSSL: " + isSsl() + " admin: " + isAdminrole() +
            " isClient: " + isClient() + " isActive: " + isActive() +
            " isProxified: " + isProxified() + " (" +
            (pojo.getHostkey() != null? pojo.getHostkey().length : 0) +
            ") Version: " + getVersion(getHostid());
   }
 
   /**
    * Write selected DbHostAuth to a Json String
    *
    * @param preparedStatement
    *
    * @return the associated Json String
    *
    * @throws WaarpDatabaseNoConnectionException
    * @throws WaarpDatabaseSqlException
    */
   public static String getJson(final DbPreparedStatement preparedStatement,
                                final int limit)
       throws WaarpDatabaseNoConnectionException, WaarpDatabaseSqlException {
     final ArrayNode arrayNode = JsonHandler.createArrayNode();
     try {
       preparedStatement.executeQuery();
       int nb = 0;
       while (preparedStatement.getNext()) {
         final DbHostAuth host = getFromStatement(preparedStatement);
         final ObjectNode node = host.getInternalJson();
         arrayNode.add(node);
         nb++;
         if (nb >= limit) {
           break;
         }
       }
     } finally {
       preparedStatement.realClose();
     }
     return JsonHandler.writeAsString(arrayNode);
   }
 
   private ObjectNode getInternalJson() {
     final ObjectNode node = getJson();
     try {
       node.put(Columns.HOSTKEY.name(),
                new String(getHostkey(), WaarpStringUtils.UTF8));
     } catch (final Exception e1) {
       node.put(Columns.HOSTKEY.name(), "");
     }
     int nb;
     try {
       nb = NetworkTransaction.nbAttachedConnection(getSocketAddress(),
                                                    getHostid());
     } catch (final Exception e) {
       nb = -1;
     }
     node.put("Connection", nb);
     node.put("Version", COMMA.matcher(BACKSLASH.matcher(getVersion(getHostid()))
                                                .replaceAll(
                                                    Matcher.quoteReplacement(
                                                        "")))
                              .replaceAll(Matcher.quoteReplacement(", ")));
     return node;
   }
 
   /**
    * @return the Json string for this
    */
   public final String getJsonAsString() {
     final ObjectNode node = getInternalJson();
     return JsonHandler.writeAsString(node);
   }
 
   /**
    * @param session
    * @param body
    * @param crypted True if the Key is kept crypted, False it will be
    *     in
    *     clear form
    *
    * @return the runner in Html format specified by body by replacing all
    *     instance of fields
    */
   public final String toSpecializedHtml(final R66Session session,
                                         final String body,
                                         final boolean crypted) {
     final StringBuilder builder = new StringBuilder(body);
     WaarpStringUtils.replace(builder, "XXXHOSTXXX", getHostid());
     WaarpStringUtils.replace(builder, "XXXADDRXXX", getAddress());
     WaarpStringUtils.replace(builder, "XXXPORTXXX",
                              Integer.toString(getPort()));
     if (crypted) {
       WaarpStringUtils.replace(builder, "XXXKEYXXX",
                                new String(getHostkey(), WaarpStringUtils.UTF8));
     } else {
       try {
         WaarpStringUtils.replace(builder, "XXXKEYXXX", new String(getHostkey(),
                                                                   WaarpStringUtils.UTF8));
       } catch (final Exception e) {
         WaarpStringUtils.replace(builder, "XXXKEYXXX", "BAD DECRYPT");
       }
     }
     WaarpStringUtils.replace(builder, "XXXSSLXXX", isSsl()? CHECKED : "");
     WaarpStringUtils.replace(builder, "XXXADMXXX", isAdminrole()? CHECKED : "");
     WaarpStringUtils.replace(builder, "XXXISCXXX", isClient()? CHECKED : "");
     WaarpStringUtils.replace(builder, "XXXISAXXX", isActive()? CHECKED : "");
     WaarpStringUtils.replace(builder, "XXXISPXXX", isProxified()? CHECKED : "");
     WaarpStringUtils.replace(builder, "XXXVERSIONXXX",
                              COMMA.matcher(getVersion(getHostid()))
                                   .replaceAll(Matcher.quoteReplacement(", ")));
     int nb;
     try {
       nb = NetworkTransaction.nbAttachedConnection(getSocketAddress(),
                                                    getHostid());
     } catch (final Exception e) {
       nb = -1;
     }
     WaarpStringUtils.replace(builder, "XXXCONNXXX",
                              nb > 0? "(" + nb + " Connected) " : "");
     return builder.toString();
   }
 
   /**
    * @return True if any of the server has the isProxified property
    */
   public static boolean hasProxifiedHosts() {
     final List<Filter> filters = new ArrayList<Filter>();
     filters.add(new Filter(DBHostDAO.IS_PROXIFIED_FIELD, "=", true));
 
     HostDAO hostAccess = null;
     try {
       hostAccess = DAOFactory.getInstance().getHostDAO(false);
       return hostAccess.count(filters) > 0;
     } catch (final DAOConnectionException e) {
       logger.error("DAO Access error", e);
       return false;
     } finally {
       DAOFactory.closeDAO(hostAccess);
     }
   }
 }