Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

import java.text.MessageFormat;

import java.util.Objects;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.fmap.geom.Geometry;

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

import static org.gvsig.expressionevaluator.ExpressionBuilder.PARAMETER_TYPE_VARIABLE;

import org.gvsig.expressionevaluator.ExpressionBuilder.AbstractValue;

import org.gvsig.expressionevaluator.ExpressionBuilder.Constant;

import org.gvsig.expressionevaluator.ExpressionBuilder.Function;

import static org.gvsig.expressionevaluator.ExpressionBuilder.PARAMETER_TYPE_CONSTANT;

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.ExpressionBuilder.Visitor;

import org.gvsig.expressionevaluator.ExpressionBuilder.VisitorFilter;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.expressionevaluator.impl.DefaultExpressionBuilder.FunctionBase;

import org.gvsig.expressionevaluator.impl.DefaultExpressionBuilder.ParameterBase;

import org.gvsig.fmap.geom.GeometryUtils;

import org.gvsig.expressionevaluator.GeometryExpressionBuilderHelper;

import static org.gvsig.expressionevaluator.GeometryExpressionBuilderHelper.PARAMETER_TYPE_GEOMETRY;

public class DefaultGeometryExpressionBuilderHelper 

        implements GeometryExpressionBuilderHelper {

    private static final String FORMAT_ST_SRID = "ST_SRID({0})";

    private static final String FORMAT_ST_ASTEXT = "ST_AsText({0})";

    private static final String FORMAT_ST_ASBINARY = "ST_AsBinary({0})";

    private static final String FORMAT_ST_ASEWKB = "ST_AsEWKB({0})";

    private static final String FORMAT_ST_CONTAINS = "ST_Contains(({0}), ({1}))";

    private static final String FORMAT_ST_CROSSES = "ST_Crosses(({0}), ({1}))";

    private static final String FORMAT_ST_DISJOINT = "ST_Disjoint(({0}), ({1}))";

    private static final String FORMAT_ST_EQUALS = "ST_Equals(({0}), ({1}))";

    private static final String FORMAT_ST_ISCLOSED = "ST_IsClosed({0})";

    private static final String FORMAT_ST_OVERLAPS = "ST_Overlaps(({0}), ({1}))";

    private static final String FORMAT_ST_TOUCHES = "ST_Touches(({0}), ({1}))";

    private static final String FORMAT_ST_WITHIN = "ST_Within(({0}), ({1}))";

    private static final String FORMAT_ST_ENVELOPE = "ST_Envelope({0})";

    private static final String FORMAT_ST_FORCE2D = "ST_Force2D({0})";

    private static final String FORMAT_ST_INTERSECTS = "ST_Intersects(({0}), ({1}))";

    private static final String FORMAT_ST_GEOMFROMTEXT = "ST_GeomFromText(({0}), ({1}))";

    private static final String FORMAT_ST_GEOMFROMWKB = "ST_GeomFromWKB(({0}), ({1}))";

    private static final String FORMAT_ST_GEOMFROMEWKB = "ST_GeomFromEWKB(({0}), ({1}))";

    private static final String FORMAT_ST_SIMPLIFY = "ST_Simplify(({0}), ({1}))";

    public static class GeometryParameterBase 

            extends ParameterBase 

            implements GeometryParameter {

        protected Value srs;

        protected GeometryExpressionBuilderHelper builder;

        /*

        Para un parametro de tipo Geometria, el srs sera siempre un Constant

        excepto cuando se le asigne una geometria contante al parametro y esta

        tenga un SRS asignado. En este caso, tanto la geometria como el SRS

        se trataran como parametros.

        Si se quiere que el SRS sea un Parameter, se construira como tal.

        */

        public GeometryParameterBase(GeometryExpressionBuilderHelper builder) {

            super();

            this.builder = builder;

        }

        @Override

        public void accept(Visitor visitor, VisitorFilter filter) {

            super.accept(visitor, filter);

            if (this.srs != null) {

                this.srs.accept(visitor, filter);

            }

        }

        @Override

        public void replace(Value target, Value replacement) {

            if( this.srs == target ) {

                this.srs = replacement;

            } else {

                this.srs.replace(target, replacement);

            }

        }

        @Override

        public GeometryParameter value(Object value) {

            if( value instanceof Geometry ) {

                if( this.srs == null ) {

                    IProjection proj = ((Geometry)value).getProjection();

                    this.srs(this.builder.parameter().value(proj));

                }

            }

            this.value = value;

            return this;

        }

        @Override

        public GeometryParameter srs(IProjection srs) {

            this.srs = new ProjectionConstant(this.builder, srs);

            if( this.type == PARAMETER_TYPE_VARIABLE ) {

                this.type = PARAMETER_TYPE_GEOMETRY;

            }

            return this;

        }

        @Override

        public GeometryParameter srs(Value srs) {

            this.srs = srs;

            if( this.type == PARAMETER_TYPE_VARIABLE ) {

                this.type = PARAMETER_TYPE_GEOMETRY;

            }

            return this;

        }

        @Override

        public Value srs() {

            return this.srs;

        }

        @Override

        public Geometry geometry() {

            return (Geometry) this.value;

        }

        @Override

        public GeometryParameter name(String value) {

            return (GeometryParameter) super.name(value);

        }

        @Override

        public GeometryParameter as_variable() {

            return (GeometryParameter) super.as_variable();

        }

        @Override

        public GeometryParameter as_geometry_variable() {

            this.type = PARAMETER_TYPE_GEOMETRY;

            if (this.value == null && this.name != null) {

                this.value = this.name;

            }

            return this;

        }

        @Override

        public boolean is_geometry_variable() {

            return this.type == PARAMETER_TYPE_GEOMETRY;

        }

        @Override

        public GeometryParameter as_constant() {

            return (GeometryParameter) super.as_constant();

        }

        @Override

        public String name() {

            if( this.type == PARAMETER_TYPE_VARIABLE ) {

                return this.name;

            }

            return super.name();

        }

        @Override

        public Object value() {

            try {

                switch (this.type) {

                    case PARAMETER_TYPE_CONSTANT:

                        if( this.value instanceof Geometry ) {

                            switch (this.builder.geometry_support_type()) {

                                case EWKB:

                                    return GeometryUtils.toEWKB(this.geometry());

                                case WKB:

                                    return GeometryUtils.toWKB(this.geometry());

                                case WKT:

                                default:

                                    return GeometryUtils.toWKT(this.geometry());

                            }

                        }

                        if( this.value instanceof IProjection ) {

                            return this.builder.srs_id((IProjection) this.value);

                        }

                        return this.value;

                    case PARAMETER_TYPE_VARIABLE:

                    case PARAMETER_TYPE_GEOMETRY:

                    default:

                        return this.name;

                }

            } catch (Exception ex) {

                throw new RuntimeException("Can't get value from parameter.", ex);

            }

        }

        @Override

        public String toString(Formatter<Value> formatter) {

            if( formatter!=null && formatter.canApply(this) ) {

                return formatter.format(this);

            }

            switch (this.type) {

                case PARAMETER_TYPE_CONSTANT:

                        if( this.value instanceof Geometry ) {

                            switch (this.builder.geometry_support_type()) {

                                case EWKB:

                                    return MessageFormat.format(

                                        FORMAT_ST_GEOMFROMEWKB,

                                        "?",

                                        this.getSRS(formatter)

                                    );

                                case WKB:

                                    return MessageFormat.format(

                                        FORMAT_ST_GEOMFROMWKB,

                                        "?",

                                        this.getSRS(formatter)

                                    );

                                case WKT:

                                default:

                                    return MessageFormat.format(

                                        FORMAT_ST_GEOMFROMTEXT,

                                        "?",

                                        this.getSRS(formatter)

                                    );

                            }

                        }

                case PARAMETER_TYPE_VARIABLE:

                default:

                    return "?";

                case PARAMETER_TYPE_GEOMETRY:

                    switch (this.builder.geometry_support_type()) {

                        case EWKB:

                            return MessageFormat.format(

                                FORMAT_ST_GEOMFROMEWKB,

                                "?",

                                getSRS(formatter)

                            );

                        case WKB:

                            return MessageFormat.format(

                                FORMAT_ST_GEOMFROMWKB,

                                "?",

                                getSRS(formatter)

                            );

                        case WKT:

                        default:

                            return MessageFormat.format(

                                FORMAT_ST_GEOMFROMTEXT,

                                "?",

                                getSRS(formatter)

                            );

                    }

            }

        }

        private String getSRS(Formatter formatter) {

            if( this.srs!=null ) {

                return this.srs.toString(formatter);

            }

            if( this.value instanceof Geometry ) {

                IProjection proj = ((Geometry)this.value).getProjection();

                Object s = this.builder.srs_id(proj);

                if( s == null ) {

                    throw new IllegalArgumentException("A parameter of type Geometry with an invalid SRS.");

                }

                return s.toString();

            }

            throw new IllegalArgumentException("The parameter of type Geometry need a SRS.");

        }

    }

//    

//    public static class ProjectionParameterBase 

//            extends ParameterBase 

//            implements Parameter {

//        

//        protected GeometryExpressionBuilderHelper builder;

//

//        public ProjectionParameterBase(GeometryExpressionBuilderHelper builder) {

//            this.builder = builder;

//        }

//

//        @Override

//        public Parameter value(Object value) {

//            if( !(value instanceof IProjection) ) {

//                throw new IllegalArgumentException("Only IProjection are allowed.");

//            }

//            return super.value(value);

//        }

//

//        @Override

//        public Object value() {

//            try {

//                switch (this.type) {

//                    case PARAMETER_TYPE_CONSTANT:

//                        return this.builder.srs_id((IProjection) this.value);

//                    case PARAMETER_TYPE_VARIABLE:

//                    default:

//                        return this.value;

//                }

//            } catch (Exception ex) {

//                throw new RuntimeException("Can't get value from parameter.", ex);

//            }

//        }        

//    }

    public static class GeometryConstant extends AbstractValue implements Constant {

        protected Geometry geometry;

        protected GeometryExpressionBuilderHelper builder;

        public GeometryConstant(GeometryExpressionBuilderHelper builder, Geometry geometry) {

            this.builder = builder;

            this.geometry = geometry;

        }

        @Override

        public String toString(Formatter<Value> formatter) {

            if( formatter!=null && formatter.canApply(this) ) {

                return formatter.format(this);

            }

            try {

                switch (this.builder.geometry_support_type()) {

                    case EWKB:

                        return MessageFormat.format(

                                FORMAT_ST_GEOMFROMEWKB,

                                "DECODE('"+this.builder.builder().bytearray_hex(GeometryUtils.toEWKB(geometry))+"','hex')",

                                this.getSRS()

                        );

                    case WKB:

                        return MessageFormat.format(

                                FORMAT_ST_GEOMFROMWKB,

                                "DECODE('"+this.builder.builder().bytearray_hex(GeometryUtils.toWKB(geometry))+"','hex')",

                                this.getSRS()

                        );

                    case WKT:

                    default:

                        return MessageFormat.format(

                                FORMAT_ST_GEOMFROMTEXT,

                                this.builder.builder().string(GeometryUtils.toWKT(geometry)),

                                this.getSRS()

                        );

                }

            } catch(Throwable th) {

                throw th;

            }

        }

        @Override

        public Object value() {

            return this.geometry;

        }

        private String getSRS() {

            IProjection proj = this.geometry.getProjection();

            Object s = this.builder.srs_id(proj);

            if( s == null ) {

                throw new IllegalArgumentException("A parameter of type Geometry with an invalid SRS.");

            }

            return s.toString();

        }

    }

    public static class ProjectionConstant extends AbstractValue implements Constant {

        protected IProjection projection;

        protected GeometryExpressionBuilderHelper builder;

        public ProjectionConstant(GeometryExpressionBuilderHelper builder, IProjection projection) {

            this.projection = projection;

            this.builder = builder;

        }

        @Override

        public String toString(Formatter<Value> formatter) {

            if( formatter!=null && formatter.canApply(this) ) {

                return formatter.format(this);

            }

            return Objects.toString(this.builder.srs_id(this.projection));

        }

        @Override

        public Object value() {

            return this.projection;

        }

    }

    protected GeometrySupportType geometrySupportType;

    protected ExpressionBuilder builder;

    public DefaultGeometryExpressionBuilderHelper(ExpressionBuilder builder) {

        this.builder = builder;

        this.geometrySupportType = GeometrySupportType.WKB;

    }

    public DefaultGeometryExpressionBuilderHelper() {

        this.geometrySupportType = GeometrySupportType.WKB;

    }

    @Override

    public ExpressionBuilder builder() {

        return this.builder;

    }

    @Override

    public GeometrySupportType geometry_support_type() {

        return this.geometrySupportType;

    }

    @Override

    public GeometryExpressionBuilderHelper geometry_support_type(GeometrySupportType geometrySupportType) {

        this.geometrySupportType = geometrySupportType;

        return this;

    }

    @Override

    public Object srs_id(IProjection projection) {

        if( projection==null ) {

            return 0;

        }

        return ProjectionUtils.getCode(projection);

    }

    @Override

    public Constant srs(IProjection projection) {

        return new ProjectionConstant(this, projection);

    }

    @Override

    public Constant geometry(Geometry geom, IProjection projection) {

        geom.setProjection(projection);

        return new GeometryConstant(this, geom);

    }

    @Override

    public Constant geometry(Geometry geom) {

        if( geom.getProjection()==null ) {

            throw new IllegalArgumentException("The geometry does not have an associated projection. Use 'geometry(Geometry, IProjection)'.");

        }

        return new GeometryConstant(this, geom);

    }

    @Override

    public Constant envelope(Envelope envelope, IProjection projection) {

        Geometry geom = envelope.getGeometry();

        geom.setProjection(projection);

        return new GeometryConstant(this, geom);

    }

    @Override

    public Constant envelope(Envelope envelope) {

        if( envelope.getProjection()==null ) {

            throw new IllegalArgumentException("The envelope does not have an associated projection. Use 'envelope(Geometry, IProjection)'.");

        }

        Geometry geom = envelope.getGeometry();

        return new GeometryConstant(this, geom);

    }

    @Override

    public GeometryParameter parameter() {

        GeometryParameterBase p = new GeometryParameterBase(this);

        return p;

    }

    @Override

    public GeometryParameter parameter(String name) {

        GeometryParameterBase p = new GeometryParameterBase(this);

        p.name(name);

        return p;

    }

    @Override

    public GeometryParameter parameter(Object value) {

        GeometryParameterBase p = new GeometryParameterBase(this);

        p.value(value);

        return p;

    }

    public Function builtin_function(String name, String format, Value... values) {

        FunctionBase func = new FunctionBase(name, format);

        for (Value theValue : values) {

            func.parameter(theValue);

        }

        return func;

    }    

    public Function function(String name, Value... values) {

        FunctionBase func = new FunctionBase(name);

        for (Value theValue : values) {

            func.parameter(theValue);

        }

        return func;

    }    

    @Override

    public Function as_geometry(Value value) {

        return builtin_function(FUNCTION_ST_ASBINARY, FORMAT_ST_ASBINARY, value);

    }

    @Override

    public Function ST_Intersects(Value geom1, Value geom2) {

        return builtin_function(FUNCTION_ST_INTERSECTS, FORMAT_ST_INTERSECTS, geom1, geom2);

    }

    @Override

    public Function ST_SRID(Value geom) {

        return builtin_function(FUNCTION_ST_SRID, FORMAT_ST_SRID, geom);

    }

    @Override

    public Function ST_Envelope(Value geom) {

        return builtin_function(FUNCTION_ST_ENVELOPE, FORMAT_ST_ENVELOPE, geom);

    }

    @Override

    public Function ST_Force2D(Value geom) {

        return builtin_function(FUNCTION_ST_FORCE2D, FORMAT_ST_FORCE2D, geom);

    }

    @Override

    public Function ST_AsText(Value geom) {

        return builtin_function(FUNCTION_ST_ASTEXT, FORMAT_ST_ASTEXT, geom);

    }

    @Override

    public Function ST_AsBinary(Value geom) {

        return builtin_function(FUNCTION_ST_ASBINARY, FORMAT_ST_ASBINARY, geom);

    }

    @Override

    public Function ST_AsEWKB(Value geom) {

        return builtin_function(FUNCTION_ST_ASEWKB, FORMAT_ST_ASEWKB, geom);

    }

    @Override

    public Function ST_GeomFromText(Value geom, Value crs) {

        return builtin_function(FUNCTION_ST_GEOMFROMTEXT, FORMAT_ST_GEOMFROMTEXT, geom, crs);

    }

    @Override

    public Function ST_GeomFromWKB(Value geom, Value crs) {

        return builtin_function(FUNCTION_ST_GEOMFROMWKB, FORMAT_ST_GEOMFROMWKB, geom, crs);

    }

    @Override

    public Function ST_GeomFromEWKB(Value geom, Value crs) {

        return builtin_function(FUNCTION_ST_GEOMFROMEWKB, FORMAT_ST_GEOMFROMEWKB, geom, crs);

    }

    @Override

    public Function ST_Simplify(Value geom, Value tolerance) {

        return builtin_function(FUNCTION_ST_SIMPLIFY, FORMAT_ST_SIMPLIFY, tolerance);

    }

    @Override

    public Function ST_Disjoint(Value geom1, Value geom2) {

        return builtin_function(FUNCTION_ST_DISJOINT, FORMAT_ST_DISJOINT, geom1, geom2);

    }

    @Override

    public Function ST_Contains(Value geom1, Value geom2) {

        return builtin_function(FUNCTION_ST_CONTAINS, FORMAT_ST_CONTAINS, geom1, geom2);

    }

    @Override

    public Function ST_Equals(Value geom1, Value geom2) {

        return builtin_function(FUNCTION_ST_EQUALS, FORMAT_ST_EQUALS, geom1, geom2);

    }

    @Override

    public Function ST_Crosses(Value geom1, Value geom2) {

        return builtin_function(FUNCTION_ST_CROSSES, FORMAT_ST_CROSSES, geom1, geom2);

    }

    @Override

    public Function ST_IsClosed(Value geom) {

        return builtin_function(FUNCTION_ST_ISCLOSED, FORMAT_ST_ISCLOSED, geom);

    }

    @Override

    public Function ST_Overlaps(Value geom1, Value geom2) {

        return builtin_function(FUNCTION_ST_OVERLAPS, FORMAT_ST_OVERLAPS, geom1, geom2);

    }

    @Override

    public Function ST_Touches(Value geom1, Value geom2) {

        return builtin_function(FUNCTION_ST_TOUCHES, FORMAT_ST_TOUCHES, geom1, geom2);

    }

    @Override

    public Function ST_Within(Value geom1, Value geom2) {

        return builtin_function("ST_Within", FORMAT_ST_WITHIN, geom1, geom2);

    }

    @Override

    public Function ST_Area(Value geom) {

        return function("ST_Area", geom);

    }

    @Override

    public Function ST_Buffer(Value geom) {

        return function("ST_Buffer", geom);

    }

    @Override

    public Function ST_Buffer(Value geom, Value dist) {

        return function("ST_Buffer", geom, dist);

    }

    @Override

    public Function ST_Centroid(Value geom) {

        return function("ST_Centroid", geom);

    }

    @Override

    public Function ST_CoveredBy(Value geom1, Value geom2) {

        return function("ST_CoveredBy", geom1, geom2);

    }

    @Override

    public Function ST_Covers(Value geom1, Value geom2) {

        return function("ST_Covers", geom1, geom2);

    }

    @Override

    public Function ST_Diference(Value geom1, Value geom2) {

        return function("ST_Diference", geom1, geom2);

    }

    @Override

    public Function ST_Dimension(Value geom) {

        return function("ST_Dimension", geom);

    }

    @Override

    public Function ST_Distance(Value geom1, Value geom2) {

        return function("ST_Distance", geom1, geom2);

    }

    @Override

    public Function ST_EndPoint(Value geom) {

        return function("ST_EndPoint", geom);

    }

    @Override

    public Function ST_Intersection(Value geom1, Value geom2) {

        return function("ST_Intersection", geom1, geom2);

    }

    @Override

    public Function ST_IsSimple(Value geom) {

        return function("ST_IsSimple", geom);

    }

    @Override

    public Function ST_IsValid(Value geom) {

        return function("ST_IsValid", geom);

    }

    @Override

    public Function ST_NumGeometries(Value geom) {

        return function("ST_NumGeometries", geom);

    }

    @Override

    public Function ST_NumPoints(Value geom) {

        return function("ST_NumPoints", geom);

    }

    @Override

    public Function ST_Perimeter(Value geom) {

        return function("ST_Perimeter", geom);

    }

    @Override

    public Function ST_PointN(Value geom, Value n) {

        return function("ST_PointN", geom, n);

    }

    @Override

    public Function ST_StartPoint(Value geom) {

        return function("ST_StartPoint", geom);

    }

    @Override

    public Function ST_Union(Value geom1, Value geom2) {

        return function("ST_Union", geom1, geom2);

    }

    @Override

    public Function ST_X(Value geom) {

        return function("ST_X", geom);

    }

    @Override

    public Function ST_Y(Value geom) {

        return function("ST_Y", geom);

    }

    @Override

    public Function ST_Z(Value geom) {

        return function("ST_Z", geom);

    }

    @Override

    public Function ST_ExtentAggregate(Value geom) {

       return function(FUNCTION_ST_EXTENTAGGREGATE, geom);

    }

    @Override

    public Function ST_UnionAggregate(Value geom) {

       return function(FUNCTION_ST_UNIONAGGREGATE, geom);

    }

    @Override

    public Function ST_Point(Value x, Value y) {

       return function(FUNCTION_ST_POINT, x, y);

    }

    @Override

    public Function ST_MakePoint(Value x, Value y) {

       return function(FUNCTION_ST_MAKEPOINT, x, y);

    }

    @Override

    public Function ST_MakePoint(Value x, Value y, Value z) {

       return function(FUNCTION_ST_MAKEPOINT, x, y, z);

    }

    @Override

    public Function ST_MakePoint(Value x, Value y, Value z, Value m) {

       return function(FUNCTION_ST_MAKEPOINT, x, y, z, m);

    }

    @Override

    public Function ST_SetSRID(Value geom, Value srid) {

       return function(FUNCTION_ST_POINT, geom, srid);

    }

}