Application: gvSIG desktop

package org.gvsig.sqlite.dal.expressionbuilderformatter;

import java.text.MessageFormat;

import java.util.List;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import static org.gvsig.expressionevaluator.GeometryExpressionBuilder.FUNCTION_ST_INTERSECTS;

import org.gvsig.expressionevaluator.ExpressionBuilder.Function;

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.fmap.dal.SQLBuilder;

import static org.gvsig.fmap.dal.SQLBuilder.PROP_FEATURE_TYPE;

import static org.gvsig.fmap.dal.SQLBuilder.PROP_QUERY;

import static org.gvsig.fmap.dal.SQLBuilder.PROP_TABLENAME;

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.sqlite.dal.geopackage.GeopackageUtils;

import org.gvsig.sqlite.dal.geopackage.index.GeopackageIndex;

/**

 *

 * @author jjdelcerro

 */

public class ST_Intersects implements Formatter<Value> {

    private final SQLBuilder sqlbuilder;

    private final Formatter<Value> formatter;

    public ST_Intersects(SQLBuilder sqlbuilder, Formatter<Value> formatter) {

        this.sqlbuilder = sqlbuilder;

        this.formatter = formatter;

    }

    @Override

    public boolean canApply(ExpressionBuilder.Value value) {

        if (value instanceof ExpressionBuilder.Function) {

            return StringUtils.equalsIgnoreCase(FUNCTION_ST_INTERSECTS, ((Function) value).name());

        }

        return false;

    }

    @Override

    public String format(Value function) {

        List<Value> parameters = ((Function) function).parameters();

        Value p1 = parameters.get(0);

        Value p2 = parameters.get(1);

        String p1s = p1.toString(formatter);

        String p2s = p2.toString(formatter);

        String filter = getBBoxIntersectsFilter(formatter, p1, p2);

        if (filter == null ) {         

            filter = getBBoxIntersectsFilter(formatter, p2, p1);

        }

        String r;

        if( filter == null ) {

            r = MessageFormat.format("ST_Intersects(({0}),({1}))", p1s, p2s);

        } else {

            r = MessageFormat.format("( ({2}) AND ST_Intersects(({0}),({1}) ))", p1s, p2s, filter);

//            r = MessageFormat.format("({0})", filter);

        }

        return r;

    }

    /*friend*/ static String getBBoxIntersectsFilter(Formatter<Value> formatter, Value column, Value expression) { 

        if( !(column instanceof ExpressionBuilder.Variable) ) { 

            return null;

        }

        String tableName = (String) column.getProperty(PROP_TABLENAME);

        if( StringUtils.isBlank(tableName) ) {

            return null;

        }

        FeatureType featureType = (FeatureType) column.getProperty(PROP_FEATURE_TYPE);

        if( featureType==null ) {

            return null;

        }

        FeatureAttributeDescriptor[] attrpk = featureType.getPrimaryKey();

        if( ArrayUtils.isEmpty(attrpk) || attrpk.length!=1 ) {

            return null;

        }

        FeatureAttributeDescriptor attrid = attrpk[0];

        ExpressionBuilder.Variable variable = (ExpressionBuilder.Variable) column;

        FeatureAttributeDescriptor attrgeom = featureType.getAttributeDescriptor(variable.name());

        if (attrgeom == null) {

            FeatureQuery query = (FeatureQuery) column.getProperty(PROP_QUERY);

            if( query == null ) {

                return null;

            }

            attrgeom = query.getExtraColumn().get(variable.name());

            if (attrgeom == null) {

                return null;

            }

        }

        GeopackageIndex index = GeopackageUtils.getIndexManager().getGeometryIndex(attrgeom);

        if( index == null ) {

            return null;

        }

        Code geomcode;

        ExpressionEvaluatorManager expressionManager = ExpressionEvaluatorLocator.getExpressionEvaluatorManager();

        try {

            geomcode = expressionManager.compile(expression.toString());

            MutableSymbolTable symbolTable = expressionManager.createSymbolTable();

            // Le pasamos el optimize para que resuelva las expresiones constantes

            // a ver si es una geometria.

            geomcode = expressionManager.optimize(symbolTable, geomcode);

        } catch(Exception ex) {

            return null;

        }        

        if( geomcode.code() == Code.CONSTANT ) {

            Object go = ((Code.Constant)geomcode).value();

            if( go instanceof Geometry ) {

                String filter = index.getBBoxIntersectsFilter(tableName, attrid.getName(), attrgeom.getName(), (Geometry)go);

                return filter;

            }

        }

        String filter = index.getBBoxIntersectsFilter(

                tableName, 

                attrid.getName(),

                attrgeom.getName(), 

                "ST_MinX("+expression.toString(formatter)+")",

                "ST_MinY("+expression.toString(formatter)+")",

                "ST_MaxX("+expression.toString(formatter)+")",

                "ST_MaxY("+expression.toString(formatter)+")"

        );

        return filter;

    }

}