/*
 * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0,
 * or the Eclipse Distribution License v. 1.0 which is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
 */

// Contributors:
//     Mike Norman - from Proof-of-concept, become production code
package dbws.testing.shadowddlgeneration.oldjpub;

//javase imports
import java.lang.reflect.Modifier;
import java.sql.SQLException;
import java.util.List;

//EclipseLink imports
import dbws.testing.shadowddlgeneration.oldjpub.PublisherException;

/**
 * Instances of the class <code>Type</code> represent user-declared or predefined types in SQL or
 * PL/SQL that may have fields and methods. Currently, subclasses of <code>Type</code> represent
 * PL/SQL packages, the top-level PL/SQL scope, Oracle 8 user-defined types (objects, varrays and
 * nested tables) and the primitive database types.
 * <br>
 * This class is analogous to java.lang.Class.
 */
public abstract class TypeClass {

    protected Name m_name;
    protected boolean m_isPrimitive;
    protected int m_typecode;
    protected Object m_annotation;
    protected String m_hint;
    protected List<String> m_namedTranslations;

    /** The following methods are adapted from java.lang.Class */

    /**
     * If this Type has a component type, return the Type object that represents the component type;
     * otherwise returns null.
     */
    public TypeClass getComponentType() throws SQLException, PublisherException {
        return null;
    }

    /**
     * Returns an array of Field objects reflecting all the fields declared by this Type object.
     * Returns an array of length 0 if this Type object declares no fields.
     */
    public List<AttributeField> getDeclaredFields(boolean publishedOnly) throws SecurityException, SQLException,
        PublisherException {
        /* derived classes that have fields override this */
        return null;
    }

    /**
     * Returns an array of Method objects reflecting all the methods declared by this Type object.
     * Returns an array of length 0 if the Type declares no methods
     */
    public List<ProcedureMethod> getDeclaredMethods() throws SecurityException, SQLException, PublisherException {
        return null;
    }

    /**
     * Returns an array of Field objects reflecting all the accessible fields of this Type object.
     * Returns an array of length 0 if this Type object has no accesible fields.
     */
    public List<AttributeField> getFields(boolean publishedOnly) throws SecurityException, SQLException,
        PublisherException {
        /* derived classes that have fields override this */
        return null;
    }

    /**
     * Returns the modifiers for this type, encoded in an integer. The modifiers currently in use
     * are: public (always set) final abstract The modifiers are decoded using the methods of
     * java.lang.reflect.Modifier. If we ever need additional modifiers for C++, we can subclass
     * Modifier.
     */
    public int getModifiers() throws SQLException {
        return Modifier.PUBLIC + Modifier.FINAL;
    }

    /**
     * Returns the fully-qualified name of the type represented by this Type object, as a String.
     */
    public String getName() {
        return m_name.toString();
    }

    /**
     * Returns the Type representing the supertype of the entity represented by this Type. If no
     * supertype, returns null
     */

    public TypeClass getSupertype() throws SQLException, PublisherException {
        return null;
    }

    /**
     * Determines if this Type represents an array type.
     * <br>
     */
    public boolean isArray() {
        return false;
    }

    /**
     * Determines if this Type represents an object type.
     * <br>
     */
    public boolean isObject() {
        return false;
    }

    /**
     * Determines if this Type represents a primitive type.
     */
    public boolean isPrimitive() {
        return m_isPrimitive;
    }

    /**
     * Converts the Type to a string, as it would appear in an error message.
     */
    public String toString() {
        return getName();
    }

    public int hashCode() {
        return m_name.hashCode();
    }

    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (obj.getClass() != getClass()) {
            return false;
        }

        return getName().equals(((TypeClass)obj).getName());
    }

    /**
     * The remaining methods are not adapted from java.lang.Class
     */

    public boolean isPackage() {
        return false;
    }

    public boolean isTable() {
        return false;
    }

    /**
     * Returns the annotation associated with the Type. The annotation was set by the client of the
     * Type using setAnnotation().
     */
    public Object getAnnotation() {
        return m_annotation;
    }

    /**
     * Sets the annotation associated with the Type. The annotation is an arbitary object chosed by
     * the client of the Type.
     */
    public void setAnnotation(Object o) {
        m_annotation = o;
    }

    /**
     * Returns a hint associated with the Type. Usually hints are used for index-by table types.
     */
    public String getHint() {
        return m_hint;
    }

    /**
     * Sets the hint associated with the Type. Usually hints are used for index-by table types.
     */
    public void setHint(String s) {
        m_hint = s;
    }

    public List<String> getNamedTranslations() {
        return m_namedTranslations;
    }

    public void setNamedTranslations(List<String> v) {
        m_namedTranslations = v;
    }

    /**
     * Return the typecode for this type.
     */
    public int getTypecode() {
        return m_typecode;
    }

    /**
     * set the typecode for this type.
     */
    public void setTypecode(int typecode) {
        m_typecode = typecode;
    }

    /**
     * Return a JDBC typecode for this type.
     */
    public int getJdbcTypecode() {
        // JDBC shares the same typecode for nested table and varrays
        if (getTypecode() == OracleTypes.TABLE) {
            return OracleTypes.ARRAY;
        }
        // PL/SQL TABLE is mapped into SQL VARRAT
        if (getTypecode() == OracleTypes.PLSQL_INDEX_TABLE) {
            return OracleTypes.ARRAY;
        }
        if (getTypecode() == OracleTypes.PLSQL_NESTED_TABLE) {
            return OracleTypes.ARRAY;
        }
        if (getTypecode() == OracleTypes.PLSQL_VARRAY_TABLE) {
            return OracleTypes.ARRAY;
        }
        // PL/SQL RECORD is mapped into SQL OBJECT
        if (getTypecode() == OracleTypes.PLSQL_RECORD) {
            return OracleTypes.STRUCT;
        }
        return getTypecode();
    }

    public boolean hasMethods() throws SQLException, PublisherException {
        /* subclasses with methods override this */
        return false;
    }

    public Name getNameObject() {
        return m_name;
    }

    void setNameObject(Name name) {
        m_name = name;
    }

    protected TypeClass(Name name, int typecode, boolean isPrimitive) {
        m_name = name;
        m_typecode = typecode;
        m_isPrimitive = isPrimitive;
    }

    /**
     * Reports whether this is a PL/SQL type which has user-defined conversion functions to a SQL
     * type.
     */
    public boolean hasConversion() {
        return false;
    }

    /**
     * Returns the PL/SQL function to be used for converting this PL/SQL into a SQL type.
     * <br>
     * Returns null if this is not a PL/SQL type or if it does not have user-defined conversions.
     */
    public String getOutOfConversion() {
        return null;
    }

    /**
     * Returns the PL/SQL function to be used for converting this PL/SQL into a SQL type, qualified
     * with package name.
     * <br>
     * Returns null if this is not a PL/SQL type or if it does not have user-defined conversions.
     */
    public String getOutOfConversionQualified() {
        return null;
    }

    /**
     * Returns the PL/SQL function to be used for converting a SQL type into this PL/SQL type,
     * qualified with package name.
     * <br>
     * Returns null if this is not a PL/SQL type or if it does not have user-defined conversions.
     */
    public String getIntoConversion() {
        return null;
    }

    /**
     * Returns the PL/SQL function to be used for converting a SQL type into this PL/SQL type,
     * qualified with package name.
     * <br>
     * Returns null if this is not a PL/SQL type or if it does not have user-defined conversions.
     */
    public String getIntoConversionQualified() {
        return null;
    }
}