Application: gvSIG desktop

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

import java.util.HashMap;

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

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

import java.util.List;

import java.util.Map;

import java.util.Objects;

import java.util.logging.Level;

import org.apache.commons.codec.digest.DigestUtils;

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.BaseStoresRepository;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataTransaction;

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.DisposableFeatureSetIterable;

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.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;

        private DataTransaction transaction;

        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);

            DisposeUtils.disposeQuietly(this.transaction);

            this.featureStore = null;

            this.storesRepository = null;

            this.labelExpression = null;

            this.symbolTable = null;

            this.featureSymbolTable = null;

            this.contextValues = null;

            this.transaction = null;

        }

        @Override

        public StoresRepository getStoresRepository() {

            if (this.storesRepository == null) {

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

            }

            return this.storesRepository;

        }

        @Override

        public FeatureStore getFeatureStore() {

            if (DisposeUtils.isNullOrDisposed(this.featureStore)) {

                StoresRepository repository = DefaultForeingKey.this.getStoresRepository(tableName);

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

                if(this.transaction != null){

                    try {

                        this.transaction.add(this.featureStore, true);

                    } catch (Exception ex) {

                        throw new RuntimeException("Can't add table '"+tableName+"' to transaction.", ex);

                    }

                }

            }

            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;

        }

        @Override

        public void setTransaction(DataTransaction transaction) {

            if(this.transaction != null){

                DisposeUtils.disposeQuietly(this.transaction);

                this.transaction = null;

            }

            this.transaction = transaction;

            DisposeUtils.bind(this.transaction);

        }

        @Override

        public DataTransaction getTransaction() {

            return this.transaction;

        }

    }

    private boolean foreingKey;

    private boolean closedList;

    private String labelFormula;

    private String tableName;

    private String codeName;

    private DynObjectValueItem[] availableValues;

    private boolean loadAvailableValues;

    private String repositoryIDOfAvailableValues;

    private String repositoryLabelOfAvailableValues;

    private boolean ensureReferentialIntegrity;

    private StoresRepository storesRepository = null;

    private FeatureAttributeDescriptor descriptor;

    private String fieldName;

    public DefaultForeingKey() {

        this.foreingKey = false;

        this.closedList = false;

        this.tableName = null;

        this.codeName = null;

        this.labelFormula = null;

        this.ensureReferentialIntegrity = false;

        this.loadAvailableValues = true;

        this.repositoryIDOfAvailableValues = null;

        this.repositoryLabelOfAvailableValues = null;

        this.fieldName = "unknown";

    }

    public void setDescriptor(FeatureAttributeDescriptor descriptor) {

        this.descriptor = descriptor;

    }

    public String getFieldName() {

        if(this.descriptor != null) {

            return this.descriptor.getName();

        }

        return fieldName;

    }

    private StoresRepository getStoresRepository() {

        if (this.storesRepository == null) {

            if (this.descriptor == null) {

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

            } else {

                FeatureStore store = descriptor.getStore();

                if (store == null) {

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

                } else {

                    this.storesRepository = store.getStoresRepository();

                }

            }

        }

        return this.storesRepository;

    }

    @Override

    public void unbind() {

        this.getStoresRepository(); // Force get stores repository

        if(this.descriptor != null){

            this.fieldName = this.descriptor.getName();

        }

        this.descriptor = null;

    }

    @Override

    public boolean isClosedList() {

        return this.closedList;

    }

    @Override

    public void setClosedList(boolean selectable) {

        this.closedList = selectable;

        // Force reload available values

        this.availableValues = null;

        this.loadAvailableValues = true;

    }

    @Override

    public boolean isForeingKey() {

        return this.foreingKey;

    }

    @Override

    public void setForeingKey(boolean foreingKey) {

        this.foreingKey = foreingKey;

        // Force reload available values

        this.availableValues = null;

        this.loadAvailableValues = true;

    }

    @Override

    public String getLabelFormula() {

        return this.labelFormula;

    }

    @Override

    public void setLabelFormula(String labelFormula) {

        this.labelFormula = labelFormula;

        // Force reload available values with new formula

        this.availableValues = null;

        this.loadAvailableValues = true;

    }

    @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;

        // Force reload available values

        this.availableValues = null;

        this.loadAvailableValues = true;

    }

    @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.getStoresRepository());

    }

    @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;

        }

        StoresRepository theStoresRepository = this.getStoresRepository(this.getTableName());

//        StoresRepository theStoresRepository = this.getStoresRepository(context);

        if( theStoresRepository==null ) {

            LOGGER.warn("Can't get available values for field '" + this.getStoreName() + "." + this.getFieldName()+ "' from table '" + this.getTableName() + "', can't locate the stores-repository.");

            return null;

        }

        theStoresRepository = theStoresRepository.getRepositoryOfStore(this.getTableName());

        if( theStoresRepository==null ) {

            LOGGER.warn("Can't get available values for field '" + this.getStoreName() + "." + this.getFieldName()+ "' from table '" + this.getTableName() + "', can't locate the stores-repository from the table.");

            return null;

        }

        if ((this.availableValues == null && this.loadAvailableValues) ||

                !StringUtils.equalsIgnoreCase(theStoresRepository.getID(), this.repositoryIDOfAvailableValues) ||

                !StringUtils.equalsIgnoreCase(theStoresRepository.getLabel(), this.repositoryLabelOfAvailableValues)

                ) {

            FeatureStore foreingStore = null;

            try {

                this.repositoryLabelOfAvailableValues = theStoresRepository.getLabel();

                this.repositoryIDOfAvailableValues = theStoresRepository.getID();

                foreingStore = (FeatureStore) theStoresRepository.getStore(

                        this.getTableName()

                );

                DataManager dataManager = DALLocator.getDataManager();

                Map<String,DynObjectValueItem[]> availableValuesCache = (Map<String,DynObjectValueItem[]>) dataManager.getProperty("FOREIGNKEY_AVAILABLE_VALUES_CACHE");

                if( availableValuesCache==null ) {

                    availableValuesCache = new HashMap<>();

                    dataManager.setProperty("FOREIGNKEY_AVAILABLE_VALUES_CACHE",availableValuesCache);

                }

                this.availableValues = availableValuesCache.get(foreingStore.getFullName());

                if( this.availableValues == null ) {

                    LOGGER.info("Loading available values for field '" + this.getStoreName() + "." + this.getFieldName()+ "' from table '" + this.getTableName() + "'/"+DataStore.getFullNameQuietly(foreingStore)+".");

                    this.availableValues = this.getAvailableValuesFromStore(foreingStore);

                    availableValuesCache.put(foreingStore.getFullName(),this.availableValues);

                }

            } catch (Exception ex) {

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

            } finally {

                this.loadAvailableValues = false;

                DisposeUtils.disposeQuietly(foreingStore);

            }

        }

        return this.availableValues;

    }

    private DynObjectValueItem[] getAvailableValuesFromStore(FeatureStore store) {

        DisposableFeatureSetIterable set = null;

        DynObjectValueItem[] values = null;

        try {

            Expression labelExpression = this.getLabelExpression(null);

            String theCodeName = this.getCodeName();

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

            MutableSymbolTable symbolTable = featureSymbolTable.createParent();

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

            if (count < 1) {

                LOGGER.warn("Can't get available values for field '" + this.getStoreName() + "." + this.getFieldName() + "' from table '" + this.getTableName() + "'(" + DataStore.getFullNameQuietly(store) + ").");

            }

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

            int n = 0;

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

                Object code = feature.get(theCodeName);

                Object value;

                if (labelExpression == null) {

                    value = code;

                } else {

                    featureSymbolTable.setFeature(feature);

                    try {

                        value = labelExpression.execute(symbolTable);

                    } catch (Exception ex) {

                        LOGGER.warn("Can't get label from table: " + this.tableName + " with expression: " + labelExpression.getPhrase(), ex);

                        values = null;

                        break;

                    }

                }

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

                if (n >= MAX_AVAILABLE_VALUES) {

                    break;

                }

            }

        } catch (Exception ex) {

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

        } finally {

            DisposeUtils.disposeQuietly(set);

        }

        return values;

    }

    private String getStoreName() {

        if (this.descriptor==null) {

            return "Unknown";

        }

        if (this.descriptor.getStore()==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;

    }

    public StoresRepository getStoresRepository(String tableName) {

            StoresRepository repository = this.getStoresRepository();

            FeatureStore store = null;

            if(descriptor != null) {

                store = descriptor.getStore();

            }

            if( store==null ) {

                return repository;

            } else {

                DataServerExplorer explorer = null;

                try {

                    DataManager dataManager = DALLocator.getDataManager();

                    explorer = store.getExplorer();

                    StoresRepository repo2 = dataManager.getStoresRepository().getSubrepository(explorer);

                    if( repo2!=null && repo2.contains(tableName)) {

                        return repo2;

                    }

                    DataStoreParameters params = explorer.get(tableName);

                    if( explorer.exists(params) ) {

                        String id = getRepositoryId(store, tableName); //tableName+"-"+dataManager.createUniqueID().replace("-", "");

                        BaseStoresRepository repo3 = new BaseStoresRepository(id, null, explorer.getParameters());

                        repo3.add(tableName, params);

                        return repo3;

                    }

                } catch (Exception ex) {

                    LOGGER.info("Can't access to table '"+tableName+"' near store "+store.getFullName()+", search in repositories.",ex);

                } finally {

                    DisposeUtils.disposeQuietly(explorer);

                }

                return repository;

            }

    }

    private String getRepositoryId(FeatureStore store, String tableName) {

        String id;

        if(store == null){

            DataManager dataManager = DALLocator.getDataManager();

            id = tableName+"-"+dataManager.createUniqueID().replace("-", "");

        } else {

            id = tableName + "-" + DigestUtils.md5Hex(store.getFullName());

        }

        return id;

    }

}