/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements. See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You 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 org.apache.logging.log4j.core.appender.db.jdbc;
  
  import java.io.StringReader;
  import java.sql.Clob;
  import java.sql.Connection;
  import java.sql.DatabaseMetaData;
  import java.sql.NClob;
  import java.sql.PreparedStatement;
  import java.sql.SQLException;
  import java.sql.Timestamp;
  import java.sql.Types;
  import java.util.ArrayList;
  import java.util.Date;
  import java.util.List;
  
  import org.apache.logging.log4j.core.LogEvent;
  import org.apache.logging.log4j.core.appender.AppenderLoggingException;
  import org.apache.logging.log4j.core.appender.ManagerFactory;
  import org.apache.logging.log4j.core.appender.db.AbstractDatabaseManager;
  import org.apache.logging.log4j.core.appender.db.ColumnMapping;
  import org.apache.logging.log4j.core.config.plugins.convert.DateTypeConverter;
  import org.apache.logging.log4j.core.config.plugins.convert.TypeConverters;
  import org.apache.logging.log4j.core.util.Closer;
  import org.apache.logging.log4j.spi.ThreadContextMap;
  import org.apache.logging.log4j.spi.ThreadContextStack;
  import org.apache.logging.log4j.util.ReadOnlyStringMap;
  import org.apache.logging.log4j.util.Strings;
  
  /**
   * An {@link AbstractDatabaseManager} implementation for relational databases accessed via JDBC.
   */
  public final class JdbcDatabaseManager extends AbstractDatabaseManager {
  
      private static final JdbcDatabaseManagerFactory INSTANCE = new JdbcDatabaseManagerFactory();
  
      // NOTE: prepared statements are prepared in this order: column mappings, then column configs
      private final List<ColumnMapping> columnMappings;
      private final List<ColumnConfig> columnConfigs;
      private final ConnectionSource connectionSource;
      private final String sqlStatement;
  
      private Connection connection;
      private PreparedStatement statement;
      private boolean isBatchSupported;
  
      private JdbcDatabaseManager(final String name, final int bufferSize, final ConnectionSource connectionSource,
                                  final String sqlStatement, final List<ColumnConfig> columnConfigs,
                                  final List<ColumnMapping> columnMappings) {
          super(name, bufferSize);
          this.connectionSource = connectionSource;
          this.sqlStatement = sqlStatement;
          this.columnConfigs = columnConfigs;
          this.columnMappings = columnMappings;
      }
  
      @Override
      protected void startupInternal() throws Exception {
          this.connection = this.connectionSource.getConnection();
          final DatabaseMetaData metaData = this.connection.getMetaData();
          this.isBatchSupported = metaData.supportsBatchUpdates();
          Closer.closeSilently(this.connection);
      }
  
      @Override
      protected boolean shutdownInternal() {
          if (this.connection != null || this.statement != null) {
              return this.commitAndClose();
          }
          return true;
      }
  
      @Override
      protected void connectAndStart() {
          try {
              this.connection = this.connectionSource.getConnection();
              this.connection.setAutoCommit(false);
              this.statement = this.connection.prepareStatement(this.sqlStatement);
          } catch (final SQLException e) {
              throw new AppenderLoggingException(
                      "Cannot write logging event or flush buffer; JDBC manager cannot connect to the database.", e
              );
          }
      }
 
     @Override
     protected void writeInternal(final LogEvent event) {
         StringReader reader = null;
         try {
             if (!this.isRunning() || this.connection == null || this.connection.isClosed() || this.statement == null
                     || this.statement.isClosed()) {
                 throw new AppenderLoggingException(
                         "Cannot write logging event; JDBC manager not connected to the database.");
             }
 
             int i = 1;
             for (final ColumnMapping mapping : this.columnMappings) {
                 if (ThreadContextMap.class.isAssignableFrom(mapping.getType())
                     || ReadOnlyStringMap.class.isAssignableFrom(mapping.getType())) {
                     this.statement.setObject(i++, event.getContextData().toMap());
                 } else if (ThreadContextStack.class.isAssignableFrom(mapping.getType())) {
                     this.statement.setObject(i++, event.getContextStack().asList());
                 } else if (Date.class.isAssignableFrom(mapping.getType())) {
                     this.statement.setObject(i++,
                         DateTypeConverter.fromMillis(event.getTimeMillis(), mapping.getType().asSubclass(Date.class)));
                 } else if (Clob.class.isAssignableFrom(mapping.getType())) {
                     this.statement.setClob(i++, new StringReader(mapping.getLayout().toSerializable(event)));
                 } else if (NClob.class.isAssignableFrom(mapping.getType())) {
                     this.statement.setNClob(i++, new StringReader(mapping.getLayout().toSerializable(event)));
                 } else {
                     final Object value = TypeConverters.convert(mapping.getLayout().toSerializable(event),
                         mapping.getType(), null);
                     if (value == null) {
                         this.statement.setNull(i++, Types.NULL);
                     } else {
                         this.statement.setObject(i++, value);
                     }
                 }
             }
             for (final ColumnConfig column : this.columnConfigs) {
                 if (column.isEventTimestamp()) {
                     this.statement.setTimestamp(i++, new Timestamp(event.getTimeMillis()));
                 } else if (column.isClob()) {
                     reader = new StringReader(column.getLayout().toSerializable(event));
                     if (column.isUnicode()) {
                         this.statement.setNClob(i++, reader);
                     } else {
                         this.statement.setClob(i++, reader);
                     }
                 } else if (column.isUnicode()) {
                     this.statement.setNString(i++, column.getLayout().toSerializable(event));
                 } else {
                     this.statement.setString(i++, column.getLayout().toSerializable(event));
                 }
             }
 
             if (this.isBatchSupported) {
                 this.statement.addBatch();
             } else if (this.statement.executeUpdate() == 0) {
                 throw new AppenderLoggingException(
                         "No records inserted in database table for log event in JDBC manager.");
             }
         } catch (final SQLException e) {
             throw new AppenderLoggingException("Failed to insert record for log event in JDBC manager: " +
                     e.getMessage(), e);
         } finally {
             Closer.closeSilently(reader);
         }
     }
 
     @Override
     protected boolean commitAndClose() {
         boolean closed = true;
         try {
             if (this.connection != null && !this.connection.isClosed()) {
                 if (this.isBatchSupported) {
                     this.statement.executeBatch();
                 }
                 this.connection.commit();
             }
         } catch (final SQLException e) {
             throw new AppenderLoggingException("Failed to commit transaction logging event or flushing buffer.", e);
         } finally {
             try {
                 Closer.close(this.statement);
             } catch (final Exception e) {
                 logWarn("Failed to close SQL statement logging event or flushing buffer", e);
                 closed = false;
             } finally {
                 this.statement = null;
             }
 
             try {
                 Closer.close(this.connection);
             } catch (final Exception e) {
                 logWarn("Failed to close database connection logging event or flushing buffer", e);
                 closed = false;
             } finally {
                 this.connection = null;
             }
         }
         return closed;
     }
 
     /**
      * Creates a JDBC manager for use within the {@link JdbcAppender}, or returns a suitable one if it already exists.
      *
      * @param name The name of the manager, which should include connection details and hashed passwords where possible.
      * @param bufferSize The size of the log event buffer.
      * @param connectionSource The source for connections to the database.
      * @param tableName The name of the database table to insert log events into.
      * @param columnConfigs Configuration information about the log table columns.
      * @return a new or existing JDBC manager as applicable.
      * @deprecated use {@link #getManager(String, int, ConnectionSource, String, ColumnConfig[], ColumnMapping[])}
      */
     @Deprecated
     public static JdbcDatabaseManager getJDBCDatabaseManager(final String name, final int bufferSize,
                                                              final ConnectionSource connectionSource,
                                                              final String tableName,
                                                              final ColumnConfig[] columnConfigs) {
 
         return getManager(name,
             new FactoryData(bufferSize, connectionSource, tableName, columnConfigs, new ColumnMapping[0]),
             getFactory());
     }
 
     /**
      * Creates a JDBC manager for use within the {@link JdbcAppender}, or returns a suitable one if it already exists.
      *
      * @param name The name of the manager, which should include connection details and hashed passwords where possible.
      * @param bufferSize The size of the log event buffer.
      * @param connectionSource The source for connections to the database.
      * @param tableName The name of the database table to insert log events into.
      * @param columnConfigs Configuration information about the log table columns.
      * @param columnMappings column mapping configuration (including type conversion).
      * @return a new or existing JDBC manager as applicable.
      */
     public static JdbcDatabaseManager getManager(final String name,
                                                  final int bufferSize,
                                                  final ConnectionSource connectionSource,
                                                  final String tableName,
                                                  final ColumnConfig[] columnConfigs,
                                                  final ColumnMapping[] columnMappings) {
         return getManager(name, new FactoryData(bufferSize, connectionSource, tableName, columnConfigs, columnMappings),
             getFactory());
     }
 
     private static JdbcDatabaseManagerFactory getFactory() {
         return INSTANCE;
     }
 
     /**
      * Encapsulates data that {@link JdbcDatabaseManagerFactory} uses to create managers.
      */
     private static final class FactoryData extends AbstractDatabaseManager.AbstractFactoryData {
         private final ConnectionSource connectionSource;
         private final String tableName;
         private final ColumnConfig[] columnConfigs;
         private final ColumnMapping[] columnMappings;
 
         protected FactoryData(final int bufferSize, final ConnectionSource connectionSource, final String tableName,
                               final ColumnConfig[] columnConfigs, final ColumnMapping[] columnMappings) {
             super(bufferSize);
             this.connectionSource = connectionSource;
             this.tableName = tableName;
             this.columnConfigs = columnConfigs;
             this.columnMappings = columnMappings;
         }
     }
 
     /**
      * Creates managers.
      */
     private static final class JdbcDatabaseManagerFactory implements ManagerFactory<JdbcDatabaseManager, FactoryData> {
         @Override
         public JdbcDatabaseManager createManager(final String name, final FactoryData data) {
             final StringBuilder sb = new StringBuilder("INSERT INTO ").append(data.tableName).append(" (");
             // so this gets a little more complicated now that there are two ways to configure column mappings, but
             // both mappings follow the same exact pattern for the prepared statement
             for (final ColumnMapping mapping : data.columnMappings) {
                 sb.append(mapping.getName()).append(',');
             }
             for (final ColumnConfig config : data.columnConfigs) {
                 sb.append(config.getColumnName()).append(',');
             }
             // at least one of those arrays is guaranteed to be non-empty
             sb.setCharAt(sb.length() - 1, ')');
             sb.append(" VALUES (");
             final List<ColumnMapping> columnMappings = new ArrayList<>(data.columnMappings.length);
             for (final ColumnMapping mapping : data.columnMappings) {
                 if (Strings.isNotEmpty(mapping.getLiteralValue())) {
                     sb.append(mapping.getLiteralValue());
                 } else {
                     sb.append('?');
                     columnMappings.add(mapping);
                 }
                 sb.append(',');
             }
             final List<ColumnConfig> columnConfigs = new ArrayList<>(data.columnConfigs.length);
             for (final ColumnConfig config : data.columnConfigs) {
                 if (Strings.isNotEmpty(config.getLiteralValue())) {
                     sb.append(config.getLiteralValue());
                 } else {
                     sb.append('?');
                     columnConfigs.add(config);
                 }
                 sb.append(',');
             }
             // at least one of those arrays is guaranteed to be non-empty
             sb.setCharAt(sb.length() - 1, ')');
             final String sqlStatement = sb.toString();
 
             return new JdbcDatabaseManager(name, data.getBufferSize(), data.connectionSource, sqlStatement,
                 columnConfigs, columnMappings);
         }
     }
 
 }