package com.atlassian.activeobjects.internal;
   
   import com.atlassian.activeobjects.spi.DatabaseType;
   import net.java.ao.DatabaseProvider;
   import net.java.ao.Disposable;
   import net.java.ao.DisposableDataSource;
   import net.java.ao.builder.DelegatingDisposableDataSourceHandler;
   import net.java.ao.db.ClientDerbyDatabaseProvider;
   import net.java.ao.db.EmbeddedDerbyDatabaseProvider;
  import net.java.ao.db.H2DatabaseProvider;
  import net.java.ao.db.HSQLDatabaseProvider;
  import net.java.ao.db.MsJdbcSQLServerDatabaseProvider;
  import net.java.ao.db.MySQLDatabaseProvider;
  import net.java.ao.db.NuoDBDatabaseProvider;
  import net.java.ao.db.NuoDBDisposableDataSourceHandler;
  import net.java.ao.db.OracleDatabaseProvider;
  import net.java.ao.db.PostgreSQLDatabaseProvider;
  import net.java.ao.db.SQLServerDatabaseProvider;
  
  import javax.sql.DataSource;
  
  import static com.atlassian.activeobjects.ao.ConverterUtils.toLowerCase;
  import static com.google.common.base.Preconditions.checkNotNull;
  
  public final class JdbcDriverDatabaseProviderFactory implements DatabaseProviderFactory {
      private final DriverNameExtractor driverNameExtractor;
  
      public JdbcDriverDatabaseProviderFactory(DriverNameExtractor driverNameExtractor) {
          this.driverNameExtractor = checkNotNull(driverNameExtractor);
      }
  
      public DatabaseProvider getDatabaseProvider(DataSource dataSource, DatabaseType databaseType, String schema) {
          final String driverName = getDriverName(dataSource);
          for (DatabaseProviderFactoryEnum dbProviderFactory : DatabaseProviderFactoryEnum.values()) {
              if (dbProviderFactory.accept(databaseType, driverName)) {
                  return dbProviderFactory.getDatabaseProvider(dataSource, schema);
              }
          }
          throw new DatabaseProviderNotFoundException(driverName);
      }
  
      private String getDriverName(DataSource dataSource) {
          return driverNameExtractor.getDriverName(dataSource);
      }
  
      /**
       * TODO fix, this is actually not tested and needs to be. This is possibly quite fragile as well, as I don't know
       * yet what happens to the driver name when using connection pooling, but I'd bet it changes to something that doesn't
       * give much information
       */
      private static enum DatabaseProviderFactoryEnum {
          MYSQL(DatabaseType.MYSQL, "mysql", false) {
              @Override
              public DatabaseProvider getDatabaseProvider(DataSource dataSource, String schema) {
                  return new MySQLDatabaseProvider(getDisposableDataSource(dataSource));
              }
          },
          DERBY_NETWORK(DatabaseType.DERBY_NETWORK, "derby", false) {
              @Override
              public DatabaseProvider getDatabaseProvider(DataSource dataSource, String schema) {
                  return new ClientDerbyDatabaseProvider(getDisposableDataSource(dataSource));
              }
          },
          DERBY_EMBEDDED(DatabaseType.DERBY_EMBEDDED, "derby", false) {
              @Override
              public DatabaseProvider getDatabaseProvider(DataSource dataSource, String schema) {
                  return new EmbeddedDerbyDatabaseProvider(getDisposableDataSource(dataSource), "a-fake-uri"); // TODO handle the URI issue
              }
          },
          ORACLE(DatabaseType.ORACLE, "oracle", false) {
              @Override
              public DatabaseProvider getDatabaseProvider(DataSource dataSource, String schema) {
                  return new OracleDatabaseProvider(getDisposableDataSource(dataSource), schema);
              }
          },
          POSTGRESQL(DatabaseType.POSTGRESQL, "postgres", false) {
              @Override
              public DatabaseProvider getDatabaseProvider(DataSource dataSource, String schema) {
                  return new PostgreSQLDatabaseProvider(getDisposableDataSource(dataSource), schema);
              }
          },
          MSSQL(DatabaseType.MS_SQL, "microsoft", true) {
              @Override
              public DatabaseProvider getDatabaseProvider(DataSource dataSource, String schema) {
                  return new MsJdbcSQLServerDatabaseProvider(getDisposableDataSource(dataSource), schema);
              }
          },
          MSSQL_JTDS(DatabaseType.MS_SQL, "jtds", true) {
              @Override
              public DatabaseProvider getDatabaseProvider(DataSource dataSource, String schema) {
                  return new SQLServerDatabaseProvider(getDisposableDataSource(dataSource), schema);
              }
          },
          HSQLDB(DatabaseType.HSQL, "hsql", false) {
              @Override
              public DatabaseProvider getDatabaseProvider(DataSource dataSource, String schema) {
                  return new HSQLDatabaseProvider(getDisposableDataSource(dataSource), schema);
              }
          },
         H2(DatabaseType.H2, "h2", false) {
             @Override
             public DatabaseProvider getDatabaseProvider(DataSource dataSource, String schema) {
                 return new H2DatabaseProvider(getDisposableDataSource(dataSource), schema);
             }
         },
         NUODB(DatabaseType.NUODB, "nuodb", false) {
             @Override
             public DatabaseProvider getDatabaseProvider(DataSource dataSource, String schema) {
                 return new NuoDBDatabaseProvider(NuoDBDisposableDataSourceHandler.newInstance(dataSource), schema);
             }
         };
 
         private final DatabaseType databaseType;
         private final String driverName;
         private final boolean needsDatabaseTypeAndDriverName;
 
         DatabaseProviderFactoryEnum(DatabaseType databaseType, String driverName, boolean needsDatabaseTypeAndDriverName) {
             this.databaseType = checkNotNull(databaseType);
             this.driverName = checkNotNull(driverName);
             this.needsDatabaseTypeAndDriverName = needsDatabaseTypeAndDriverName;
         }
 
         boolean accept(DatabaseType otherDatabaseType, String otherDriverName) {
             final boolean acceptDatabaseType = acceptDatabaseType(otherDatabaseType);
             final boolean acceptDriverName = acceptDriverName(otherDriverName);
             if (needsDatabaseTypeAndDriverName) {
                 return acceptDatabaseType && acceptDriverName;
             } else {
                 return acceptDatabaseType || acceptDriverName;
             }
         }
 
         private boolean acceptDatabaseType(DatabaseType otherDatabaseType) {
             return databaseType.equals(otherDatabaseType);
         }
 
         private boolean acceptDriverName(String otherDriverName) {
             return otherDriverName != null && toLowerCase(otherDriverName).contains(this.driverName);
         }
 
         // apparently useless, I know, but the compiler complains if not there
         public abstract DatabaseProvider getDatabaseProvider(DataSource dataSource, String schema);
     }
 
     private static DisposableDataSource getDisposableDataSource(final DataSource dataSource) {
         return DelegatingDisposableDataSourceHandler.newInstance(dataSource, new Disposable() {
             @Override
             public void dispose() {
             }
         });
     }
 }