package liquibase.executor;
   
   import java.io.IOException;
   import java.io.Writer;
   import java.util.ArrayList;
   import java.util.List;
   import java.util.Map;
   
   import liquibase.database.Database;
  import liquibase.database.core.MSSQLDatabase;
  import liquibase.database.core.SybaseASADatabase;
  import liquibase.database.core.SybaseDatabase;
  import liquibase.exception.DatabaseException;
  import liquibase.servicelocator.LiquibaseService;
  import liquibase.sql.visitor.SqlVisitor;
  import liquibase.sqlgenerator.SqlGeneratorFactory;
  import liquibase.statement.CallableSqlStatement;
  import liquibase.statement.SqlStatement;
  import liquibase.statement.core.GetNextChangeSetSequenceValueStatement;
  import liquibase.statement.core.LockDatabaseChangeLogStatement;
  import liquibase.statement.core.RawSqlStatement;
  import liquibase.statement.core.SelectFromDatabaseChangeLogLockStatement;
  import liquibase.statement.core.UnlockDatabaseChangeLogStatement;
  import liquibase.util.StreamUtil;
  
  @LiquibaseService(skip = true)
  public class LoggingExecutor extends AbstractExecutor implements Executor {
  
      private Writer output;
      private Executor delegatedReadExecutor;
  
      public LoggingExecutor(Executor delegatedExecutor, Writer output, Database database) {
          this.output = output;
          this.delegatedReadExecutor = delegatedExecutor;
          setDatabase(database);
      }
  
      @Override
      public void execute(SqlStatement sql) throws DatabaseException {
          outputStatement(sql);
      }
  
      @Override
      public int update(SqlStatement sql) throws DatabaseException {
          if (sql instanceof LockDatabaseChangeLogStatement) {
              return 1;
          } else if (sql instanceof UnlockDatabaseChangeLogStatement) {
              return 1;
          }
  
          outputStatement(sql);
  
          return 0;
      }
  
      @Override
      public void execute(SqlStatement sql, List<SqlVisitor> sqlVisitors) throws DatabaseException {
          outputStatement(sql, sqlVisitors);
      }
  
      @Override
      public int update(SqlStatement sql, List<SqlVisitor> sqlVisitors) throws DatabaseException {
          outputStatement(sql, sqlVisitors);
          return 0;
      }
  
      @Override
      public Map call(CallableSqlStatement csc, List declaredParameters, List<SqlVisitor> sqlVisitors)
              throws DatabaseException {
          throw new DatabaseException("Do not know how to output callable statement");
      }
  
      @Override
      public void comment(String message) throws DatabaseException {
          try {
              output.write(database.getLineComment());
              output.write(" ");
              output.write(message);
              output.write(StreamUtil.getLineSeparator());
          } catch (IOException e) {
              throw new DatabaseException(e);
          }
      }
  
      private void outputStatement(SqlStatement sql) throws DatabaseException {
          outputStatement(sql, new ArrayList<SqlVisitor>());
      }
  
      private void outputStatement(SqlStatement sql, List<SqlVisitor> sqlVisitors) throws DatabaseException {
          try {
              if (SqlGeneratorFactory.getInstance().requiresCurrentDatabaseMetadata(sql, database)) {
                  throw new DatabaseException(sql.getClass().getSimpleName()
                          + " requires access to up to date database metadata which is not available in SQL output mode");
              }
              for (String statement : applyVisitors(sql, sqlVisitors)) {
                  if (statement == null) {
                      continue;
                  }
                  output.write(statement);
 
                 if (database instanceof MSSQLDatabase || database instanceof SybaseDatabase
                         || database instanceof SybaseASADatabase) {
                     output.write(StreamUtil.getLineSeparator());
                     output.write("GO");
                     // } else if (database instanceof OracleDatabase) {
                     // output.write(StreamUtil.getLineSeparator());
                     // output.write("/");
                 } else {
                     String endDelimiter = ";";
                     if (sql instanceof RawSqlStatement) {
                         endDelimiter = ((RawSqlStatement) sql).getEndDelimiter();
                     }
                     if (!statement.endsWith(endDelimiter)) {
                         output.write(endDelimiter);
                     }
                 }
                 output.write(StreamUtil.getLineSeparator());
                 output.write(StreamUtil.getLineSeparator());
             }
         } catch (IOException e) {
             throw new DatabaseException(e);
         }
     }
 
     @Override
     public Object queryForObject(SqlStatement sql, Class requiredType) throws DatabaseException {
         if (sql instanceof SelectFromDatabaseChangeLogLockStatement) {
             return false;
         }
         return delegatedReadExecutor.queryForObject(sql, requiredType);
     }
 
     @Override
     public Object queryForObject(SqlStatement sql, Class requiredType, List<SqlVisitor> sqlVisitors)
             throws DatabaseException {
         return delegatedReadExecutor.queryForObject(sql, requiredType, sqlVisitors);
     }
 
     @Override
     public long queryForLong(SqlStatement sql) throws DatabaseException {
         return delegatedReadExecutor.queryForLong(sql);
     }
 
     @Override
     public long queryForLong(SqlStatement sql, List<SqlVisitor> sqlVisitors) throws DatabaseException {
         return delegatedReadExecutor.queryForLong(sql, sqlVisitors);
     }
 
     @Override
     public int queryForInt(SqlStatement sql) throws DatabaseException {
         try {
             return delegatedReadExecutor.queryForInt(sql);
         } catch (DatabaseException e) {
             if (sql instanceof GetNextChangeSetSequenceValueStatement) { // table probably does not exist
                 return 0;
             }
             throw e;
         }
     }
 
     @Override
     public int queryForInt(SqlStatement sql, List<SqlVisitor> sqlVisitors) throws DatabaseException {
         return delegatedReadExecutor.queryForInt(sql, sqlVisitors);
     }
 
     @Override
     public List queryForList(SqlStatement sql, Class elementType) throws DatabaseException {
         return delegatedReadExecutor.queryForList(sql, elementType);
     }
 
     @Override
     public List queryForList(SqlStatement sql, Class elementType, List<SqlVisitor> sqlVisitors)
             throws DatabaseException {
         return delegatedReadExecutor.queryForList(sql, elementType, sqlVisitors);
     }
 
     @Override
     public List<Map> queryForList(SqlStatement sql) throws DatabaseException {
         return delegatedReadExecutor.queryForList(sql);
     }
 
     @Override
     public List<Map> queryForList(SqlStatement sql, List<SqlVisitor> sqlVisitors) throws DatabaseException {
         return delegatedReadExecutor.queryForList(sql, sqlVisitors);
     }
 
     @Override
     public boolean updatesDatabase() {
         return false;
     }
 }