/*******************************************************************************
 * Copyright (c) 2010, 2015 Dies Koper (Fujitsu). Oracle and/or its affiliates, IBM Corporation.
 * All rights reserved. This program and the accompanying materials are made available under the 
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 
 * which accompanies this distribution. 
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at 
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Created Feb 19, 2010 - Dies Koper (Fujitsu)
 *        bug 288715: Drop Table Restrictions: "table locked" errors when dropping
 *                    tables in several Core and many JPA LRG tests on Symfoware.
 *     Jul 19, 2014 - Tomas Kraus (Oracle)
 *        bug 437578: Added few helper methods to simplify table builder methods.
 *     Jan 06, 2015 - Dalia Abo Sheasha (IBM)
 *        bug 454917: Moved a few helper methods from child class to be visible to all table creators.
 ******************************************************************************/
package org.eclipse.persistence.testing.framework;

import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.Vector;

import org.eclipse.persistence.exceptions.DatabaseException;
import org.eclipse.persistence.internal.databaseaccess.DatabasePlatform;
import org.eclipse.persistence.internal.helper.DatabaseField;
import org.eclipse.persistence.internal.sessions.AbstractSession;
import org.eclipse.persistence.logging.AbstractSessionLog;
import org.eclipse.persistence.logging.SessionLog;
import org.eclipse.persistence.sessions.DatabaseSession;
import org.eclipse.persistence.tools.schemaframework.FieldDefinition;
import org.eclipse.persistence.tools.schemaframework.ForeignKeyConstraint;
import org.eclipse.persistence.tools.schemaframework.SchemaManager;
import org.eclipse.persistence.tools.schemaframework.TableCreator;
import org.eclipse.persistence.tools.schemaframework.TableDefinition;

/**
 * Many JPA and a few Core tests use the same tables names, so at the start of
 * the tests tables are dropped and recreated. If the tables were created in a
 * previous test and the connection used to create it is still open, Symfoware
 * complains that the tables are locked when it tries to drop them.
 * <p/>
 * 
 * This class sets a flag before the subsequent recreation of the tables to
 * delete the rows instead. The first time it is called it does not set the
 * flag, to allow the tables to be initially created.
 * <p/>
 * 
 * To enable this functionality, the system property
 * "eclipselink.test.toggle-fast-table-creator" needs to be set to "true".
 * <p/>
 * 
 * This class should be positioned between the test's table creator class and
 * TableCreator by making the's test table creator extend this class.<br/>
 * 
 * @author Dies Koper, Tomas Kraus
 * 
 */
public class TogglingFastTableCreator extends TableCreator {

    /** Character to separate table name and column name in full column identifier. */
    protected static final char TABLE_FIELD_SEPARATOR = '.';

    protected static Set fastTableCreators = new HashSet();
    protected static boolean useFastTableCreatorAfterInitialCreate = Boolean
            .getBoolean("eclipselink.test.toggle-fast-table-creator");

    /**
     * Delegates to super's constructor.
     */
    public TogglingFastTableCreator() {
        super();
    }

    /**
     * Delegates to super's constructor.
     */
    public TogglingFastTableCreator(Vector tableDefinitions) {
        super(tableDefinitions);
    }

    @Override
    public void replaceTables(DatabaseSession session) {
        // on Symfoware, to avoid table locking issues only the first invocation
        // of an instance of this class (drops & re-)creates the tables
        // if the system property is set.
        session.getSessionLog().log(SessionLog.FINEST, "TogglingFastTableCreator: useFastTableCreatorAfterInitialCreate: "
                + useFastTableCreatorAfterInitialCreate);

        boolean isFirstCreate = !isFastTableCreator();
        session.getSessionLog().log(SessionLog.FINEST, "TogglingFastTableCreator: " + getTableCreatorName()
                + " - isFirstCreate: " + isFirstCreate);
        session.getSessionLog().log(SessionLog.FINEST, "TogglingFastTableCreator: Current fastTableCreators: "
                + fastTableCreators);

        if (useFastTableCreatorAfterInitialCreate && !isFirstCreate) {
            session.getSessionLog().log(SessionLog.FINEST, "TogglingFastTableCreator: " + getTableCreatorName()
                    + " - toggling true");
            String sequenceTableName = getSequenceTableName(session);
            List<TableDefinition> tables = getTableDefinitions();
            for (TableDefinition table : tables) {
                if (!table.getName().equals(sequenceTableName)) {
                    SchemaManager schemaManager = new SchemaManager(session);
                    AbstractSession abstarctSession = schemaManager.getSession();
                    try {
                        abstarctSession.priviledgedExecuteNonSelectingCall(new org.eclipse.persistence.queries.SQLCall("DELETE FROM " + table.getFullName()));
                    } catch (DatabaseException ex) {
                        //Ignore database exception. eg. If there is no table to delete, it gives database exception. 
                    } 
                }
            }
        } else { 
            super.replaceTables(session);
        }

        // next time just delete the rows instead.
        if (useFastTableCreatorAfterInitialCreate) {
            setFastTableCreator();
            session.getSessionLog().log(SessionLog.FINEST, "TogglingFastTableCreator: " + getTableCreatorName()
                    + " added to fastTableCreators");
        }
    }

    public boolean resetFastTableCreator() {
        AbstractSessionLog.getLog().log(SessionLog.FINEST, "TogglingFastTableCreator: removing table creator: "
                + getTableCreatorName());
        return fastTableCreators.remove(getTableCreatorName());
    }

    public boolean setFastTableCreator() {
        AbstractSessionLog.getLog().log(SessionLog.FINEST, "TogglingFastTableCreator: adding table creator: "
                + getTableCreatorName());
        return fastTableCreators.add(getTableCreatorName());
    }

    public boolean isFastTableCreator() {
        return fastTableCreators.contains(getTableCreatorName());
    }
    
    public String getTableCreatorName() {
        return this.getClass().getName();
    }

    /**
     * Helper method to concatenate table name and column name into full column name.
     * @param tableName Table name.
     * @param columnName Column name.
     * @return Full column name (prefixed with table name).
     */
    protected static String buildFullColumnName(
            final String tableName, final String columnName) {
        final StringBuilder sb = new StringBuilder(tableName.length() + columnName.length() + 1);
        sb.append(tableName).append(TABLE_FIELD_SEPARATOR).append(columnName);
        return sb.toString();

    }

    /**
     * Helper method to create {@link TableDefinition} instance with given table name.
     * @param name Table name.
     * @return {@link TableDefinition} instance with name set.
     */
    protected static TableDefinition createTable(final String name) {
        final TableDefinition table = new TableDefinition();
        table.setName(name);
        return table;
    }

    /**
     * Helper method to create {@link FieldDefinition} instance for unique
     * numeric primary key with given name and size.
     * @param name Column name.
     * @param size Column numeric type size.
     * @return Initialized {@link FieldDefinition} instance.
     */
    protected static FieldDefinition createNumericPk(
            final String name, final int size) {
        final FieldDefinition field = new FieldDefinition();
        field.setName(name);
        field.setTypeName("NUMERIC");
        field.setSize(size);
        field.setShouldAllowNull(false);
        field.setIsPrimaryKey(true);
        field.setUnique(true);
        field.setIsIdentity(true);
        return field;
    }

    /**
     * Helper method to create {@link FieldDefinition} instance for unique
     * numeric primary key with given name and default size of {@code 15}.
     * @param name Column name.
     * @return Initialized {@link FieldDefinition} instance.
     */
    protected static FieldDefinition createNumericPk(final String name) {
        return createNumericPk(name, 15);
    }

    /**
     * Helper method to create {@link FieldDefinition} instance for
     * numeric foreign key with given name, size and foreign key name.
     * @param name   Column name.
     * @param size   Column numeric type size.
     * @param fkName Foreign key name (e.g. {@code "MY_TABLE.ID"}.
     * @return Initialized {@link FieldDefinition} instance.
     */
    protected static FieldDefinition createNumericFk(
            final String name, final int size, final String fkName) {
        final FieldDefinition field = new FieldDefinition();
        field.setName(name);
        field.setTypeName("NUMERIC");
        field.setSize(size);
        field.setShouldAllowNull(false);
        field.setIsPrimaryKey(false);
        field.setUnique(false);
        field.setIsIdentity(false);
        field.setForeignKeyFieldName(fkName);
        return field;
    }

    /**
     * Helper method to create {@link FieldDefinition} instance for
     * numeric foreign key with given name, foreign key name and default size
     * of {@code 15}.
     * @param name Column name.
     * @return Initialized {@link FieldDefinition} instance.
     */
    protected static FieldDefinition createNumericFk(
            final String name, final String fkName) {
        return createNumericFk(name, 15, fkName);
    }

    /**
     * Helper method to create {@link FieldDefinition} instance for numeric column
     * with given name and size and without any additional constraints.
     * @param name Column name.
     * @param size Column numeric type size.
     * @param allowNull Allow {@code null} values for column.
     * @return Initialized {@link FieldDefinition} instance.
     */
    protected static FieldDefinition createNumericColumn(
            final String name, final int size, final boolean allowNull) {
        final FieldDefinition field = new FieldDefinition();
        field.setName(name);
        field.setTypeName("NUMERIC");
        field.setSize(size);
        field.setShouldAllowNull(allowNull);
        field.setIsPrimaryKey(false);
        field.setUnique(false);
        field.setIsIdentity(false);
        return field;
    }

    /**
     * Helper method to create {@link FieldDefinition} instance for numeric column
     * with given name, size of {@code 15}, with {@code null} value allowed and
     * without any additional constraints.
     * @param name Column name.
     * @param size Column numeric type size of {@code 15} with .
     * @return Initialized {@link FieldDefinition} instance.
     * @param allowNull Allow {@code null} values for column.
     */
    protected static FieldDefinition createNumericColumn(
            final String name) {
        return createNumericColumn(name, 15, true);
    }

    /**
     * Helper method to create {@link FieldDefinition} instance for <code>DTYPE</code>
     * column used for inheritance in model.
     * @return Initialized {@link FieldDefinition} instance.
     */
    protected static FieldDefinition createDTypeColumn() {
        final FieldDefinition field = new FieldDefinition();
        field.setName("DTYPE");
        field.setTypeName("VARCHAR2");
        field.setSize(15);
        field.setSubSize(0);
        field.setIsPrimaryKey(false);
        field.setIsIdentity(false);
        field.setUnique(false);
        field.setShouldAllowNull(true);
        return field;
    }

    /**
     * Helper method to create {@link FieldDefinition} instance for {@link String} column
     * with given name and size and without any additional constraints.
     * @param name Column name.
     * @param size Column numeric type size.
     * @param allowNull Allow {@code null} values for column.
     * @return Initialized {@link FieldDefinition} instance.
     */
    protected static FieldDefinition createStringColumn(
            final String name, final int size, final boolean allowNull) {
        final FieldDefinition field = new FieldDefinition();
        field.setName(name);
        field.setTypeName("VARCHAR");
        field.setSize(size);
        field.setShouldAllowNull(allowNull);
        field.setIsPrimaryKey(false);
        field.setUnique(false);
        field.setIsIdentity(false);
        return field;
    }

    /**
     * Helper method to create {@link FieldDefinition} instance for {@link String} column
     * with given name size of {@code 32}, with {@code null} value allowed and
     * without any additional constraints.
     * @param name Column name.
     * @return Initialized {@link FieldDefinition} instance.
     */
    protected static FieldDefinition createStringColumn(
            final String name) {
        return createStringColumn(name, 32, true);
    }

    /**
     * Helper method to create {@link FieldDefinition} instance
     * for {@link java.util.Date} column with given name and size and without
     * any additional constraints.
     * @param name Column name.
     * @param size Column date size.
     * @param allowNull Allow {@code null} values for column.
     * @return Initialized {@link FieldDefinition} instance.
     */
    protected static FieldDefinition createDateColumn(
            final String name, final int size, final boolean allowNull) {
        final FieldDefinition field = new FieldDefinition();
        field.setName(name);
        field.setTypeName("DATE");
        field.setSize(size);
        field.setShouldAllowNull(allowNull);
        field.setIsPrimaryKey(false);
        field.setUnique(false);
        field.setIsIdentity(false);
        return field;
    }

    /**
     * Helper method to create {@link FieldDefinition} instance
     * for {@link java.util.Date} column with given name size of {@code 23},
     * with {@code null} value allowed and without any additional constraints.
     * @param name Column name.
     * @return Initialized {@link FieldDefinition} instance.
     */
    protected static FieldDefinition createDateColumn(
            final String name) {
        return createDateColumn(name, 23, true);
    }

    protected void adjustForeignKeyFieldTypes(DatabaseSession session) {
        for (TableDefinition sourceTableDefinition : getTableDefinitions() ) {
            for (FieldDefinition sourceFieldDefinition : sourceTableDefinition.getFields()) {  // see TableDefinition, l.789
                if (sourceFieldDefinition.getForeignKeyFieldName() != null) {
                    // We need to build each foreign key constraint on the fly, because TableDefinition.buildFieldTypes() has not been called yet
                    ForeignKeyConstraint foreignKeyConstraint = buildForeignKeyConstraint(sourceFieldDefinition, session.getPlatform());
                    // Assume only one of each (as in Field Defintion)
                    String sourceFieldName = foreignKeyConstraint.getSourceFields().get(0);
                    String targetFieldName = foreignKeyConstraint.getTargetFields().get(0);

                    // Find the target table and the target field
                    TableDefinition targetTableDefinition = getTableDefinition(foreignKeyConstraint.getTargetTable());
                    // session.getSessionLog().log(SessionLog.FINEST, "AdvancedTableCreator: Found target table " +  foreignKeyConstraint.getTargetTable() + " for foreign key " + foreignKeyConstraint.getName());
                    FieldDefinition targetFieldDefinition = getFieldDefinition(targetTableDefinition, targetFieldName); 
                    // session.getSessionLog().log(SessionLog.FINEST, "AdvancedTableCreator: Found target field " + targetFieldDefinition.getName() + " in table " + targetTableDefinition.getName());
                    // Only change source column if target is identity
                    String qualifiedName = targetTableDefinition.getFullName() + '.' + targetFieldDefinition.getName();
                    if (targetFieldDefinition.isIdentity() && session.getPlatform().shouldPrintFieldIdentityClause((AbstractSession)session, qualifiedName)) {
                        session.getSessionLog().log(SessionLog.FINEST, "AdvancedTableCreator.adjustForeignKeyFieldTypes(): Changing data type of source field " + sourceFieldDefinition.getName() + "to INTEGER in table " + sourceTableDefinition.getName());
                        sourceFieldDefinition.setTypeName("INTEGER");
                        sourceFieldDefinition.setSize(0);                                             
                    }
                }
            }
        }
    }
    
    // Helper methods for adjustForeignKeyFieldTypes()

    private FieldDefinition getFieldDefinition(TableDefinition tableDefinition, String fieldName) {
        for (FieldDefinition targetField : tableDefinition.getFields()) { // see TableDefinition, l.351
            if (targetField.getName().equals(fieldName)) {
                return targetField;
            }
        }
        return null;    
    }

    private TableDefinition getTableDefinition(String tableName) {
        for (TableDefinition targetTable : getTableDefinitions()) { // see TableCreator, l.87
            if (targetTable.getName().equals(tableName)) {
                return targetTable;
            }
        }
        return null;    
    }

    // Mostly cloned from TableDefinition.buildForeignKeyConstraint()
    private ForeignKeyConstraint buildForeignKeyConstraint(FieldDefinition field, DatabasePlatform platform) {
        Vector sourceFields = new Vector();
        Vector targetFields = new Vector();
        ForeignKeyConstraint fkConstraint = new ForeignKeyConstraint();
        DatabaseField tempTargetField = new DatabaseField(field.getForeignKeyFieldName());
        DatabaseField tempSourceField = new DatabaseField(field.getName());

        sourceFields.add(tempSourceField.getName());
        targetFields.add(tempTargetField.getName());

        fkConstraint.setSourceFields(sourceFields);
        fkConstraint.setTargetFields(targetFields);
        fkConstraint.setTargetTable(tempTargetField.getTable().getQualifiedNameDelimited(platform));

        return fkConstraint;
    }
}
