Application: gvSIG desktop

package org.gvsig.app.project.symboltables;

import java.io.File;

import java.io.FileInputStream;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Properties;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.Range;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

import org.gvsig.app.project.Project;

import org.gvsig.app.project.ProjectManager;

import org.gvsig.app.project.documents.Document;

import org.gvsig.app.project.documents.view.ViewDocument;

import org.gvsig.app.project.documents.view.ViewManager;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.ExpressionRuntimeException;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.expressionevaluator.spi.AbstractGeometryFunction;

import org.gvsig.expressionevaluator.spi.AbstractSymbolTable;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.HasDataStore;

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

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

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

import org.gvsig.fmap.geom.primitive.Point;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.layers.FLayer;

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

import org.gvsig.fmap.mapcontrol.AreaAndPerimeterCalculator;

import org.gvsig.temporarystorage.TemporaryStorageGroup;

import org.gvsig.temporarystorage.TemporaryStorageLocator;

import org.gvsig.temporarystorage.TemporaryStorageManager;

import org.gvsig.tools.util.UnmodifiableBasicList;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class ProjectSymbolTable extends AbstractSymbolTable {

    public static final String PROJECT_GROUP = "Project";        

    public static final String AREA_NAME = "AREA";        

    public static final String PERIMETER_NAME = "PERIMETER";

    public static final String STORE_NAME = "STORE";

    public static final String FETCH_FIRST_NAME = "FETCH_FIRST";

    public static final String FETCH_FIRST_SELECTED_NAME = "FETCH_FIRST_SELECTED";

    public static final String FETCH_NAME = "FETCH";

    public static final String APPLICATION_NAME = "APPLICATION";

    static final String NAME = "Project";

    private static final String TABLE_DOCUMENT_TYPENAME = "project.document.table";

    private abstract class CachedValue<T> {

        T value = null;

        long lastAccess = 0;

        protected abstract void reload();

        public boolean isExpired() {

            long now = System.currentTimeMillis();

            return now - lastAccess > 3000;

        }

        public T get() {

            if (isExpired()) {

                reload();

            }

            lastAccess = System.currentTimeMillis();

            return value;

        }

    }

    private class ProjectValue extends CachedValue<Project> {

        @Override

        protected void reload() {

            value = ProjectManager.getInstance().getCurrentProject();

        }

    }

    private class CurrentViewValue extends CachedValue<ViewDocument> {

        @Override

        protected void reload() {

            ApplicationManager application = ApplicationLocator.getManager();

            ViewDocument viewdoc = (ViewDocument) application.getActiveDocument(ViewManager.TYPENAME);

            value = viewdoc;

        }

    }

    private class CurrentViewEnvelopeValue extends CachedValue<Geometry> {

        @Override

        protected void reload() {

            ApplicationManager application = ApplicationLocator.getManager();

            ViewDocument viewdoc = (ViewDocument) application.getActiveDocument(ViewManager.TYPENAME);

            if( viewdoc == null ) {

                value = null;

                return;

            }

            value = viewdoc.getMapContext().getViewPort().getEnvelope().getGeometry();

        }

    }

    private class PropertiesValue extends CachedValue<Map<File, Properties>> {

        @Override

        protected void reload() {

            value = new HashMap<>();

        }

    }

    private class CurrentProjectFunction extends AbstractFunction {

        public CurrentProjectFunction() {

            super(

                    PROJECT_GROUP,

                    "project",

                    Range.is(0),

                    "Access to the current project loaded in gvSIG desktop.\n",

                    "project()",

                    null,

                    "Project"

            );

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            return currentProject.get();

        }

    }

    private class ApplicationFunction extends AbstractFunction {

        public ApplicationFunction() {

            super(

                    PROJECT_GROUP,

                    APPLICATION_NAME,

                    Range.is(0),

                    "Access to the Application object.\n",

                    APPLICATION_NAME+"()",

                    null,

                    "ApplicationManager"

            );

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            return ApplicationLocator.getApplicationManager();

        }

    }

    private class StoreFunction extends AbstractFunction {

        public StoreFunction() {

            super(

                    PROJECT_GROUP,

                    STORE_NAME,

                    Range.is(2), // Range.between(1, 2),

                    "Return the data store associated with a layer.", // or a table.\n" +

//                       "If receive a single parameter, it will correspond to " + 

//                       "the name of a table-type document, and it will return " + 

//                       "your data store. If you receive two parameters, you expect " +

//                       "to be the name of a view and a layer of it, returning the " +

//                       "data store of the layer.",

                    STORE_NAME+"({{view}}, layer)",

                    new String[]{

                        "view - String value with the name of a view, if view is null use current View.",

                        "layer - String value with the name of a layer in the indicated view"

//                        "table - String value with the name of document table"

                    },

                    "DataStore"

            );

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            Project project = currentProject.get();

            switch (args.length) {

                case 1:

                    String tableName = getStr(args, 0);

                    Document document = project.getDocument(tableName, TABLE_DOCUMENT_TYPENAME);

                    if (document == null) {

                        throw new ExpressionRuntimeException("Problems calling '"+STORE_NAME+"' function, can't locate table document '"+tableName+"'.");

//                        return null;

                    }

                    if( document instanceof HasDataStore ) {

                        return ((HasDataStore) document).getDataStore();

                    }

                    throw new ExpressionRuntimeException("Problems calling '"+STORE_NAME+"' function, can't get store from table document '"+tableName+"'.");

//                    return null;

                case 2:

                    ViewDocument view;

                    String viewName = getStr(args, 0);

                    if( StringUtils.isBlank(viewName) ) {

                        view = (ViewDocument) project.getActiveDocument(ViewManager.TYPENAME);

                        if (view == null) {

                            throw new ExpressionRuntimeException("Problems calling '"+STORE_NAME+"' function, can't locate active View.");

//                            return null;

                        }

                    } else {

                        view = (ViewDocument) project.getDocument(viewName, ViewManager.TYPENAME);

                        if (view == null) {

                            throw new ExpressionRuntimeException("Problems calling '"+STORE_NAME+"' function, can't locate View '"+viewName+"'.");

//                            return null;

                        }

                    }

                    String layerName = getStr(args, 1);

                    FLayer layer = view.getLayer(layerName);

                    if( layer == null ) {

                        throw new ExpressionRuntimeException("Problems calling '"+STORE_NAME+"' function, can't locate layer '"+layerName+"' in View '"+viewName+"'.");

                    }

                    if( layer instanceof HasDataStore ) {

                        return ((HasDataStore)layer).getDataStore();

                    }

                    throw new ExpressionRuntimeException("Problems calling '"+STORE_NAME+"' function, can't get the store from layer '"+layerName+"' in View '"+viewName+"'.");

//                    return null;

            }

            return null;

        }

    }

    private class FetchFunction extends AbstractFunction {

        public FetchFunction() {

            super(

                    PROJECT_GROUP,

                    FETCH_NAME,

                    Range.between(2, 4),

                    "Access to the features of a table and retuen a list with the values.",

                    FETCH_NAME+"({{value}}, store, where, order)",

                    new String[]{

                        "value - value to retrieve from the store, usually an expression in the columns of this are involved.",

                        "store - data store from which values will be collected",

                        "where - Optional. String value with a filter expression",

                        "order - Optional. String value with the order. must be a string with the names of separate fields with commas"

                    },

                    "Object"

            );

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            Object value;

            String where = null;

            String order = null;

            String expression_s = getStr(args, 0);

            FeatureStore store = (FeatureStore) getObject(args, 1);

            switch (args.length) {

                case 3:

                    where = getStr(args, 2);

                    break;

                case 4:

                    where = getStr(args, 2);

                    order = getStr(args, 3);

                    break;

            }

            try {

                List<Feature> features;

                if (where == null && order == null) {

                    features = store.getFeatures();

                } else {

                    FeatureQuery query = store.createFeatureQuery();

                    if (where != null) {

                        query.addFilter(where);

                    }

                    if (order != null) {

                        query.getOrder().add(order);

                    }

                    query.retrievesAllAttributes();

                    features = store.getFeatures(query);

                }

                UnmodifiableBasicList<Object> list = new ListOfFeaturesWrapper(

                        features,

                        interpreter.getSymbolTable(), 

                        expression_s

                );

                return list;

            } catch (Exception ex) {

                throw new ExpressionRuntimeException("Problems calling '"+FETCH_NAME+"' function", ex);

            }

        }

    }

    private class FetchFirstFunction extends AbstractFunction {

        public FetchFirstFunction() {

            super(

                    PROJECT_GROUP,

                    FETCH_FIRST_NAME,

                    Range.between(2, 4),

                    "Access to the first feature of the layer, and "

                    + "return the value of the attribute.",

                    FETCH_FIRST_NAME+"({{value}}, store, where, order)",

                    new String[]{

                        "value - value to retrieve from the store, usually an expression in the columns of this are involved.",

                        "store - data store from which values will be collected",

                        "where - Optional. String value with a filter expression",

                        "order - Optional. String value with the order. must be a string with the names of separate fields with commas"

                    },

                    "Object"

            );

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            Object value;

            String where = null;

            String order = null;

            String expression_s = getStr(args, 0);

            FeatureStore store = (FeatureStore) getObject(args, 1);

            if( store == null ) {

                throw new ExpressionRuntimeException("Problems calling '"+FETCH_FIRST_NAME+"' function, the store is null.");

            }

            switch (args.length) {

                case 3:

                    where = getStr(args, 2);

                    break;

                case 4:

                    where = getStr(args, 2);

                    order = getStr(args, 3);

                    break;

            }

            try {

                FeatureSet set;

                if (where == null && order == null) {

                    set = store.getFeatureSet();

                } else {

                    FeatureQuery query = store.createFeatureQuery();

                    if (where != null) {

                        query.addFilter(where);

                    }

                    if (order != null) {

                        query.getOrder().add(order);

                    }

                    query.retrievesAllAttributes();

                    set = store.getFeatureSet(query);

                }

                Feature feature = set.first();

                if (feature == null) {

                    return null;

                }

                DataManager dataManager = DALLocator.getDataManager();

                FeatureSymbolTable symbolTable = dataManager.createFeatureSymbolTable();

                symbolTable.setFeature(feature);

                ExpressionEvaluatorManager expManager = ExpressionEvaluatorLocator.getManager();

                Expression expression = expManager.createExpression();

                expression.setPhrase(expression_s);

                value = expression.execute(symbolTable.createParent());

                return value;

            } catch (Exception ex) {

                throw new ExpressionRuntimeException("Problems calling '"+FETCH_FIRST_NAME+"' function", ex);

            }

        }

    }

    private class FetchFirstSelectedFunction extends AbstractFunction {

        public FetchFirstSelectedFunction() {

            super(

                    PROJECT_GROUP,

                    FETCH_FIRST_SELECTED_NAME,

                    Range.is(2),

                    "Access to the first feature of the selection.",

                    FETCH_FIRST_SELECTED_NAME+"({{value}}, store)",

                    new String[]{

                        "value - value to retrieve from the store, usually an expression in the columns of this are involved.",

                        "store - data store from which values will be collected"

                    },

                    "Object"

            );

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            String expression_s = getStr(args, 0);

            FeatureStore store = (FeatureStore) getObject(args, 1);

            try {

                FeatureSet set = store.getFeatureSelection();

                Feature feature = set.first();

                if (feature == null) {

                    return null;

                }

                DataManager dataManager = DALLocator.getDataManager();

                FeatureSymbolTable symbolTable = dataManager.createFeatureSymbolTable();

                symbolTable.setFeature(feature);

                ExpressionEvaluatorManager expManager = ExpressionEvaluatorLocator.getManager();

                Expression expression = expManager.createExpression();

                expression.setPhrase(expression_s);

                Object value = expression.execute(symbolTable.createParent());

                return value;

            } catch (Exception ex) {

                throw new ExpressionRuntimeException("Problems calling '"+FETCH_FIRST_SELECTED_NAME+"' function", ex);

            }

        }

    }

    private class ViewFunction extends AbstractFunction {

        public ViewFunction() {

            super(

                    PROJECT_GROUP,

                    "view",

                    Range.is(1),

                    "Access to the indicated view",

                    "view({{viewName}})",

                    new String[]{

                        "view - String value with the name of a view"

                    },

                    "DocumentView"

            );

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            String viewName = getStr(args, 0);

            Project project = currentProject.get();

            ViewDocument view = (ViewDocument) project.getDocument(viewName, ViewManager.TYPENAME);

            return view;

        }

    }

    private class ViewBBoxFunction extends AbstractFunction {

        public ViewBBoxFunction() {

            super(

                    PROJECT_GROUP,

                    "viewbbox",

                    Range.is(0),

                    "Return the BBox of the active view.",

                    "viewbbox()",

                    null,

                    "Geometry"

            );

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            return currentViewEnvelope.get();

        }

    }

    private class SavedPointFunction extends AbstractFunction {

        public SavedPointFunction() {

            super(

                    PROJECT_GROUP,

                    "savedpoint",

                    Range.is(1),

                    "Return the value of the saved point with the name indicated.\n"

                            + "If the named point do not exists return null.",

                    "savedpoint({{name}})",

                    new String[]{

                        "name - String value with the name of the point"

                    },

                    "Geometry"

            );

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            TemporaryStorageManager manager = TemporaryStorageLocator.getTemporaryStorageManager();

            TemporaryStorageGroup storage = manager.create("Points",Point.class);

            Geometry value = (Geometry) storage.get(getStr(args, 0));

            return value;

        }

    }

    private  class AreaFunction extends AbstractGeometryFunction {

        public AreaFunction() {

            super(

                    PROJECT_GROUP,

                    AREA_NAME,

                    Range.between(2,3),

                    "Calculate the area of the geometry in the indicated units",

                    AREA_NAME+"({{geometry}}, 'm?')",

                    new String[]{

                        "geometry - Geometry",

                        "Projection - Optional. Projection of the geometry or a string with the projection name",

                        "units - String value with the name the units to use"

                    },

                    "Double"

            );

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            int units = 0;

            IProjection proj = null;

            Geometry geom = getGeom(args, 0);

            switch( args.length ) {

                case 2:

                    units = getUnitsArea(args, 1);

                    break;

                case 3:

                    proj = getProjection(args, 1);

                    units = getUnitsArea(args, 2);

                    break;

            }

            if (proj == null) {

                proj = geom.getProjection();

            }

            AreaAndPerimeterCalculator calculator = new AreaAndPerimeterCalculator();

            double area = calculator.area(geom, proj, units);

            return area;

        }

    }

    private class PerimeterFunction extends AbstractGeometryFunction {

        public PerimeterFunction() {

            super(

                    PROJECT_GROUP,

                    PERIMETER_NAME,

                    Range.between(2,3),

                    "Calculate the perimeter of the geometry in the indicated units",

                    PERIMETER_NAME+"({{geometry}}, 'm')",

                    new String[]{

                        "geometry - Geometry",

                        "Projection - Optional. Projection of the geometry or a string with the projection name",

                        "units - String value with the name the units to use"

                    },

                    "Double"

            );

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            int units = 0;

            IProjection proj = null;

            Geometry geom = getGeom(args, 0);

            switch( args.length ) {

                case 2:

                    units = getUnitsArea(args, 1);

                    break;

                case 3:

                    proj = getProjection(args, 1);

                    units = getUnitsArea(args, 2);

                    break;

            }

            if (proj == null) {

                proj = geom.getProjection();

            }

            AreaAndPerimeterCalculator calculator = new AreaAndPerimeterCalculator();

            double area = calculator.perimeter(geom, proj, units);

            return area;

        }

    }

    private class PropertyFunction extends AbstractFunction {

        public PropertyFunction() {

            super(

                    PROJECT_GROUP,

                    "property",

                    Range.between(2, 3),

                    "Access to a property value in a properties file. If the"

                    + "indicated filename is not absolute, access it relative"

                    + "to the project.",

                    "property({{filename}}, name, defaultValue)",

                    new String[]{

                        "filename - String value with the name of the properties file",

                        "name - String value with the name of the property to retrieve from the file",

                        "defaultValue - Optional. Default value if can't access the file or the property",},

                    "String"

            );

        }

        @Override

        public Object call(Interpreter interpreter, Object[] args) throws Exception {

            String filename = getStr(args, 0);

            String name = getStr(args, 1);

            String defaultValue = null;

            if (args.length == 3) {

                defaultValue = getStr(args, 2);

            }

            File file = new File(filename);

            if (!file.isAbsolute()) {

                Project project = currentProject.get();

                if (project.getFile() == null) {

                    return defaultValue;

                }

                file = new File(project.getFile().getParent(), filename);

            }

            Map<File, Properties> x = propertiesFiles.get();

            Properties properties = x.get(file);

            if (properties == null) {

                properties = new Properties();

                FileInputStream in = null;

                try {

                    in = new FileInputStream(file);

                    properties.load(in);

                } catch (Exception ex) {

                    return defaultValue;

                } finally {

                    IOUtils.closeQuietly(in);

                }

                x.put(file, properties);

            }

            String value = properties.getProperty(name, defaultValue);

            return value;

        }

    }

    ProjectValue currentProject = new ProjectValue();

    CurrentViewValue currentView = new CurrentViewValue();

    CurrentViewEnvelopeValue currentViewEnvelope = new CurrentViewEnvelopeValue();

    PropertiesValue propertiesFiles = new PropertiesValue();

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public ProjectSymbolTable() {

        super(NAME);

        this.addFunction(new CurrentProjectFunction());

        this.addFunction(new StoreFunction());

        this.addFunction(new FetchFunction());

        this.addFunction(new FetchFirstFunction());

        this.addFunction(new FetchFirstSelectedFunction());

        this.addFunction(new ViewFunction());

        this.addFunction(new ViewBBoxFunction());

        this.addFunction(new PropertyFunction());

        this.addFunction(new AreaFunction());

        this.addFunction(new PerimeterFunction());

        this.addFunction(new SavedPointFunction());

        this.addFunction(new ApplicationFunction());

    }

    private MapContext getMapContext(Feature feature) {

        FeatureStore store = feature.getStore();

        Project project = ProjectManager.getInstance().getCurrentProject();

        project.getDocuments(ViewManager.TYPENAME);

        for (Document document : project.getDocuments(ViewManager.TYPENAME)) {

            ViewDocument view = (ViewDocument) document;

            MapContext mapContext = view.getMapContext();

            FLayer layer = getLayer(mapContext, store);

            if (layer != null) {

                return mapContext;

            }

        }

        return null;

    }

    private FLayer getLayer(MapContext mapContext, FeatureStore store) {

        Iterator<FLayer> it = mapContext.deepiterator();

        while (it.hasNext()) {

            FLayer layer = it.next();

            if (layer instanceof FLyrVect) {

                FeatureStore layer_store = ((FLyrVect) layer).getFeatureStore();

                if (layer_store == store) {

                    return layer;

                }

            }

        }

        return null;

    }

    private IProjection getProjection(Object[] args, int i) {

        Object value = args[i];

        if (value == null) {

            return null;

        }

        if (value instanceof IProjection) {

            return (IProjection) value;

        }

        String code = value.toString();

        return CRSFactory.getCRS(code);

    }

    private int getUnitsArea(Object[] args, int i) {

        Object value = args[i];

        if (value == null) {

            throw new IllegalArgumentException("Illegal unit value 'null'");

        }

        if (value instanceof Number) {

            return ((Number) value).intValue();

        }

        String name = value.toString();

        String[] names = MapContext.getAreaAbbr();

        for (int j = 0; j < names.length; j++) {

            if (name.equalsIgnoreCase(names[j])) {

                return j;

            }

        }

        names = MapContext.getAreaNames();

        for (int j = 0; j < names.length; j++) {

            if (name.equalsIgnoreCase(names[j])) {

                return j;

            }

        }

        throw new IllegalArgumentException("Illegal unit name '" + name + "'");

    }

    private int getUnitsDistance(Object[] args, int i) {

        Object value = args[i];

        if (value == null) {

            throw new IllegalArgumentException("Illegal unit value 'null'");

        }

        if (value instanceof Number) {

            return ((Number) value).intValue();

        }

        String name = value.toString();

        String[] names = MapContext.getDistanceAbbr();

        for (int j = 0; j < names.length; j++) {

            if (name.equalsIgnoreCase(names[j])) {

                return j;

            }

        }

        names = MapContext.getDistanceNames();

        for (int j = 0; j < names.length; j++) {

            if (name.equalsIgnoreCase(names[j])) {

                return j;

            }

        }

        throw new IllegalArgumentException("Illegal unit name '" + name + "'");

    }

}