Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import org.apache.commons.lang3.ObjectUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Code;

import static org.gvsig.expressionevaluator.Code.CALLER;

import static org.gvsig.expressionevaluator.Code.CONSTANT;

import static org.gvsig.expressionevaluator.Code.IDENTIFIER;

import static org.gvsig.expressionevaluator.Code.UNDEFINED;

import static org.gvsig.expressionevaluator.Code.CODES;

import org.gvsig.expressionevaluator.Code.Caller;

import org.gvsig.expressionevaluator.Code.Constant;

import static org.gvsig.expressionevaluator.Code.EMPTY_FORMATTER;

import org.gvsig.expressionevaluator.Code.Identifier;

import org.gvsig.expressionevaluator.Code.Method;

//import org.gvsig.expressionevaluator.Code.Method;

import org.gvsig.expressionevaluator.CodeBuilder;

import org.gvsig.expressionevaluator.Codes;

import org.gvsig.expressionevaluator.ExpressionBuilder;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.expressionevaluator.impl.function.programming.CallMethodFunction;

import org.gvsig.expressionevaluator.impl.function.programming.GetattrFunction;

import org.gvsig.expressionevaluator.impl.function.programming.GetitemFunction;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.exception.DynMethodNotSupportedException;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.script.Script;

import org.gvsig.tools.visitor.Visitor;

@SuppressWarnings("UseSpecificCatch")

public class DefaultCodeBuilder implements CodeBuilder {

    public abstract class BaseCode implements Code {

        @Override

        public int code() {

            return UNDEFINED;

        }

        @Override

        public void accept(Visitor visitor) throws BaseException {

            visitor.visit(this);

        }

        @Override

        public Value toValue(ExpressionBuilder builder) {

            return null;

        }

        @Override

        public Value toValue() {

            ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

            return this.toValue(builder);

        }

        @Override

        public void link(SymbolTable symbolTable) {

            if( this.code() == Code.CALLER ) {

                Caller caller = (Caller) this;

                if( caller.function() == null ) {

                    caller.function(symbolTable.function(caller.name()));

                }

                if( caller.parameters() != null ) {

                    for( Code arg : caller.parameters() ) {

                        arg.link(symbolTable);

                    }

                }

            }

        }

    }

    class BaseConstant extends BaseCode implements Constant {

        private Object value;

        public BaseConstant(Object value) {

            this.value = value;

        }

        @Override

        public int code() {

            return CONSTANT;

        }

        @Override

        public Object value() {

            return this.value;

        }

        public void value(Object v) {

            this.value = v;

        }

        @Override

        public Value toValue(ExpressionBuilder builder) {

            return builder.constant(this.value);

        }

        @Override

        public String toString() {

            return this.toString(EMPTY_FORMATTER);

        }

        @Override

        public String toString(Formatter<Code> formatter) {

            if( formatter.canApply(this) ) {

                return formatter.format(this);

            }

            StringBuilder builder = new StringBuilder();

            Object v = this.value();

            if( v == null ) {

                builder.append("NULL");

            } else if( v instanceof CharSequence ) {

                if( StringUtils.isEmpty((CharSequence)v) ) {

                    builder.append("''");

                } else {

                    v = "'" + StringUtils.replace(v.toString(), "'", "''") + "'";

                    builder.append(v);

                }

            } else if( v instanceof Boolean ) {

                builder.append(((Boolean)v).toString().toUpperCase());

            } else if( v instanceof Geometry ) {

                try {

                    builder.append("'");

                    builder.append(((Geometry) v).convertToWKT());

                    builder.append("'::geometry");

                } catch (Exception ex) {

                    builder.append("'UNKNOW'::geometry");

                }

            } else {

                builder.append(v);

            }

            return builder.toString();

        }

    }

    public interface RecursionControlSupport {

        public boolean enterCode(int max);

        public void exitCode();

        public void resetRecursionState();

    }

    private class RecursionSupport implements RecursionControlSupport {

        private int counter;

        public RecursionSupport() {

            this.counter = 0;

        }

        @Override

        public boolean enterCode(int max) {

            this.counter += 1;

            return this.counter < max;

        }

        @Override

        public void exitCode() {

            this.counter -= 1;

        }

        @Override

        public void resetRecursionState() {

            this.counter = 0;

        }

    }

    public class BaseIdentifier extends BaseCode implements Identifier, RecursionControlSupport {

        private final String name;

        private final RecursionSupport recursionSupport;

        public BaseIdentifier(String name) {

            this.name = name;

            this.recursionSupport = new RecursionSupport();

        }

        @Override

        public int code() {

            return IDENTIFIER;

        }

        @Override

        public String name() {

            return this.name;

        }

        @Override

        public Value toValue(ExpressionBuilder builder) {

            return builder.variable(this.name);

        }

        @Override

        public String toString() {

            return this.toString(EMPTY_FORMATTER);

        }

        @Override

        public String toString(Formatter<Code> formatter) {

            if( formatter.canApply(this) ) {

                return formatter.format(this);

            }

            StringBuilder builder = new StringBuilder();

            builder.append("\"");

            builder.append(this.name());

            builder.append("\"");

            return builder.toString();

        }

        @Override

        public boolean enterCode(int max) {

            return this.recursionSupport.enterCode(max);

        }

        @Override

        public void exitCode() {

            this.recursionSupport.exitCode();

        }

        @Override

        public void resetRecursionState() {

            this.recursionSupport.resetRecursionState();

        }

    }

    public class BaseCodes implements Codes {

        private final List<Code> codes;

        public BaseCodes() {

            this.codes = new ArrayList<>();

        }

        @Override

        public int code() {

            return CODES;

        }

        @Override

        public int size() {

            if( codes == null ) {

                return 0;

            }

            return this.codes.size();

        }

        public void add(Code arg) {

            this.codes.add(arg);

        }

        public void insert(int pos, Code arg) {

            this.codes.add(pos, arg);

        }

        @Override

        public Iterator<Code> iterator() {

            return this.codes.iterator();

        }

        @Override

        public Code get(int n) {

            return this.codes.get(n);

        }

        @Override

        public boolean isEmpty() {

            return this.codes.isEmpty();

        }

        @Override

        public List<Code> toList() {

            return Collections.unmodifiableList(this.codes);

        }

        @Override

        public void accept(Visitor visitor) throws BaseException {

            for( Code arg : this.codes ) {

                arg.accept(visitor);

            }

        }

        @Override

        public String toString() {

            return this.toString(EMPTY_FORMATTER);

        }

        @Override

        public Value toValue(ExpressionBuilder builder) {

            throw new UnsupportedOperationException();

        }

        @Override

        public Value toValue() {

            throw new UnsupportedOperationException();

        }

        @Override

        public String toString(Formatter<Code> formatter) {

            if( formatter.canApply(this) ) {

                return formatter.format(this);

            }

            if( codes != null ) {

                StringBuilder builder = new StringBuilder();

                boolean skipcoma = true;

                for( Code code : codes ) {

                    if( code == null ) {

                        continue;

                    }

                    if( skipcoma ) {

                        skipcoma = false;

                    } else {

                        builder.append(", ");

                    }

                    builder.append(code.toString(formatter));

                }

                return builder.toString();

            }

            return "";

        }

        @Override

        public void link(SymbolTable symbolTable) {

            for (Code code : this.codes) {

                code.link(symbolTable);

            }

        }

    }

    public class BaseCaller extends BaseCode implements Caller, RecursionControlSupport {

        private final String name;

        private final Codes args;

        private Function function;

        private final int type;

        private final RecursionSupport recursionSupport;

        public BaseCaller(String name, int type, Codes args) {

            this.name = name;

            this.args = args;

            this.type = type;

            this.function = null;

            this.recursionSupport = new RecursionSupport();

        }

        @Override

        public int code() {

            return CALLER;

        }

        @Override

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

            return this.function.call(interpreter, args);

        }

        @Override

        public String name() {

            return this.name;

        }

        @Override

        public Function function() {

            return this.function;

        }

        @Override

        public Function function(Function function) {

            this.function = function;

            return this.function;

        }

        @Override

        public Codes parameters() {

            return this.args;

        }

        @Override

        public int type() {

            return this.type;

        }

        @Override

        public void accept(Visitor visitor) throws BaseException {

            visitor.visit(this);

            if(this.args!=null) {

                this.args.accept(visitor);

            }

        }

        @Override

        public Value toValue(ExpressionBuilder builder) {

            switch(this.type) {

                case UNARY_OPERATOR:

                    return builder.function(

                            OPERATOR_NEGATE.equalsIgnoreCase(this.name())?

                                "-" :

                                this.name(),

                            this.parameters().get(0).toValue(builder)

                    );

                case BINARY_OPERATOR:

                    return builder.binaryOperator(

                            this.name(),

                            this.parameters().get(0).toValue(builder),

                            this.parameters().get(1).toValue(builder)

                    );

                case FUNCTION:

                default:

                    ExpressionBuilder.Function f = builder.function(this.name());

                    if( this.parameters()!=null ) {

                        for (Code parameter : this.parameters()) {

                            f.parameter(parameter.toValue(builder));

                        }

                    }

                    return f;

            }

        }

        @Override

        public String toString() {

            return this.toString(EMPTY_FORMATTER);

        }

        @Override

        public String toString(Formatter<Code> formatter) {

            if( formatter.canApply(this) ) {

                return formatter.format(this);

            }

            Code code;

            StringBuilder builder = new StringBuilder();

            switch(this.type) {

                case UNARY_OPERATOR:

                    if( OPERATOR_NEGATE.equalsIgnoreCase(this.name()) ) {

                        builder.append("-");

                    } else {

                        builder.append(this.name());

                    }

                    builder.append("(");

                    builder.append(this.parameters().get(0).toString(formatter));

                    builder.append(")");

                    break;

                case BINARY_OPERATOR:

                    builder.append("(");

                    code = this.parameters().get(0);

                    if( code == null ) {                    

                        builder.append("?NULL?");

                    } else {

                        builder.append(code.toString(formatter));

                    }

                    builder.append(" ");

                    builder.append(this.name());

                    builder.append(" ");

                    code = this.parameters().get(1);

                    if( code == null ) {                    

                        builder.append("?NULL?");

                    } else {

                        builder.append(code.toString(formatter));

                    }

                    builder.append(")");

                    break;

                case FUNCTION:

                default:

                    builder.append(this.name());

                    builder.append("(");

                    if( this.parameters()!=null ) {

                        builder.append(this.parameters().toString(formatter));

                    }

                    builder.append(")");

            }

            return builder.toString();

        }

        @Override

        public boolean enterCode(int max) {

            return this.recursionSupport.enterCode(max);

        }

        @Override

        public void exitCode() {

            this.recursionSupport.exitCode();

        }

        @Override

        public void resetRecursionState() {

            this.recursionSupport.resetRecursionState();

        }

    }

    public class BaseMethod extends BaseCode implements Method {

        private final Code instance;

        private final String methodname;

        private final Codes args;

        public BaseMethod(Code instance, String methodname, Codes args) {

            this.instance = instance;

            this.methodname = methodname;

            this.args = args;

        }

        @Override

        public int code() {

            return METHOD;

        }

        @Override

        public String methodname() {

            return this.methodname;

        }

        @Override

        public Code instance() {

            return this.instance;

        }

        @Override

        public Codes parameters() {

            return this.args;

        }

        @Override

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

            Object theInstance = interpreter.run(instance);

            if( theInstance instanceof SimpleScript ) {

                try {

                    return ((SimpleScript)theInstance).invokeFunction(methodname, args);

                } catch(NoSuchMethodException ex) {

                    // Ignore... continue calling instance method

                }                

            } else if( theInstance instanceof DynObject ) {

                DynObject dynobj = (DynObject) theInstance;

                try {

                    return dynobj.invokeDynMethod(methodname, args);

                } catch(DynMethodNotSupportedException ex) {

                    // Ignore... continue calling instance method

                }

            }

            return InstanceUtils.callmethod(theInstance, methodname, args);

        }

        @Override

        public String toString() {

            return this.toString(EMPTY_FORMATTER);

        }

        @Override

        public Value toValue(ExpressionBuilder builder) {

            ExpressionBuilder.Method m = builder.method(this.instance.toValue(builder), this.methodname);

            if( this.parameters()!=null ) {

                for (Code parameter : this.parameters()) {

                    m.parameter(parameter.toValue(builder));

                }

            }

            return m;

        }

        @Override

        public String toString(Formatter<Code> formatter) {

            if( formatter.canApply(this) ) {

                return formatter.format(this);

            }

            StringBuilder builder = new StringBuilder();

            builder.append(this.instance.toString(formatter));

            builder.append("->");

            builder.append(this.methodname());

            builder.append("(");

            if( this.parameters()!=null ) {

                builder.append(this.parameters().toString(formatter));

            }

            builder.append(")");

            return builder.toString();

        }

    }    

    @Override

    public CodeBuilder clone() throws CloneNotSupportedException {

        // This implementation of CodeBuilder does not maintain state, so 

        // we only call the super class.

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

        return other;

    }

    @Override

    public Constant constant(Object value) {

        return new BaseConstant(value);

    }

    @Override

    public Identifier identifier(String name) {

        return new BaseIdentifier(name);

    }

    @Override

    public BaseCodes args() {

        return new BaseCodes();

    }

    @Override

    public Caller function(String name, int type, Codes args) {

        return new BaseCaller(name, type, args);

    }

    @Override

    public Caller function(String name, Codes args) {

        return function(name, Caller.FUNCTION, args);

    }

    @Override

    public Code method(Code instance, String methodname, Codes methodargs) {

        Method m = new BaseMethod(instance, methodname, methodargs);

        return m;

    }

    @Override

    public Caller operator(String name, Code arg1) {

        BaseCodes args = args();

        args.add(arg1);

        return function(name, Caller.UNARY_OPERATOR, args);

    }

    @Override

    public Caller operator(String name, Code arg1, Code arg2) {

        BaseCodes args = args();

        args.add(arg1);

        args.add(arg2);

        return function(name, Caller.BINARY_OPERATOR, args);

    }

    @Override

    public Code not(Code op1) {

        return operator(OPERATOR_NOT, op1);

    }

    @Override

    public Code negate(Code op1) {

        return operator(OPERATOR_NEGATE, op1);

    }

    @Override

    public Code concat(Code op1, Code op2) {

        return operator(OPERATOR_CONCAT, op1, op2);

    }

    @Override

    public Code add(Code op1, Code op2) {

        return operator(OPERATOR_ADD, op1, op2);

    }

    @Override

    public Code subst(Code op1, Code op2) {

        return operator(OPERATOR_SUBST, op1, op2);

    }

    @Override

    public Code mult(Code op1, Code op2) {

        return operator(OPERATOR_MULT, op1, op2);

    }

    @Override

    public Code div(Code op1, Code op2) {

        return operator(OPERATOR_DIV, op1, op2);

    }

    @Override

    public Code mod(Code op1, Code op2) {

        return operator(OPERATOR_MOD, op1, op2);

    }

    @Override

    public Code or(Code op1, Code op2) {

        return operator(OPERATOR_OR, op1, op2);

    }

    @Override

    public Code and(Code op1, Code op2) {

        return operator(OPERATOR_AND, op1, op2);

    }

    @Override

    public Code like(Code op1, Code op2) {

        return operator(OPERATOR_LIKE, op1, op2);

    }

    @Override

    public Code ilike(Code op1, Code op2) {

        return operator(OPERATOR_ILIKE, op1, op2);

    }

    @Override

    public Code regexp(Code op1, Code op2) {

        return operator(OPERATOR_REGEXP, op1, op2);

    }

    @Override

    public Code lt(Code op1, Code op2) {

        return operator(OPERATOR_LT, op1, op2);

    }

    @Override

    public Code gt(Code op1, Code op2) {

        return operator(OPERATOR_GT, op1, op2);

    }

    @Override

    public Code le(Code op1, Code op2) {

        return operator(OPERATOR_LE, op1, op2);

    }

    @Override

    public Code ge(Code op1, Code op2) {

        return operator(OPERATOR_GE, op1, op2);

    }

    @Override

    public Code eq(Code op1, Code op2) {

        return operator(OPERATOR_EQ, op1, op2);

    }

    @Override

    public Code ne(Code op1, Code op2) {

        return operator(OPERATOR_NE, op1, op2);

    }

    @Override

    public Code is(Code op1, Code op2) {

        return operator(OPERATOR_IS, op1, op2);

    }

    @Override

    public Code getattr(Code obj, String attrname) {

        BaseCodes args = args();

        args.add(obj);

        args.add(constant(attrname));

        return function(GetattrFunction.NAME, args);

    }    

    @Override

    public Code getitem(Code obj, Code index) {

        BaseCodes args = args();

        args.add(obj);

        args.add(index);

        return function(GetitemFunction.NAME, args);

    }

}