/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.    
 */
package org.apache.openjpa.jdbc.meta;

import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;

import org.apache.openjpa.jdbc.identifier.DBIdentifier;
import org.apache.openjpa.jdbc.schema.Column;
import org.apache.openjpa.jdbc.schema.ColumnIO;
import org.apache.openjpa.jdbc.schema.ForeignKey;
import org.apache.openjpa.jdbc.schema.Index;
import org.apache.openjpa.jdbc.schema.Schemas;
import org.apache.openjpa.jdbc.schema.Table;
import org.apache.openjpa.jdbc.schema.Unique;
import org.apache.openjpa.jdbc.sql.Row;
import org.apache.openjpa.jdbc.sql.Select;
import org.apache.openjpa.kernel.OpenJPAStateManager;
import org.apache.openjpa.lib.util.Localizer;
import org.apache.openjpa.meta.JavaTypes;
import org.apache.openjpa.meta.ValueMetaData;
import org.apache.openjpa.meta.ValueMetaDataImpl;
import org.apache.openjpa.util.InternalException;
import org.apache.openjpa.util.MetaDataException;

/**
 * Standalone {@link ValueMapping} implementation.
 *
 * @author Abe White
 * @since 0.4.0
 */
@SuppressWarnings("serial")
public class ValueMappingImpl
    extends ValueMetaDataImpl
    implements ValueMapping {
    
    private static final long serialVersionUID = 6440545965133775709L;

    private static final Localizer _loc = Localizer.forPackage
        (ValueMappingImpl.class);

    private ValueMappingInfo _info;
    private ValueHandler _handler = null;
    private ClassMapping[] _typeArr = null;

    private Column[] _cols = Schemas.EMPTY_COLUMNS;
    private ColumnIO _io = null;
    private ForeignKey _fk = null;
    private Map<ClassMapping,ForeignKey> _targetFKs = null;
    private Index _idx = null;
    private Unique _unq = null;
    private int _join = JOIN_FORWARD;
    private boolean _criteria = false;
    private int _poly = POLY_TRUE;

    /**
     * Constructor. Supply owning mapping.
     */
    public ValueMappingImpl(FieldMapping owner) {
        super(owner);
        _info = owner.getMappingRepository().newMappingInfo(this);
        _info.setUseClassCriteria(owner.getMappingRepository().
            getMappingDefaults().useClassCriteria());
    }
    
    /**
     * Constructor for deserialization.
     */
    protected ValueMappingImpl() {
        super();
    }

    public ValueMappingInfo getValueInfo() {
        return _info;
    }

    public ValueHandler getHandler() {
        return _handler;
    }

    public void setHandler(ValueHandler handler) {
        _handler = handler;
    }

    public MappingRepository getMappingRepository() {
        return (MappingRepository) getRepository();
    }

    public FieldMapping getFieldMapping() {
        return (FieldMapping) getFieldMetaData();
    }

    public ClassMapping getTypeMapping() {
        return (ClassMapping) getTypeMetaData();
    }

    public ClassMapping getDeclaredTypeMapping() {
        return (ClassMapping) getDeclaredTypeMetaData();
    }

    public ClassMapping getEmbeddedMapping() {
        return (ClassMapping) getEmbeddedMetaData();
    }

    public FieldMapping getValueMappedByMapping() {
        return (FieldMapping) getValueMappedByMetaData();
    }

    public Column[] getColumns() {
        if (_cols.length != 0)
            return _cols;
        if (_fk != null)
            return _fk.getColumns();
        if (getValueMappedBy() != null)
            return getValueMappedByMapping().getColumns();
        return _cols;
    }

    public void setColumns(Column[] cols) {
        if (cols == null)
            cols = Schemas.EMPTY_COLUMNS;
        _cols = cols;
    }

    public ColumnIO getColumnIO() {
        if (_cols.length == 0 && _fk == null && getValueMappedBy() != null)
            return getValueMappedByMapping().getColumnIO();
        return (_io == null) ? ColumnIO.UNRESTRICTED : _io;
    }

    public void setColumnIO(ColumnIO io) {
        _io = io;
    }

    public ForeignKey getForeignKey() {
        if (_fk == null && getValueMappedBy() != null)
            return getValueMappedByMapping().getForeignKey();
        return _fk;
    }

    public void setForeignKey(ForeignKey fk) {
        _fk = fk;
        if (fk == null)
            _join = JOIN_FORWARD;
    }

    public ForeignKey getForeignKey(ClassMapping target, int targetNumber) {
        if (_fk == null && getValueMappedBy() != null)
            return getValueMappedByMapping().getForeignKey(target);
        if (target == null)
            return _fk;
        ClassMapping embeddedMeta = (ClassMapping)getEmbeddedMetaData(); 
        if (embeddedMeta != null) {
            FieldMapping[] fields = embeddedMeta.getFieldMappings();
            int j = 0;
            for (int i = 0; i < fields.length; i++) {
                ValueMapping val = fields[i].getValueMapping(); 
                if (val.getDeclaredTypeMapping() == target)
                    if (targetNumber == j)
                    return val.getForeignKey();
                    else
                        j++;
            }
        }
        if (_fk == null && _cols.length == 0)
            return null;

        // always use least-derived joinable type
        for (ClassMapping sup = target; sup != null;
            sup = sup.getJoinablePCSuperclassMapping()) {
            if (sup == getTypeMetaData())
                return _fk;
            target = sup;
        }

        synchronized (this) {
            if (_targetFKs != null) {
                Object cachedFK = _targetFKs.get(target);
                if (cachedFK != null)
                    return (ForeignKey) cachedFK;
            } else
                _targetFKs = new HashMap<ClassMapping, ForeignKey>();

            ForeignKey newfk = (_join == JOIN_FORWARD)
                ? newForwardForeignKey(target) : newInverseForeignKey(target);
            _targetFKs.put(target, newfk);
            return newfk;
        }
    }
    public ForeignKey getForeignKey(ClassMapping target) {
        return getForeignKey(target, 0);
    }
    /**
     * Create a forward foreign key to the given target.
     */
    private ForeignKey newForwardForeignKey(ClassMapping target) {
        Table table;
        Column[] cols;
        if (_fk == null) {
            table = _cols[0].getTable();
            cols = _cols;
        } else {
            table = _fk.getTable();
            cols = _fk.getColumns();
        }

        // gather target cols before adding foreign key to table in case
        // there is an error while looking for a target col
        Column[] tcols = new Column[cols.length];
        for (int i = 0; i < cols.length; i++) {
            if (cols[i].getTargetField() != null)
                tcols[i] = getEquivalentColumn(cols[i], target,
                    cols[i].getTargetField());
            else if (_fk != null)
                tcols[i] = getEquivalentColumn(_fk.getPrimaryKeyColumn
                    (cols[i]).getIdentifier(), target, true);
            else if (!DBIdentifier.isNull(cols[i].getTargetIdentifier()))
                tcols[i] = getEquivalentColumn(cols[i].getTargetIdentifier(), target,
                    true);
            else
                tcols[i] = getEquivalentColumn(cols[i].getIdentifier(), target,
                    false);
        }

        ForeignKey newfk = table.addForeignKey();
        newfk.setJoins(cols, tcols);
        if (_fk != null) {
            cols = _fk.getConstantColumns();
            for (int i = 0; i < cols.length; i++)
                newfk.joinConstant(cols[i], _fk.getConstant(cols[i]));

            cols = _fk.getConstantPrimaryKeyColumns();
            for (int i = 0; i < cols.length; i++)
                newfk.joinConstant(_fk.getPrimaryKeyConstant(cols[i]),
                    getEquivalentColumn(cols[i].getIdentifier(), target, true));
        }
        return newfk;
    }

    /**
     * Return the given mapping's equivalent to the given column, using the
     * target field.
     */
    private Column getEquivalentColumn(Column col, ClassMapping target,
        String fieldName) {
        fieldName = fieldName.substring(fieldName.indexOf('.') + 1);
        FieldMapping field = target.getFieldMapping(fieldName);
        if (field == null)
            throw new MetaDataException(_loc.get("no-equiv-field",
                new Object[]{ this, target, fieldName, col }));

        Column[] cols = field.getColumns();
        if (cols.length != 1)
            throw new MetaDataException(_loc.get("bad-equiv-field",
                new Object[]{ this, target, fieldName, col }));

        return cols[0];
    }

    /**
     * Return the given mapping's equivalent of the given column.
     */
    private Column getEquivalentColumn(DBIdentifier colName, ClassMapping target,
        boolean explicit) {
        // if there was no explicit target, use single pk column
        if (!explicit) {
            for (ClassMapping cls = target; cls != null;
                cls = cls.getJoinablePCSuperclassMapping()) {
                if (cls.getTable() != null) {
                    if (cls.getPrimaryKeyColumns().length == 1)
                        return cls.getPrimaryKeyColumns()[0];
                    break;
                }
            }
        }

        Column ret;
        for (ClassMapping cls = target; cls != null;
            cls = cls.getJoinablePCSuperclassMapping()) {
            if (cls.getTable() != null) {
                ret = cls.getTable().getColumn(colName);
                if (ret != null)
                    return ret;
            }
        }

        throw new MetaDataException(_loc.get("no-equiv-col", this, target,
            colName));
    }

    /**
     * Return an inverse foreign key from the given related type to our table.
     */
    private ForeignKey newInverseForeignKey(ClassMapping target) {
        FieldMapping field = getFieldMapping();
        FieldMapping mapped = field.getMappedByMapping();
        if (mapped == null)
            throw new MetaDataException(_loc.get("cant-inverse", this));

        mapped = target.getFieldMapping(mapped.getIndex());
        if (mapped == null || mapped.getTypeCode() != JavaTypes.PC)
            throw new MetaDataException(_loc.get("no-equiv-mapped-by",
                this, target, field.getMappedBy()));
        return mapped.getForeignKey();
    }

    public int getJoinDirection() {
        if (_fk == null && getValueMappedBy() != null)
            return getValueMappedByMapping().getJoinDirection();
        return _join;
    }

    public void setJoinDirection(int direction) {
        _join = direction;
    }

    public void setForeignKey(Row row, OpenJPAStateManager rel, int targetNumber)
        throws SQLException {
        if (rel != null) {
            row.setForeignKey(getForeignKey((ClassMapping) rel.getMetaData(), targetNumber),
                _io, rel);
        }
        else if (_fk != null)
            row.setForeignKey(_fk, _io, null);
        else {
            for (int i = 0; i < _cols.length; i++) {
                if (_io == null || (row.getAction() == Row.ACTION_INSERT
                    && _io.isInsertable(i, true))
                    || (row.getAction() != Row.ACTION_INSERT
                    && _io.isUpdatable(i, true)))
                    row.setNull(_cols[i]);
            }
        }
    }
    public void setForeignKey(Row row, OpenJPAStateManager rel)
        throws SQLException {
        setForeignKey(row, rel, 0);
    }

    public void whereForeignKey(Row row, OpenJPAStateManager rel)
        throws SQLException {
        if (rel != null)
            row.whereForeignKey(getForeignKey((ClassMapping)
                rel.getMetaData()), rel);
        else if (_fk != null)
            row.whereForeignKey(_fk, null);
        else
            for (int i = 0; i < _cols.length; i++)
                row.whereNull(_cols[i]);
    }

    public ClassMapping[] getIndependentTypeMappings() {
        ClassMapping rel = getTypeMapping();
        if (rel == null)
            return ClassMapping.EMPTY_MAPPINGS;
        if (_poly != POLY_TRUE) {
            if (!rel.isMapped())
                return ClassMapping.EMPTY_MAPPINGS;
            if (_typeArr == null)
                _typeArr = new ClassMapping[]{ rel };
            return _typeArr;
        }
        return rel.getIndependentAssignableMappings();
    }

    public int getSelectSubclasses() {
        ClassMapping rel = getTypeMapping();
        if (rel == null || !rel.isMapped())
            return -1;

        switch (_poly) {
            case POLY_FALSE:
                return (_criteria) ? Select.SUBS_NONE : Select.SUBS_EXACT;
            case POLY_TRUE:
                ClassMapping[] assign = rel.getIndependentAssignableMappings();
                if (assign.length != 1 || assign[0] != rel)
                    return -1;
                // no break
            case POLY_JOINABLE:
                return (_criteria) ? Select.SUBS_JOINABLE
                    : Select.SUBS_ANY_JOINABLE;
            default:
                throw new InternalException();
        }
    }

    public Unique getValueUnique() {
        return _unq;
    }

    public void setValueUnique(Unique unq) {
        _unq = unq;
    }

    public Index getValueIndex() {
        return _idx;
    }

    public void setValueIndex(Index idx) {
        _idx = idx;
    }

    public boolean getUseClassCriteria() {
        if (_fk == null && getValueMappedBy() != null)
            return getValueMappedByMapping().getUseClassCriteria();
        return _criteria;
    }

    public void setUseClassCriteria(boolean criteria) {
        _criteria = criteria;
    }

    public int getPolymorphic() {
        return _poly;
    }

    public void setPolymorphic(int poly) {
        _poly = poly;
    }

    public void refSchemaComponents() {
        for (int i = 0; i < _cols.length; i++)
            _cols[i].ref();
        if (_fk != null) {
            _fk.ref();
            _fk.refColumns();
        }

        ClassMapping embed = getEmbeddedMapping();
        if (embed != null)
            embed.refSchemaComponents();
    }

    /**
     * @deprecated
     */
    public void mapConstraints(String name, boolean adapt) {
        mapConstraints(DBIdentifier.newConstraint(name), adapt);
    }

    public void mapConstraints(DBIdentifier name, boolean adapt) {
        _unq = _info.getUnique(this, name, adapt);
        _idx = _info.getIndex(this, name, adapt);
    }
    
    public void clearMapping() {
        _handler = null;
        _cols = Schemas.EMPTY_COLUMNS;
        _unq = null;
        _idx = null;
        _fk = null;
        _join = JOIN_FORWARD;
        _info.clear();
        setResolve(MODE_MAPPING | MODE_MAPPING_INIT, false);
    }

    public void syncMappingInfo() {
        if (getValueMappedBy() != null)
            _info.clear();
        else {
            _info.syncWith(this);
            ClassMapping embed = getEmbeddedMapping();
            if (embed != null)
                embed.syncMappingInfo();
        }
    }
    
    public void copy(ValueMetaData vmd) {
        super.copy(vmd);
        copyMappingInfo((ValueMapping)vmd);
    }

    public void copyMappingInfo(ValueMapping vm) {
        setValueMappedBy(vm.getValueMappedBy());
        setPolymorphic(vm.getPolymorphic());
        _info.copy(vm.getValueInfo());

        ClassMapping embed = vm.getEmbeddedMapping();
        if (embed != null && getEmbeddedMapping() != null) {
            FieldMapping[] tmplates = embed.getFieldMappings();
            FieldMapping[] fms = getEmbeddedMapping().getFieldMappings();
            if (tmplates.length == fms.length)
                for (int i = 0; i < fms.length; i++)
                    fms[i].copyMappingInfo(tmplates[i]);
        }
    }

    public boolean resolve(int mode) {
        int cur = getResolve();
        if (super.resolve(mode))
            return true;
        ClassMapping embed = getEmbeddedMapping();
        if (embed != null)
            embed.resolve(mode);
        if ((mode & MODE_MAPPING) != 0 && (cur & MODE_MAPPING) == 0)
            resolveMapping();
        if ((mode & MODE_MAPPING_INIT) != 0 && (cur & MODE_MAPPING_INIT) == 0)
            initializeMapping();
        return false;
    }

    /**
     * Setup mapping. Our handler will already have been set by our owning
     * field.
     */
    private void resolveMapping() {
        // mark mapped columns
        Column[] cols;
        int insertFlag;
        if (_fk != null) {
            cols = _fk.getColumns();
            insertFlag = Column.FLAG_FK_INSERT;
        } else {
            cols = getColumns();
            insertFlag = Column.FLAG_DIRECT_INSERT;
        }
        ColumnIO io = getColumnIO();
        for (int i = 0; i < cols.length; i++) {
            if (io.isInsertable(i, false))
                cols[i].setFlag(insertFlag, true);
            if (io.isUpdatable(i, false))
                cols[i].setFlag(insertFlag, true);
        }
    }

    /**
     * Prepare mapping for runtime use.
     */
    private void initializeMapping() {
        if (_fk == null)
            return;

        // if our fk cols are direct mapped by other values, make them
        // non-nullable
        Column[] cols = _fk.getColumns();
        for (int i = 0; i < cols.length; i++) {
            if (cols[i].getFlag(Column.FLAG_DIRECT_INSERT))
                newIO().setNullInsertable(i, false);
            if (cols[i].getFlag(Column.FLAG_DIRECT_UPDATE))
                newIO().setNullUpdatable(i, false);
        }

        // if anything maps our constant fk cols, make them read only
        int len = cols.length;
        cols = _fk.getConstantColumns();
        for (int i = 0; i < cols.length; i++) {
            if (cols[i].getFlag(Column.FLAG_DIRECT_INSERT)
                || cols[i].getFlag(Column.FLAG_FK_INSERT))
                newIO().setInsertable(len + i, false);
            if (cols[i].getFlag(Column.FLAG_DIRECT_UPDATE)
                || cols[i].getFlag(Column.FLAG_FK_UPDATE))
                newIO().setUpdatable(len + i, false);
        }
    }

    /**
     * Return the column I/O information, creating it if necessary.
     */
    private ColumnIO newIO() {
        if (_io == null)
            _io = new ColumnIO();
        return _io;
    }
}
