Application: gvSIG desktop

package org.gvsig.fmap.dal.feature.impl;

import org.gvsig.fmap.dal.feature.EditableForeingKey;

import org.gvsig.fmap.dal.feature.ForeingKey;

import java.util.List;

import java.util.Objects;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.StoresRepository;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.expressionevaluator.FeatureSymbolTable;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.FeatureQuery;

import org.gvsig.fmap.dal.feature.FeatureSet;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.feature.FeatureType;

import static org.gvsig.fmap.dal.feature.ForeingKey.MAX_AVAILABLE_VALUES;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectValueItem;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class DefaultForeingKey implements Persistent, ForeingKey, EditableForeingKey, org.gvsig.tools.lang.Cloneable {

    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultForeingKey.class);

    private class DefaultContextForeingKey implements ContextForeingKey {

        private FeatureStore featureStore = null;

        private StoresRepository storesRepository = null;

        private Expression labelExpression;

        private SymbolTable symbolTable;

        private FeatureSymbolTable featureSymbolTable;

        private DynObject contextValues;

        private int refs;

        public DefaultContextForeingKey(StoresRepository storesRepository) {

            this.refs = 1;

            this.storesRepository = storesRepository;

        }

        public void addRef() {

            this.refs++;

        }

        public void relese() {

            this.refs--;

        }

        @Override

        public void dispose() {

            DisposeUtils.disposeQuietly(featureStore);

            DisposeUtils.disposeQuietly(contextValues);

            this.featureStore = null;

            this.storesRepository = null;

            this.labelExpression = null;

            this.symbolTable = null;

            this.featureSymbolTable = null;

        }

        @Override

        public StoresRepository getStoresRepository() {

            if (this.storesRepository == null) {

                this.storesRepository = DALLocator.getDataManager().getStoresRepository();

            }

            return this.storesRepository;

        }

        @Override

        public FeatureStore getFeatureStore() {

            if (this.featureStore == null) {

                StoresRepository repository = this.getStoresRepository();

                this.featureStore = (FeatureStore) repository.getStore(tableName);

                if (this.featureStore == null) {

                    LOGGER.warn("Can't locate store '" + tableName + "' to get available values.");

                    return null;

                }

            }

            return this.featureStore;

        }

        @Override

        public Expression getLabelExpression() {

            if (this.labelExpression == null) {

                if (StringUtils.isBlank(labelFormula)) {

                    return null;

                }

                this.labelExpression = ExpressionUtils.createExpression(labelFormula);

            }

            return this.labelExpression;

        }

        @Override

        public FeatureSymbolTable getFeatureSymbolTable() {

            if (this.featureSymbolTable == null) {

                DataManager dataManager = DALLocator.getDataManager();

                this.featureSymbolTable = dataManager.createFeatureSymbolTable();

                this.symbolTable = this.featureSymbolTable.createParent();

            }

            return this.featureSymbolTable;

        }

        @Override

        public SymbolTable getSymbolTable() {

            if (this.symbolTable == null) {

                DataManager dataManager = DALLocator.getDataManager();

                this.featureSymbolTable = dataManager.createFeatureSymbolTable();

                this.symbolTable = this.featureSymbolTable.createParent();

            }

            return this.symbolTable;

        }

        @Override

        public DynObject getContextValues() {

            return this.contextValues;

    }

        @Override

        public void setContextValues(DynObject values) {

            this.contextValues = values;

        }

    }

    private boolean foreingKey;

    private boolean closedList;

    private String labelFormula;

    private String tableName;

    private String codeName;

    private DynObjectValueItem[] availableValues;

    private boolean ensureReferentialIntegrity;

    private StoresRepository storesRepository = null;

    private FeatureAttributeDescriptor descriptor;

    public DefaultForeingKey() {

        this.foreingKey = false;

        this.closedList = false;

        this.tableName = null;

        this.codeName = null;

        this.labelFormula = null;

        this.ensureReferentialIntegrity = false;

    }

    public void setDescriptor(FeatureAttributeDescriptor descriptor) {

        this.descriptor = descriptor;

        FeatureStore store = descriptor.getStore();

        if (store == null) {

            this.storesRepository = DALLocator.getDataManager().getStoresRepository();

        } else {

            this.storesRepository = store.getStoresRepository();

        }

    }

    public void unbind() {

        this.descriptor = null;

        this.availableValues = null;

    }

    @Override

    public boolean isClosedList() {

        return this.closedList;

    }

    @Override

    public void setClosedList(boolean selectable) {

        this.closedList = selectable;

    }

    @Override

    public boolean isForeingKey() {

        return this.foreingKey;

    }

    @Override

    public void setForeingKey(boolean foreingKey) {

        this.foreingKey = foreingKey;

    }

    @Override

    public String getLabelFormula() {

        return this.labelFormula;

    }

    @Override

    public void setLabelFormula(String labelFormula) {

        this.labelFormula = labelFormula;

    }

    @Override

    public String getCodeName() {

        return this.codeName;

    }

    @Override

    public void setCodeName(String codeName) {

        this.codeName = codeName;

    }

    @Override

    public String getTableName() {

        return this.tableName;

    }

    @Override

    public void setTableName(String tableName) {

        this.tableName = tableName;

    }

    @Override

    public boolean isEmpty() {

        if (!this.foreingKey

                && !this.closedList

                && StringUtils.isBlank(this.tableName)

                && StringUtils.isBlank(this.codeName)

                && StringUtils.isBlank(this.labelFormula)) {

            return true;

        }

        return false;

    }

    @Override

    public void clean() {

        this.foreingKey = false;

        this.closedList = false;

        this.tableName = null;

        this.codeName = null;

        this.labelFormula = null;

        this.ensureReferentialIntegrity = false;

    }

    private void disposeIfLocalContext(ContextForeingKey context) {

        DefaultContextForeingKey c = (DefaultContextForeingKey) context;

        c.relese();

        if (c.refs == 0) {

            context.dispose();

        }

    }

    private ContextForeingKey createLocalContextIfNull(ContextForeingKey context) {

        if (context == null) {

            return createContext();

        }

        DefaultContextForeingKey c = (DefaultContextForeingKey) context;

        c.addRef();

        return c;

    }

    @Override

    public ContextForeingKey createContext() {

        return new DefaultContextForeingKey(this.storesRepository);

    }

    @Override

    public StoresRepository getStoresRepository(ContextForeingKey context) {

        context = createLocalContextIfNull(context);

        try {

            return context.getStoresRepository();

        } finally {

            disposeIfLocalContext(context);

        }

    }

    @Override

    public FeatureStore getFeatureStore(ContextForeingKey context) {

        context = createLocalContextIfNull(context);

        try {

            return context.getFeatureStore();

        } finally {

            disposeIfLocalContext(context);

        }

    }

    @Override

    public FeatureType getFeatureType(ContextForeingKey context) {

        context = createLocalContextIfNull(context);

        FeatureStore store = context.getFeatureStore();

        if (store == null) {

            return null;

        }

        try {

            return store.getDefaultFeatureType();

        } catch (DataException ex) {

            return null;

        } finally {

            disposeIfLocalContext(context);

        }

    }

    @Override

    public List<Feature> getFeatures(ContextForeingKey context) {

        context = createLocalContextIfNull(context);

        FeatureStore store = context.getFeatureStore();

        if (store == null) {

            return null;

        }

        try {

            return store.getFeatures();

        } finally {

            disposeIfLocalContext(context);

        }

    }

    @Override

    public Object getCode(ContextForeingKey context, Feature feature) {

//        context = createLocalContextIfNull(context);

        try {

            return feature.get(codeName);

        } finally {

//            disposeIfLocalContext(context);

        }

    }

    @Override

    public FeatureQuery getQuery(ContextForeingKey context, Object codeValue) {

        context = createLocalContextIfNull(context);

        try {

            ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

            FeatureStore store = context.getFeatureStore();

            FeatureQuery query = store.createFeatureQuery();

            query.setFilter(builder.eq(

                    builder.variable(codeName),

                    builder.constant(codeValue)

            ).toString()

            );

            query.retrievesAllAttributes();

            return query;

        } finally {

            disposeIfLocalContext(context);

        }

    }

    @Override

    public Feature getFeature(ContextForeingKey context, Object codeValue) {

        context = createLocalContextIfNull(context);

        try {

            FeatureStore store = context.getFeatureStore();

            if (store == null) {

                return null;

            }

            FeatureQuery query = this.getQuery(context, codeValue);

            Feature feature = store.findFirst(query);

            return feature;

        } catch (DataException ex) {

            return null;

        } finally {

            disposeIfLocalContext(context);

        }

    }

    @Override

    public String getLabel(ContextForeingKey context, Object codeValue) {

        context = createLocalContextIfNull(context);

        try {

            Feature feature = this.getFeature(context, codeValue);

            if (feature == null) {

                return null;

            }

            return getLabel(context, feature);

        } finally {

            disposeIfLocalContext(context);

        }

    }

    @Override

    public Expression getLabelExpression(ContextForeingKey context) {

        context = createLocalContextIfNull(context);

        try {

            return context.getLabelExpression();

        } finally {

            disposeIfLocalContext(context);

        }

    }

    @Override

    public String getLabel(ContextForeingKey context, Feature feature) {

        if (feature == null) {

            return null;

        }

        context = createLocalContextIfNull(context);

        try {

            Expression labelExpression = context.getLabelExpression();

            if (labelExpression == null) {

                return feature.toString();

            }

            context.getFeatureSymbolTable().setFeature(feature);

            Object x = labelExpression.execute(context.getSymbolTable());

            if (x == null) {

                return null;

            }

            return x.toString();

        } finally {

            disposeIfLocalContext(context);

        }

    }

    @Override

    public DynObjectValueItem[] getAvailableValues(ContextForeingKey context) {

        if (!this.isClosedList()) {

            return null;

        }

        if (this.availableValues == null) {

            FeatureStore foreingStore = null;

            FeatureSet.DisposableFeatureSetIterable set = null;

            try {

                StoresRepository theStoresRepository = this.getStoresRepository(context);

                foreingStore = (FeatureStore) theStoresRepository.getStore(

                        this.getTableName()

                );

                Expression labelExpression = this.getLabelExpression(null);

                String theCodeName =  this.getCodeName();

                FeatureSymbolTable featureSymbolTable = DALLocator.getDataManager().createFeatureSymbolTable();

                MutableSymbolTable symbolTable = featureSymbolTable.createParent();

                int count = (int) foreingStore.getFeatureCount();

                DynObjectValueItem[] values = new DynObjectValueItem[Math.min(count, MAX_AVAILABLE_VALUES)];

                int n = 0;

                for (Feature feature : set = foreingStore.getFeatureSet().iterable()) {

                    Object code = feature.get(theCodeName);

                    Object value;

                    if (labelExpression == null) {

                        value = code;

                    } else {

                        featureSymbolTable.setFeature(feature);

                        value = labelExpression.execute(symbolTable);

                    }

                    values[n++] = new DynObjectValueItem(code, Objects.toString(value, Objects.toString(code, "##ERROR##")));

                    if (n >= MAX_AVAILABLE_VALUES) {

                        break;

                    }

                }

                this.availableValues = values;

            } catch (Exception ex) {

                LOGGER.warn("Can't get available values for field '" + this.getStoreName() + "." + this.getCodeName() + "' from table '" + this.getTableName() + "'.", ex);

            } finally {

                DisposeUtils.disposeQuietly(set);

                DisposeUtils.disposeQuietly(foreingStore);

            }

        }

        return this.availableValues;

    }

    private String getStoreName() {

        if (this.descriptor==null) {

            return "Unknown";

        }

        return this.descriptor.getStore().getName();

    }

    @Override

    public String getLabelForValue(Object value) {

        DynObjectValueItem[] values = this.getAvailableValues(null);

        if (values != null) {

            for (DynObjectValueItem value1 : values) {

                if (Objects.equals(value, value1.getValue())) {

                    return value1.getLabel();

                }

            }

        }

        return Objects.toString(value, "##ERROR##");

    }

    @Override

    public void loadFromState(PersistentState state)

            throws PersistenceException {

        foreingKey = state.getBoolean("foreingKey");

        closedList = state.getBoolean("selectable");

        labelFormula = state.getString("labelFormula");

        codeName = state.getString("codeName");

        tableName = state.getString("tableName");

        ensureReferentialIntegrity = state.getBoolean("ensureReferentialIntegrity");

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set("foreingKey", foreingKey);

        state.set("selectable", closedList);

        state.set("labelFormula", labelFormula);

        state.set("codeName", codeName);

        state.set("tableName", tableName);

        state.set("ensureReferentialIntegrity", ensureReferentialIntegrity);

    }

    private static final String FOREINGKEY_PERSISTENCE_DEFINITION_NAME = "ForeingKey";

    public static void registerPersistenceDefinition() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if (manager.getDefinition(FOREINGKEY_PERSISTENCE_DEFINITION_NAME)

                == null) {

            DynStruct definition = manager.addDefinition(DefaultForeingKey.class,

                    FOREINGKEY_PERSISTENCE_DEFINITION_NAME,

                    FOREINGKEY_PERSISTENCE_DEFINITION_NAME

                    + " persistent definition",

                    null,

                    null

            );

            definition.addDynFieldBoolean("foreingKey");

            definition.addDynFieldBoolean("selectable");

            definition.addDynFieldString("LabelFormula");

            definition.addDynFieldString("codeName");

            definition.addDynFieldString("tableName");

            definition.addDynFieldBoolean("ensureReferentialIntegrity");

        }

    }

    @Override

    public ForeingKey clone() throws CloneNotSupportedException {

        DefaultForeingKey other = (DefaultForeingKey) super.clone();

        return other;

    }

    @Override

    public boolean getEnsureReferentialIntegrity() {

        return this.ensureReferentialIntegrity;

    }

    @Override

    public void setEnsureReferentialIntegrity(boolean ensureReferentialIntegrity) {

        this.ensureReferentialIntegrity = ensureReferentialIntegrity;

    }

    @Override

    public boolean isInAvailableValues(Object valueToCheck) {

        if (this.hasAvailableValues() && availableValues.length > 0) {

            for (DynObjectValueItem availableValue : availableValues) {

                if (Objects.equals(valueToCheck, availableValue.getValue())) {

                    return true;

                }

            }

        }

        return false;

    }

    @Override

    public boolean hasAvailableValues() {

        if (this.availableValues == null) {

            this.getAvailableValues(null);

        }

        return this.availableValues != null;

    }

}