/*******************************************************************************
 * Copyright (c) 1998, 2010 Oracle. 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:
 *     Oracle - initial API and implementation from Oracle TopLink
 ******************************************************************************/

package org.eclipse.persistence.platform.database.oracle.plsql;

//javse imports
import java.util.ListIterator;
import java.util.Vector;
import static java.sql.Types.OTHER;

// EclipseLink imports
import org.eclipse.persistence.internal.helper.DatabaseType;
import org.eclipse.persistence.internal.helper.SimpleDatabaseType;
import org.eclipse.persistence.internal.sessions.AbstractRecord;
import org.eclipse.persistence.platform.database.DatabasePlatform;
import org.eclipse.persistence.queries.StoredProcedureCall;
import org.eclipse.persistence.sessions.DatabaseRecord;
import static org.eclipse.persistence.internal.helper.DatabaseType.DatabaseTypeHelper.databaseTypeHelper;
import static org.eclipse.persistence.internal.helper.Helper.NL;
import static org.eclipse.persistence.platform.database.jdbc.JDBCTypes.INTEGER_TYPE;
import static org.eclipse.persistence.platform.database.jdbc.JDBCTypes.NUMERIC_TYPE;

/**
 * <b>PUBLIC</b>: Oracle PL/SQL types
 * @author  Mike Norman - michael.norman@oracle.com
 * @since  Oracle TopLink 11.x.x
 */
@SuppressWarnings("unchecked")
public enum OraclePLSQLTypes implements SimpleDatabaseType, OraclePLSQLType {

    BinaryInteger("BINARY_INTEGER"),
    Dec("DEC") ,
    Int("INT"),
    Natural("NATURAL"),
    NaturalN("NATURALN") {
        /**
         * Requires an initial value.
         */
        @Override
        public void buildOutDeclare(StringBuilder sb, PLSQLargument outArg) {
            databaseTypeHelper.declareTarget(sb, outArg, this);
            sb.append(" := 1;");
            // can't use Helper.cr 'cause Oracle PL/SQL parser only likes Unix-style newlines '\n'
            sb.append(NL);
        }
    },
    PLSQLBoolean("BOOLEAN") {
        @Override
        public int getConversionCode() {
            // substitute Integer
            return INTEGER_TYPE.getConversionCode();
        }

        @Override
        public void buildInDeclare(StringBuilder sb, PLSQLargument inArg) {
            databaseTypeHelper.declareTarget(sb, inArg, this);
            sb.append(" := "); 
            sb.append(PLSQLBoolean_IN_CONV);
            sb.append("(:");
            sb.append(inArg.inIndex);
            sb.append(");");
            sb.append(NL);
        }

        @Override
        public void buildOutAssignment(StringBuilder sb, PLSQLargument outArg, PLSQLStoredProcedureCall call) {
            sb.append("  :");
            sb.append(outArg.outIndex);
            sb.append(" := "); 
            sb.append(PLSQLBoolean_OUT_CONV);
            sb.append("(");
            sb.append(databaseTypeHelper.buildTarget(outArg));
            sb.append(");");
            sb.append(NL);
        }
    },
    PLSQLInteger("PLS_INTEGER"),
    Positive("POSITIVE"),
    PositiveN("POSITIVEN") {
        /**
         * Requires an initial value.
         */
        @Override
        public void buildOutDeclare(StringBuilder sb, PLSQLargument outArg) {
            databaseTypeHelper.declareTarget(sb, outArg, this);
            sb.append(" := 1;");
            sb.append(NL);
        }
    },
    SignType("SIGNTYPE"),
    ;

    private final String typeName;

    OraclePLSQLTypes(String typeName) {
        this.typeName = typeName;
    }

    public boolean isComplexDatabaseType() {
        return false;
    }
    public int getSqlCode() {
        return OTHER;
    }

    public int getConversionCode() {
        // widest compatible type java.sql.Types.NUMERIC <-> BigDecimal 
        return NUMERIC_TYPE.getConversionCode(); 
    }

    public String getTypeName() {
        return typeName;
    }

    public boolean isJDBCType() {
        return false;
    }

    /**
     * INTERNAL:
     * Return the parameter index for the IN parameter.
     */
    public int computeInIndex(PLSQLargument inArg, int newIndex,
        ListIterator<PLSQLargument> i) {
        return databaseTypeHelper.computeInIndex(inArg, newIndex);
    }
    
    /**
     * INTERNAL:
     * Return the parameter index for the OUT parameter.
     */
    public int computeOutIndex(PLSQLargument outArg, int newIndex,
        ListIterator<PLSQLargument> i) {
        return databaseTypeHelper.computeOutIndex(outArg, newIndex);
    }
    
    /**
     * INTERNAL:
     * Append the variable declaration for the type.
     */
    public void buildInDeclare(StringBuilder sb, PLSQLargument inArg) {
        databaseTypeHelper.declareTarget(sb, inArg, this);
        sb.append(" := :");
        sb.append(inArg.inIndex);
        sb.append(";");
        sb.append(NL);
    }

    /**
     * INTERNAL:
     * Append the variable declaration for the type.
     */
    public void buildOutDeclare(StringBuilder sb, PLSQLargument outArg) {
        databaseTypeHelper.declareTarget(sb, outArg, this);
        sb.append(";");
        sb.append(NL);
    }
    
    /**
     * INTERNAL:
     * Append any code or translation required for the type.
     */
    public void buildBeginBlock(StringBuilder sb, PLSQLargument arg, PLSQLStoredProcedureCall call) {
        // nothing to do for simple types
    }

    /**
     * INTERNAL:
     * Append any code or translation for assigning the output value.
     */
    public void buildOutAssignment(StringBuilder sb, PLSQLargument arg, PLSQLStoredProcedureCall call) {
        databaseTypeHelper.buildOutAssignment(sb, arg, call);
    }

    /**
     * INTERNAL:
     * Translate the argument value from the query translation row to call translation row.
     */
    public void translate(PLSQLargument arg, AbstractRecord translationRow,
        AbstractRecord copyOfTranslationRow, Vector copyOfTranslationFields,
        Vector translationRowFields, Vector translationRowValues, StoredProcedureCall call) {
        databaseTypeHelper.translate(arg, translationRow, copyOfTranslationRow,
            copyOfTranslationFields, translationRowFields, translationRowValues, call);
    }

    /**
     * INTERNAL:
     * Build the query output row from the call output row.
     */
    public void buildOutputRow(PLSQLargument outArg, AbstractRecord outputRow,
        DatabaseRecord newOutputRow, Vector outputRowFields, Vector outputRowValues) {
        databaseTypeHelper.buildOutputRow(outArg, outputRow,
            newOutputRow, outputRowFields, outputRowValues);
    }

    /**
     * INTERNAL:
     * Append the parameter for logging purposes.
     */
    public void logParameter(StringBuilder sb, Integer direction, PLSQLargument arg,
        AbstractRecord translationRow, DatabasePlatform platform) {
        databaseTypeHelper.logParameter(sb, direction, arg, translationRow, platform);
    }

    public static DatabaseType getDatabaseTypeForCode(String typeName) {
        DatabaseType databaseType = null;
        if (BinaryInteger.typeName.equalsIgnoreCase(typeName)) {
            databaseType = BinaryInteger;
        }
        else if (Dec.typeName.equalsIgnoreCase(typeName)) {
            databaseType = Dec;
        }
        else if (Int.typeName.equalsIgnoreCase(typeName)) {
            databaseType = Int;
        }
        else if (Natural.typeName.equalsIgnoreCase(typeName)) {
            databaseType = Natural;
        }
        else if (NaturalN.typeName.equalsIgnoreCase(typeName)) {
            databaseType = NaturalN;
        }
        else if (PLSQLBoolean.typeName.equalsIgnoreCase(typeName) ||
            "BOOLEAN".equalsIgnoreCase(typeName)) {
            databaseType = PLSQLBoolean;
        }
        else if (PLSQLInteger.typeName.equalsIgnoreCase(typeName)) {
            databaseType = PLSQLInteger;
        }
        else if (Positive.typeName.equalsIgnoreCase(typeName)) {
            databaseType = Positive;
        }
        else if (PositiveN.typeName.equalsIgnoreCase(typeName)) {
            databaseType = PositiveN;
        }
        else if (SignType.typeName.equalsIgnoreCase(typeName)) {
            databaseType = SignType;
        }
        return databaseType;
    }
}
