/*
    * 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.syncope.common.lib;
  
  import java.io.Serializable;
  import java.time.Duration;
  import org.apache.commons.lang3.StringUtils;
  
  public abstract class AbstractJDBCConf implements Serializable {
  
      private static final long serialVersionUID = 2675132530878660196L;
  
      /**
       * SQL query to execute. Example: {@code SELECT * FROM table WHERE name=?}.
       */
      private String sql;
  
      /**
       * The database dialect is a configuration setting for platform independent software (JPA, Hibernate, etc)
       * which allows such software to translate its generic SQL statements into vendor specific DDL, DML.
       */
      private String dialect = "org.hibernate.dialect.H2Dialect";
  
      /**
       * The JDBC driver used to connect to the database.
       */
      private String driverClass = "org.h2.Driver";
  
      /**
       * The database connection URL.
       */
      private String url = "jdbc:h2:tcp://localhost:9092/mem:authdb;DB_CLOSE_DELAY=-1";
  
      /**
       * The database user.
       * <p>
       * The database user must have sufficient permissions to be able to handle
       * schema changes and updates, when needed.
       */
      private String user = "sa";
  
      /**
       * The database connection password.
       */
      private String password = "sa";
  
      /**
       * Qualifies unqualified table names with the given catalog in generated SQL.
       */
      private String defaultCatalog;
  
      /**
       * Qualify unqualified table names with the given schema/tablespace in generated SQL.
       */
      private String defaultSchema;
  
      /**
       * The SQL query to be executed to test the validity of connections.
       * This is for "legacy" databases that do not support the JDBC4 {@code Connection.isValid()} API.
       */
      private String healthQuery = StringUtils.EMPTY;
  
      /**
       * Controls the maximum amount of time that a connection is allowed to sit idle in the pool.
       */
      private Duration idleTimeout = Duration.parse("PT10M");
  
      /**
       * Attempts to do a JNDI data source look up for the data source name specified.
       * Will attempt to locate the data source object as is.
       */
      private String dataSourceName;
  
      /**
       * Controls the minimum size that the pool is allowed
       * to reach, including both idle and in-use connections.
       */
      private int minPoolSize = 6;
  
      /**
       * Controls the maximum number of connections to keep
       * in the pool, including both idle and in-use connections.
       */
     private int maxPoolSize = 18;
 
     /**
      * Sets the maximum time in seconds that this data source will wait
      * while attempting to connect to a database.
      * A value of zero specifies that the timeout is the default system timeout
      * if there is one; otherwise, it specifies that there is no timeout.
      */
     private Duration maxPoolWait = Duration.parse("PT2S");
 
     /**
      * Whether or not pool suspension is allowed.
      * There is a performance impact when pool suspension is enabled.
      * Unless you need it (for a redundancy system for example) do not enable it.
      */
     private boolean poolSuspension;
 
     /**
      * The maximum number of milliseconds that the
      * pool will wait for a connection to be validated as alive.
      */
     private long poolTimeoutMillis = 1_000;
 
     /**
      * Controls the amount of time that a connection can be out of the pool before a message
      * is logged indicating a possible connection leak.
      */
     private int poolLeakThreshold = 3_000;
 
     public String getSql() {
         return sql;
     }
 
     public void setSql(final String sql) {
         this.sql = sql;
     }
 
     public String getDialect() {
         return dialect;
     }
 
     public void setDialect(final String dialect) {
         this.dialect = dialect;
     }
 
     public String getDriverClass() {
         return driverClass;
     }
 
     public void setDriverClass(final String driverClass) {
         this.driverClass = driverClass;
     }
 
     public String getUrl() {
         return url;
     }
 
     public void setUrl(final String url) {
         this.url = url;
     }
 
     public String getUser() {
         return user;
     }
 
     public void setUser(final String user) {
         this.user = user;
     }
 
     public String getPassword() {
         return password;
     }
 
     public void setPassword(final String password) {
         this.password = password;
     }
 
     public String getDefaultCatalog() {
         return defaultCatalog;
     }
 
     public void setDefaultCatalog(final String defaultCatalog) {
         this.defaultCatalog = defaultCatalog;
     }
 
     public String getDefaultSchema() {
         return defaultSchema;
     }
 
     public void setDefaultSchema(final String defaultSchema) {
         this.defaultSchema = defaultSchema;
     }
 
     public String getHealthQuery() {
         return healthQuery;
     }
 
     public void setHealthQuery(final String healthQuery) {
         this.healthQuery = healthQuery;
     }
 
     public Duration getIdleTimeout() {
         return idleTimeout;
     }
 
     public void setIdleTimeout(final Duration idleTimeout) {
         this.idleTimeout = idleTimeout;
     }
 
     public String getDataSourceName() {
         return dataSourceName;
     }
 
     public void setDataSourceName(final String dataSourceName) {
         this.dataSourceName = dataSourceName;
     }
 
     public int getMinPoolSize() {
         return minPoolSize;
     }
 
     public void setMinPoolSize(final int minPoolSize) {
         this.minPoolSize = minPoolSize;
     }
 
     public int getMaxPoolSize() {
         return maxPoolSize;
     }
 
     public void setMaxPoolSize(final int maxPoolSize) {
         this.maxPoolSize = maxPoolSize;
     }
 
     public Duration getMaxPoolWait() {
         return maxPoolWait;
     }
 
     public void setMaxPoolWait(final Duration maxPoolWait) {
         this.maxPoolWait = maxPoolWait;
     }
 
     public boolean isPoolSuspension() {
         return poolSuspension;
     }
 
     public void setPoolSuspension(final boolean poolSuspension) {
         this.poolSuspension = poolSuspension;
     }
 
     public long getPoolTimeoutMillis() {
         return poolTimeoutMillis;
     }
 
     public void setPoolTimeoutMillis(final long poolTimeoutMillis) {
         this.poolTimeoutMillis = poolTimeoutMillis;
     }
 
     public int getPoolLeakThreshold() {
         return poolLeakThreshold;
     }
 
     public void setPoolLeakThreshold(final int poolLeakThreshold) {
         this.poolLeakThreshold = poolLeakThreshold;
     }
 }