/**
    * This file Copyright (c) 2017 Magnolia International
    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
    *
    *
    * This file is dual-licensed under both the Magnolia
    * Network Agreement and the GNU General Public License.
    * You may elect to use one or the other of these licenses.
    *
   * This file is distributed in the hope that it will be
   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
   * implied warranty of MERCHANTABILITY or FITNESS FOR A
   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
   * Redistribution, except as permitted by whichever of the GPL
   * or MNA you select, is prohibited.
   *
   * 1. For the GPL license (GPL), you can redistribute and/or
   * modify this file under the terms of the GNU General
   * Public License, Version 3, as published by the Free Software
   * Foundation.  You should have received a copy of the GNU
   * General Public License, Version 3 along with this program;
   * if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * 2. For the Magnolia Network Agreement (MNA), this file
   * and the accompanying materials are made available under the
   * terms of the MNA which accompanies this distribution, and
   * is available at http://www.magnolia-cms.com/mna.html
   *
   * Any modifications to this file must keep this entire header
   * intact.
   *
   */
  package info.magnolia.about.app;
  
  import info.magnolia.cms.beans.config.ServerConfiguration;
  import info.magnolia.cms.pddescriptor.ProductDescriptorExtractor;
  import info.magnolia.context.WebContext;
  import info.magnolia.init.MagnoliaConfigurationProperties;
  
  import java.io.File;
  import java.sql.Connection;
  import java.sql.DatabaseMetaData;
  import java.sql.DriverManager;
  import java.sql.PreparedStatement;
  import java.sql.ResultSet;
  import java.sql.SQLException;
  
  import javax.inject.Inject;
  import javax.inject.Provider;
  import javax.jcr.Repository;
  import javax.jcr.RepositoryException;
  import javax.naming.Context;
  import javax.naming.InitialContext;
  import javax.naming.NamingException;
  import javax.sql.DataSource;
  import javax.xml.parsers.DocumentBuilder;
  import javax.xml.parsers.DocumentBuilderFactory;
  import javax.xml.parsers.SAXParserFactory;
  import javax.xml.xpath.XPath;
  import javax.xml.xpath.XPathConstants;
  import javax.xml.xpath.XPathFactory;
  
  import org.apache.commons.lang3.StringUtils;
  import org.apache.jackrabbit.commons.JcrUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.w3c.dom.Document;
  import org.xml.sax.Attributes;
  import org.xml.sax.SAXException;
  import org.xml.sax.helpers.DefaultHandler;
  
  /**
   * Component for obtaining information about current installation and environment.
   */
  public class InstanceConfigurationProvider {
  
      private static final Logger log = LoggerFactory.getLogger(InstanceConfigurationProvider.class);
  
      private final Provider<WebContext> contextProvider;
      private final ProductDescriptorExtractor productDescriptorExtractor;
      private final MagnoliaConfigurationProperties magnoliaProperties;
      private final ServerConfiguration serverConfiguration;
  
      @Inject
      public InstanceConfigurationProvider(final Provider<WebContext> contextProvider,
              final ServerConfiguration serverConfiguration, final MagnoliaConfigurationProperties magnoliaProperties,
              final ProductDescriptorExtractor productDescriptorExtractor) {
          this.contextProvider = contextProvider;
          this.productDescriptorExtractor = productDescriptorExtractor;
          this.serverConfiguration = serverConfiguration;
          this.magnoliaProperties = magnoliaProperties;
      }
  
      protected String[] getConnectionString() {
          File config = null;
          // Assuming, the path to the repository-config.-file is configured
          // relative, starting with WEB-INF.
          // Otherwise, assuming it's an absolute path for this config. (See JIRA
         // MGNLUI-3163)
         String configuredPath = magnoliaProperties.getProperty("magnolia.repositories.jackrabbit.config");
         if (configuredPath != null) {
             if (configuredPath.startsWith("WEB-INF")) {
                 config = new File(magnoliaProperties.getProperty("magnolia.app.rootdir") + "/" + configuredPath);
             } else {
                 config = new File(configuredPath);
             }
         }
         // No special handling here if the config (file) is null or not
         // existing.
         // If the path is wrong or not set, Magnolia won't start up properly and
         // it won't be possible to launch the About-app.
 
         final String[] connectionString = new String[] { "", "", "" };
         try {
             DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
             DocumentBuilder builder = factory.newDocumentBuilder();
             Document doc = builder.parse(config);
             XPathFactory xPathfactory = XPathFactory.newInstance();
             XPath xpath = xPathfactory.newXPath();
             String url = (String) xpath.compile("/Repository/Workspace/PersistenceManager/param[@name='url']/@value")
                     .evaluate(doc, XPathConstants.STRING);
             if (StringUtils.isNotBlank(url)) {
                 connectionString[0] = url;
             } else {
                 connectionString[0] = (String) xpath.compile(
                         "/Repository/DataSources/DataSource/param[@name='url']/@value").evaluate(doc,
                         XPathConstants.STRING);
                 connectionString[1] = (String) xpath.compile(
                         "/Repository/DataSources/DataSource/param[@name='user']/@value").evaluate(doc,
                         XPathConstants.STRING);
                 connectionString[2] = (String) xpath.compile(
                         "/Repository/DataSources/DataSource/param[@name='password']/@value").evaluate(doc,
                         XPathConstants.STRING);
             }
         } catch (Exception e) {
             log.debug("Failed to obtain DB connection info with {}", e.getMessage(), e);
         }
         return connectionString;
     }
 
     protected String getRepositoryName() {
         String repoConfigPath = magnoliaProperties.getProperty("magnolia.repositories.config");
         File config = new File(magnoliaProperties.getProperty("magnolia.app.rootdir") + "/" + repoConfigPath);
         final String[] repoName = new String[1];
         try {
             SAXParserFactory.newInstance().newSAXParser().parse(config, new DefaultHandler() {
                 private boolean inRepo;
 
                 @Override
                 public void startElement(String uri, String localName, String qName, Attributes attributes)
                         throws SAXException {
                     super.startElement(uri, localName, qName, attributes);
                     if ("RepositoryMapping".equals(qName)) {
                         inRepo = true;
                     }
                     if (inRepo && "Map".equals(qName)) {
                         if ("config".equals(attributes.getValue("name"))) {
                             repoName[0] = attributes.getValue("repositoryName");
                         }
                     }
                 }
 
                 @Override
                 public void endElement(String uri, String localName, String qName) throws SAXException {
                     super.endElement(uri, localName, qName);
                     if ("RepositoryMapping".equals(localName)) {
                         inRepo = false;
                     }
                 }
             });
             return repoName[0];
         } catch (Exception e) {
             log.debug("Failed to obtain repository configuration info with {}", e.getMessage(), e);
         }
         return null;
     }
 
     protected String getRepositoryHome() {
         return magnoliaProperties.getProperty("magnolia.repositories.home");
     }
 
     private Connection getConnection() throws SQLException, NamingException {
         Connection connection = null;
         String connectionString[] = getConnectionString();
         String repoHome = getRepositoryHome();
         String repoName = getRepositoryName();
         connectionString[0] = StringUtils.replace(connectionString[0], "${wsp.home}", repoHome + "/" + repoName
                 + "/workspaces/default");
         if (connectionString[0].startsWith("jdbc:")) {
             // JDBC url
             connection = DriverManager.getConnection(connectionString[0], connectionString[1], connectionString[2]);
         } else if (connectionString[0].startsWith("java:")) {
             // JNDI url
             Context initialContext = new InitialContext();
             DataSource datasource = (DataSource) initialContext.lookup(connectionString[0]);
             if (datasource != null) {
                 connection = datasource.getConnection();
             } else {
                 log.debug("Failed to lookup datasource.");
             }
         }
         return connection;
     }
 
     private String getMySQLEngineInfo(Connection connection, String[] connectionString) {
         PreparedStatement statement = null;
         ResultSet resultSet = null;
         try {
             statement = connection.prepareStatement("SHOW TABLE STATUS FROM `"
                     + StringUtils.substringAfterLast(connectionString[0], "/") + "`;");
             resultSet = statement.executeQuery();
             if (resultSet.next()) {
                 String engine = resultSet.getString("Engine");
                 return " (" + engine + ")";
             }
         } catch (SQLException e) {
             // can't get extra info, oh well
         } finally {
             try {
                 if (resultSet != null) {
                     resultSet.close();
                 }
                 if (statement != null) {
                     statement.close();
                 }
             } catch (SQLException ignored) {
             }
         }
         return null;
     }
 
     public String getDatabase() {
         String dbInfo = null;
         Connection connection = null;
         try {
             connection = getConnection();
             if (connection != null) {
                 DatabaseMetaData meta = connection.getMetaData();
                 dbInfo = meta.getDatabaseProductName() + " " + meta.getDatabaseProductVersion();
                 if (dbInfo.toLowerCase().contains("mysql")) {
                     String engine = getMySQLEngineInfo(connection, getConnectionString());
                     if (engine != null) {
                         dbInfo += engine;
                     }
                 }
             }
         } catch (NamingException e) {
             log.debug("Failed obtain DB connection through JNDI with {}", e.getMessage(), e);
         } catch (SQLException e) {
             log.debug("Failed to read DB and driver info from connection with {}", e.getMessage(), e);
         } catch (IllegalArgumentException e) {
             log.debug("Failed to understand DB connection URL with {}", e.getMessage(), e);
         } finally {
             if (connection != null) {
                 try {
                     connection.close();
                 } catch (SQLException e) {
                     // ignore, nothing we can do
                 }
             }
         }
         return dbInfo;
     }
 
     public String getDatabaseDriver() {
         String dbDriverInfo = null;
         Connection connection = null;
         try {
             connection = getConnection();
             if (connection != null) {
                 DatabaseMetaData meta = connection.getMetaData();
                 dbDriverInfo = meta.getDriverName() + " " + meta.getDriverVersion();
             }
         } catch (NamingException e) {
             log.debug("Failed obtain DB connection through JNDI with {}", e.getMessage(), e);
         } catch (SQLException e) {
             log.debug("Failed to read DB and driver info from connection with {}", e.getMessage(), e);
         } catch (IllegalArgumentException e) {
             log.debug("Failed to understand DB connection URL with {}", e.getMessage(), e);
         } finally {
             if (connection != null) {
                 try {
                     connection.close();
                 } catch (SQLException e) {
                     // ignore, nothing we can do
                 }
             }
         }
         return dbDriverInfo;
     }
 
     public String getDatabaseVersion() {
         return null;
     }
 
     public String getJcrName() {
         try {
             Repository repo = JcrUtils.getRepository();
             return repo.getDescriptor("jcr.repository.name");
         } catch (RepositoryException e) {
             log.debug("JCR repository information is not available", e);
         }
         return null;
     }
 
     public String getJcrVersion() {
         try {
             Repository repo = JcrUtils.getRepository();
             return repo.getDescriptor("jcr.repository.version");
         } catch (RepositoryException e) {
             log.debug("JCR repository information is not available", e);
         }
         return null;
     }
 
     public String getMagnoliaVersion() {
         return productDescriptorExtractor.get(ProductDescriptorExtractor.VERSION_NUMBER);
     }
 
     public boolean isAdmin() {
         return serverConfiguration.isAdmin();
     }
 
     public String getOSName() {
         return magnoliaProperties.getProperty("os.name");
     }
 
     public String getOSVersion() {
         return magnoliaProperties.getProperty("os.version");
     }
 
     public String getOSArch() {
         return magnoliaProperties.getProperty("os.arch");
     }
 
     public String getJavaVendor() {
         return magnoliaProperties.getProperty("java.vendor");
     }
 
     public String getJavaVersion() {
         return magnoliaProperties.getProperty("java.version");
     }
 
     public String getJavaRuntimeVersion() {
         return magnoliaProperties.getProperty("java.runtime.version");
     }
 
     public String getApplicationServer() {
         return contextProvider.get().getServletContext().getServerInfo();
     }
 }