Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

import java.util.ArrayList;

import java.util.List;

import java.util.Objects;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Code.Caller;

import org.gvsig.expressionevaluator.Codes;

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

import org.gvsig.expressionevaluator.ExpressionSyntaxException;

import org.gvsig.expressionevaluator.LexicalAnalyzer.Token;

import org.gvsig.expressionevaluator.Statement;

import org.gvsig.expressionevaluator.Statement.CompoundRule;

import org.gvsig.expressionevaluator.Statement.ConditionalRule;

import org.gvsig.expressionevaluator.Statement.Rule;

import org.gvsig.expressionevaluator.Statement.StatementContext;

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

import org.gvsig.expressionevaluator.impl.DefaultCodeBuilder.BaseCodes;

/**

 *

 * @author jjdelcerro

 */

public class DefaultStatement implements Statement {

    private final List<Rule> rules;

    private final String name;

    private StatementBuilder stmtBuilder;

//    private String codeId;

//    private ArgsBuilder argsBuilder;

    public interface RepeatRule extends CompoundRule {

        public String getClassifier();

    }

    public class RuleRequireAnyToken implements Rule {

        private final String[] required_token;

        public RuleRequireAnyToken(String... required_token) {

            this.required_token = required_token;

        }

        @Override

        public void parse(StatementContext context) {

            Token token = context.look_token();

            if (!token.is(this.required_token)) {

                throw new ExpressionSyntaxException(

                        I18N.A_XTokenX_was_expected_and_XliteralX_was_found(

                                StringUtils.join(this.required_token,", "),

                                token.getLiteral()

                        ),

                        context.getLexicalAnalyzer()

                );

            }

            context.next_token();

        }

        private boolean isApplicable(StatementContext context) {

            Token token = context.look_token();

            return token.is(this.required_token);

        }

        @Override

        public String toString() {

            return "require_token(" + StringUtils.join(this.required_token) + ")";

        }

    }

    public class RuleRequireIdentifier implements Rule {

        private final String id;

        public RuleRequireIdentifier(String id) {

            this.id = id;

        }

        @Override

        public void parse(StatementContext context) {

            Token token = context.look_token();

            if (token.getType() != Token.IDENTIFIER) {

                throw new ExpressionSyntaxException(

                        I18N.An_identifier_was_expected_and_XliteralX_was_found(token.getLiteral()),

                        context.getLexicalAnalyzer()

                );

            }

            String identifier = (String) token.getLiteral();

            Code code = context.getCodeBuilder().constant(identifier);

            context.setCode(id, code);

            context.next_token();

        }

        @Override

        public String toString() {

            return "require_identifier('" + this.id + "')";

        }

    }

    public class RuleRequireLiteralString implements Rule {

        private final String id;

        public RuleRequireLiteralString(String id) {

            this.id = id;

        }

        @Override

        public void parse(StatementContext context) {

            Token token = context.look_token();

            if (token.getType() != Token.STRING_LITERAL) {

                throw new ExpressionSyntaxException(

                        I18N.A_string_literal_was_expected(),

                        context.getLexicalAnalyzer()

                );

            }

            String identifier = (String) token.getValue();

            Code code = context.getCodeBuilder().constant(identifier);

            context.setCode(id, code);

            context.next_token();

        }

        @Override

        public String toString() {

            return "require_literal_string('" + this.id + "')";

        }

    }

    public class RuleRequireExpression implements Rule {

        private final String id;

        public RuleRequireExpression(String id) {

            this.id = id;

        }

        @Override

        public void parse(StatementContext context) {

            Code code = context.parse_expression();

            if (code == null) {

                throw new ExpressionSyntaxException(context.getLexicalAnalyzer());

            }

            context.setCode(id, code);

        }

        @Override

        public String toString() {

            return "require_expression('" + this.id + "')";

        }

    }

    public class RuleSetExpression implements Rule {

        private final String id;

        private final Object value;

        public RuleSetExpression(String id, Object value) {

            this.id = id;

            this.value = value;

        }

        @Override

        public void parse(StatementContext context) {

            if( this.value instanceof Code ) {

                context.setCode(id, (Code) this.value);

            } else {

                context.setCode(id, context.getCodeBuilder().constant(value));

            }

        }

        @Override

        public String toString() {

            return "set_expression('" + this.id + "', "+Objects.toString(value)+")";

        }

    }

    public class RuleRequiereExpressions implements Rule {

        private final String id;

        private final String separator;

        public RuleRequiereExpressions(String id, String separator) {

            this.id = id;

            this.separator = separator;

        }

        @Override

        public void parse(StatementContext context) {

            Codes codes = context.parse_expressions(this.separator);

            if (codes == null) {

                throw new ExpressionSyntaxException(context.getLexicalAnalyzer());

            }

            Code code;

            if( codes.size()==1 ) {

                code = codes.get(0);

            } else {

                code = context.getCodeBuilder().function(CodeBlockFunction.NAME, codes);

            }

            context.setCode(id, code);

        }

        @Override

        public String toString() {

            return "require_expressions('" + this.id + "', '" + this.separator + "')";

        }

    }

    public abstract class AbstractConditionalRule implements ConditionalRule {

        protected final List<Rule> onTrueRules;

        protected final List<Rule> onFalseRules;

        public AbstractConditionalRule() {

            this.onTrueRules = new ArrayList<>();

            this.onFalseRules = new ArrayList<>();

        }

        protected void parseOnTrueRules(StatementContext context) {

            for (Rule rule : this.onTrueRules) {

                rule.parse(context);

            }

        }

        protected void parseOnFalseRules(StatementContext context) {

            for (Rule rule : this.onFalseRules) {

                rule.parse(context);

            }

        }

        @Override

        public ConditionalRule addRuleOnTrue(Rule rule) {

            this.onTrueRules.add(rule);

            return this;

        }

        @Override

        public ConditionalRule addRuleOnFalse(Rule rule) {

            this.onFalseRules.add(rule);

            return this;

        }

    }

    public class RuleOptionalAnyToken implements ConditionalRule {

        private final String[] optional_token;

        private final List<Rule> onTrueRules;

        private final List<Rule> onFalseRules;

        public RuleOptionalAnyToken(String... optional_token) {

            this.optional_token = optional_token;

            this.onTrueRules = new ArrayList<>();

            this.onFalseRules = new ArrayList<>();

        }

        @Override

        public void parse(StatementContext context) {

            Token token = context.look_token();

            if (token.is(this.optional_token)) {

                context.next_token();

                for (Rule rule : this.onTrueRules) {

                    rule.parse(context);

                }

            } else {

                for (Rule rule : this.onFalseRules) {

                    rule.parse(context);

                }

            }

        }

        @Override

        public RuleOptionalAnyToken addRuleOnTrue(Rule rule) {

            this.onTrueRules.add(rule);

            return this;

        }

        @Override

        public RuleOptionalAnyToken addRuleOnFalse(Rule rule) {

            this.onFalseRules.add(rule);

            return this;

        }

        @Override

        public String toString() {

            return "optional_token(" + StringUtils.join(this.optional_token) + ") rules:" + StringUtils.join(onTrueRules, ",");

        }

    }

    public class RuleRepeatUntilAnyTokens implements RepeatRule {

        private final String[] exit_tokens;

        private final List<Rule> rules;

        private int counter;

        public RuleRepeatUntilAnyTokens(String[] exit_tokens) {

            this.exit_tokens = exit_tokens;

            this.rules = new ArrayList<>();

        }

        @Override

        public void parse(StatementContext context) {

            String save = context.getCodeClassifier();

            try {

                this.counter = 1;

                while (true) {

                    Token token = context.look_token();

                    if (token.is(this.exit_tokens)) {

                        break;

                    }

                    context.setCodeClassifier(String.valueOf(counter).trim());

                    for (Rule rule : rules) {

                        rule.parse(context);

                    }

                    this.counter = this.counter + 1;

                }

            } finally {

                context.setCodeClassifier(save);

            }

        }

        @Override

        public RuleRepeatUntilAnyTokens addRule(Rule rule) {

            this.rules.add(rule);

            return this;

        }

        @Override

        public String getClassifier() {

            String s = String.valueOf(counter).trim();

            return s;

        }

        @Override

        public String toString() {

            return "repeat_until_tokens('" + ArrayUtils.toString(this.exit_tokens) + "') rules:" + StringUtils.join(rules, ",");

        }

    }

    public class RuleOptionalIdentifiers extends AbstractConditionalRule implements ConditionalRule {

        private final String id;

        private final String separator;

        public RuleOptionalIdentifiers(String id, String separator) {

            super();

            this.id = id;

            this.separator = separator;

        }

        @Override

        public void parse(StatementContext context) {

            BaseCodes args = (BaseCodes) context.getCodeBuilder().args();

            Token token = context.look_token();

            while (token.getType() == Token.IDENTIFIER) {

                String identifier = (String) token.getLiteral();

                if( context.isReservedWord(identifier) ) {

                    break;

                }

                Code code = context.getCodeBuilder().constant(identifier);

                args.add(code);

                context.next_token();

                token = context.look_token();

                if (!token.is(this.separator)) {

                    break;

                }

                context.next_token();

                token = context.look_token();

            }

            if (args.size() != 0) {

                Code code = context.getCodeBuilder().function(FUNCTION_LIST, args);

                context.setCode(id, code);

                this.parseOnTrueRules(context);

            } else {

                this.parseOnFalseRules(context);

            }

        }

        @Override

        public String toString() {

            return "optional_identifiers('" + id + "', '" + this.separator + "')";

        }

    }

    public class RuleOptionalLiteralString extends AbstractConditionalRule implements ConditionalRule {

        private final String id;

        public RuleOptionalLiteralString(String id) {

            super();

            this.id = id;

        }

        @Override

        public void parse(StatementContext context) {

            Token token = context.look_token();

            if (token.getType() == Token.STRING_LITERAL) {

                String s = (String) token.getValue();

                Code code = context.getCodeBuilder().constant(s);

                context.setCode(id, code);

                context.next_token();

                this.parseOnTrueRules(context);

            } else {

                this.parseOnFalseRules(context);

            }

        }

        @Override

        public String toString() {

            return "optional_literal_string('" + id + "')";

        }

    }

    public static class ArgsBuilderFromNames implements ArgsBuilder {

        private final String[] argNames;

        public ArgsBuilderFromNames(String... argNames) {

            this.argNames = argNames;

        }

        @Override

        public Codes build(StatementContext context) {

            BaseCodes args = (BaseCodes) context.getCodeBuilder().args();

            for (String argName : argNames) {

                if (argName.contains("#")) {

                    int n = 1;

                    while (true) {

                        String argNameX = StringUtils.replace(argName, "#", String.valueOf(n).trim(), 1);

                        Code code = context.getCode(argNameX);

                        if (code == null) {

                            break;

                        }

                        args.add(code);

                        n++;

                    }

                } else {

                    Code code = context.getCode(argName);

//                    if( code == null) {

//                        code = context.getCodeBuilder().constant(null);

//                    }

                    args.add(code);

                }

            }

            return args;

        }

    }

    public static class ArgsBuilderExpand extends ArgsBuilderFromNames {

        public ArgsBuilderExpand(String... argNames) {

            super(argNames);

        }

        @Override

        public Codes build(StatementContext context) {

            BaseCodes args = (BaseCodes) context.getCodeBuilder().args();

            Codes base_args = super.build(context);

            for (Code arg : base_args) {

                if( arg.code() == Code.CALLER && 

                    ((Caller)arg).name().equals(CodeBlockFunction.NAME) ) {

                    Codes block_args = ((Caller)arg).parameters();

                    for (Code block_arg : block_args) {

                        args.add(block_arg);

                    }

                } else {

                    args.add(arg);

                }

            }

            return args;

        }

    }

    public static class StatementBuilderBase implements StatementBuilder {

        protected ArgsBuilder argsBuilder;

        protected String codeID;

        public StatementBuilderBase(String codeID, ArgsBuilder argsBuilder) {

            this.codeID = codeID;

            this.argsBuilder = argsBuilder;

        }

        @Override

        public String getCodeID() {

            return this.codeID;

        }

        @Override

        public ArgsBuilder getArgsBuilder() {

            return this.argsBuilder;

        }

        @Override

        public Code build(StatementContext context) {

            Codes args = this.getArgsBuilder().build(context);

            Code code = null;

            if (this.getCodeID() == null) {

                code = args.get(0);

            } else {

                if (args.size() == 0) {

                    code = context.getCodeBuilder().function(this.getCodeID(), null);

                } else {

                    // Si es un bloque dentro de otro, dejamos solo uno.

                    if( args.size()==1 && 

                        StringUtils.equalsIgnoreCase(CodeBlockFunction.NAME,this.getCodeID()) ) {

                        Code code0 = args.get(0);

                        if( code0.code() == Code.CALLER && 

                                StringUtils.equalsIgnoreCase(CodeBlockFunction.NAME,((Caller)code0).name())

                                ) {

                            code = code0;

                        }

                    }

                    if( code == null ) {

                        code = context.getCodeBuilder().function(this.getCodeID(), args);

                    }

                }

            }

            return code;

        }

    }

    public DefaultStatement(String name) {

        this.rules = new ArrayList<>();

        this.stmtBuilder = null;

        this.name = name;

    }

    @Override

    public String getName() {

        return name;

    }

    @Override

    public Rule require_any_token(String... token) {

        return new RuleRequireAnyToken(token);

    }

    @Override

    public Rule require_identifier(String id) {

        return new RuleRequireIdentifier(id);

    }

    @Override

    public Rule require_literal_string(String id) {

        return new RuleRequireLiteralString(id);

    }

    @Override

    public Rule set_expression(String id, Object value) {

        return new RuleSetExpression(id, value);

    }

    @Override

    public Rule require_expression(String id) {

        return new RuleRequireExpression(id);

    }

    @Override

    public Rule require_expressions(String id, String separator) {

        return new RuleRequiereExpressions(id, separator);

    }

    @Override

    public ConditionalRule optional_any_token(String... id) {

        return new RuleOptionalAnyToken(id);

    }

    @Override

    public ConditionalRule optional_identifiers(String id, String separator) {

        return new RuleOptionalIdentifiers(id, separator);

    }

    @Override

    public ConditionalRule optional_literal_string(String id) {

        return new RuleOptionalLiteralString(id);

    }

    @Override

    public CompoundRule repeat_until_any_tokens(String... tokens) {

        return new RuleRepeatUntilAnyTokens(tokens);

    }

    @Override

    public Statement addRule(Rule rule) {

        this.rules.add(rule);

        return this;

    }

    @Override

    public boolean isApplicable(StatementContext context) {

        if (this.rules.isEmpty()) {

            return false;

        }

        Rule rule = this.rules.get(0);

        if (!(rule instanceof RuleRequireAnyToken)) {

            return false;

        }

        return ((RuleRequireAnyToken) rule).isApplicable(context);

    }

    @Override

    public ArgsBuilder args_names(String... args) {

        ArgsBuilder x = new ArgsBuilderFromNames(args);

        return x;

    }

    @Override

    public ArgsBuilder args_expand(String... args) {

        ArgsBuilder x = new ArgsBuilderExpand(args);

        return x;

    }

    @Override

    public void code(final String id, final ArgsBuilder argsBuilder) {

        this.builder(new StatementBuilderBase(id, argsBuilder));

    }

    public void builder(StatementBuilder builder) {

        this.stmtBuilder = builder;

    }

    @Override

    public Code parse(StatementContext context) {

//        System.err.println("start parse "+this.getName());

        for (Rule rule : rules) {

            rule.parse(context);

        }

        Code code = this.stmtBuilder.build(context);

        return code;

    }

    @Override

    public String toString() {

        return this.getName() + " " + StringUtils.join(this.rules, ";");

    }

}