/*
 * This file is part of NodeBox.
 *
 * Copyright (C) 2008 Frederik De Bleser (frederik@pandora.be)
 *
 * NodeBox is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * NodeBox is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with NodeBox. If not, see <http://www.gnu.org/licenses/>.
 */
package nodebox.node;

import nodebox.graphics.Color;
import nodebox.util.waves.AbstractWave;
import org.mvel2.CompileException;
import org.mvel2.MVEL;
import org.mvel2.ParserContext;
import org.mvel2.UnresolveablePropertyException;
import org.mvel2.integration.VariableResolver;
import org.mvel2.integration.impl.BaseVariableResolverFactory;
import org.mvel2.integration.impl.SimpleValueResolver;
import org.mvel2.optimizers.OptimizerFactory;
import org.python.google.common.collect.ImmutableMap;

import java.io.Serializable;
import java.lang.ref.WeakReference;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class Expression {

    static ParserContext parserContext = new ParserContext();
    private static ImmutableMap<String, VariableResolver> defaultResolvers;

    static {
        // Initialize MVEL.

        // The dynamic optimizer crashes for some reason, so we use the "safe reflective" one.
        // Although "safe" sounds slower, this optimizer actually seems *faster*
        // than the dynamic one. Don't change this unless you want to go digging for weird
        // reflective constructor errors.
        OptimizerFactory.setDefaultOptimizer(OptimizerFactory.SAFE_REFLECTIVE);

        // Add "built-in" methods to the expression context.
        parserContext = new ParserContext();
        try {
            // MVEL has a bug where it accepts methods with varargs, but only executes the method with
            // non-varargs. So in our ExpressionHelper we have both the varargs and non-varargs methods.
            // We lookup the varargs version here, but only the non-varargs will get called.
            parserContext.addImport("random", ExpressionHelper.class.getMethod("random", Object.class, double[].class));
            parserContext.addImport("randint", ExpressionHelper.class.getMethod("randint", Object.class, int.class, int.class));
            parserContext.addImport("clamp", ExpressionHelper.class.getMethod("clamp", double.class, double.class, double.class));
            parserContext.addImport("color", ExpressionHelper.class.getMethod("color", double[].class));
            parserContext.addImport("rgb", ExpressionHelper.class.getMethod("color", double[].class));
            parserContext.addImport("hsb", ExpressionHelper.class.getMethod("hsb", double[].class));
            parserContext.addImport("stamp", ExpressionHelper.class.getMethod("stamp", String.class, Object.class));
            parserContext.addImport("int", ExpressionHelper.class.getMethod("toInt", double.class));
            parserContext.addImport("float", ExpressionHelper.class.getMethod("toFloat", int.class));
            parserContext.addImport("hold", ExpressionHelper.class.getMethod("hold", double.class, double.class, double[].class));
            parserContext.addImport("schedule", ExpressionHelper.class.getMethod("schedule", double.class, double.class, double.class, double[].class));
            parserContext.addImport("timeloop", ExpressionHelper.class.getMethod("timeloop", double.class, List.class));
            parserContext.addImport("timeloop", ExpressionHelper.class.getMethod("timeloop", double.class, List.class, double.class));
            parserContext.addImport("wave", ExpressionHelper.class.getMethod("wave"));
            parserContext.addImport("wave", ExpressionHelper.class.getMethod("wave", AbstractWave.Type.class, double[].class));
            parserContext.addImport("math", Math.class);
        } catch (NoSuchMethodException e) {
            throw new AssertionError("Unknown static method for expression." + e);
        }

        ImmutableMap.Builder<String, VariableResolver> resolvers = ImmutableMap.builder();
        for (AbstractWave.Type wave : AbstractWave.Type.values())
            resolvers.put(wave.name(), new SimpleValueResolver(wave));
        defaultResolvers = resolvers.build();
    }

    private final Parameter parameter;
    private final String expression;
    private transient Throwable error;
    private transient Serializable compiledExpression;
    private Set<WeakReference<Parameter>> markedParameterReferences;

    /**
     * Construct and set the expression.
     * <p/>
     * The expression is accepted as is, and no errors will be thrown even if the expression is invalid.
     * Only during compilation or evaluation will this result in an error.
     *
     * @param parameter
     * @param expression
     */
    public Expression(Parameter parameter, String expression) {
        assert parameter != null; // We need the current parameter for stamp expressions.
        this.parameter = parameter;
        this.expression = expression;
        markedParameterReferences = null;
        compiledExpression = null;
    }

    //// Attribute access ////

    public String getExpression() {
        return expression;
    }

    public boolean hasError() {
        return error != null;
    }

    public Throwable getError() {
        return error;
    }

    /* package private */

    void setError(Exception error) {
        // This method is called from Parameter to set an error for cyclic dependencies.
        this.error = error;
    }

    public Parameter getParameter() {
        return parameter;
    }

    //// Values ////

    public boolean asBoolean() throws ExpressionError {
        Object value = evaluate();
        if (value instanceof Boolean) {
            return (Boolean) value;
        } else {
            throw new ExpressionError("Value \"" + value + "\" for expression \"" + expression + "\" is not a boolean.");
        }
    }

    public int asInt() throws ExpressionError {
        Object value = evaluate();
        if (value instanceof Number) {
            return (Integer) value;
        } else {
            throw new ExpressionError("Value \"" + value + "\" for expression \"" + expression + "\" is not an integer.");
        }
    }

    public double asFloat() throws ExpressionError {
        Object value = evaluate();
        if (value instanceof Number) {
            return (Double) value;
        } else {
            throw new ExpressionError("Value \"" + value + "\" for expression \"" + expression + "\" is not a floating-point value.");
        }
    }

    public String asString() throws ExpressionError {
        Object value = evaluate();
        if (value instanceof String) {
            return (String) value;
        } else {
            throw new ExpressionError("Value \"" + value + "\" for expression \"" + expression + "\" is not a string.");
        }
    }

    public Color asColor() throws ExpressionError {
        Object value = evaluate();
        if (value instanceof Color) {
            return (Color) value;
        } else {
            throw new ExpressionError("Value \"" + value + "\" for expression \"" + expression + "\" is not a color.");
        }
    }

    //// Evaluation ////

    /**
     * Compile the expression.
     *
     * @throws ExpressionError if the compilation fails.
     * @see #getError()
     */
    public void compile() throws ExpressionError {
        try {
            this.compiledExpression = MVEL.compileExpression(expression, parserContext);
            error = null;
        } catch (Exception e) {
            error = e;
            throw new ExpressionError("Cannot compile expression '" + expression + "' on " + getParameter().getAbsolutePath() + ": " + e.getMessage(), e);
        }
    }

    /**
     * Evaluate the expression and return the result.
     *
     * @return the result of the expression
     * @throws ExpressionError if an error occurs whilst evaluating the expression.
     */
    public Object evaluate() throws ExpressionError {
        return evaluate(new ProcessingContext(parameter.getNode()));
    }

    /**
     * Evaluate the expression and return the result.
     * <p/>
     * Throw an exception if an error occurs. You can retrieve this exception by calling getError().
     *
     * @param context the context wherein evaluation happens.
     * @return the result of the expression
     * @throws ExpressionError if an error occurs whilst evaluating the expression.
     * @see #getError()
     */
    public Object evaluate(ProcessingContext context) throws ExpressionError {
        // If there was an error with the expression, throw it before doing anything.
        if (hasError()) {
            throw new ExpressionError("Cannot compile expression '" + expression + "' on " + getParameter().getAbsolutePath() + ": " + getError().getMessage(), getError());
        }

        // If the expression was not compiled, compile it first.
        // This can throw an ExpressionError, which will be forwarded to the caller.
        if (compiledExpression == null) {
            compile();
        }
        // Set up state variables in the expression utilities class.
        // TODO: This is not thread-safe.
        ExpressionHelper.currentContext = context;
        ExpressionHelper.currentParameter = parameter;
        // Marked parameter references are used to find which parameters this expression references.
        markedParameterReferences = new HashSet<WeakReference<Parameter>>();
        ProxyResolverFactory prf = new ProxyResolverFactory(parameter.getNode(), context, markedParameterReferences);
        try {
            error = null;
            return MVEL.executeExpression(compiledExpression, prf);
        } catch (Exception e) {
            error = e;
            throw new ExpressionError("Cannot evaluate expression '" + expression + "' on " + getParameter().getAbsolutePath() + ": " + e.getMessage(), e);
        }
    }

    /**
     * Returns all parameters this expression depends on
     * <p/>
     * If the expression contains an error, this method will return an empty set.
     *
     * @return a set of parameters
     */
    public Set<Parameter> getDependencies() {
        if (markedParameterReferences == null) {
            try {
                evaluate();
            } catch (ExpressionError expressionError) {
                return new HashSet<Parameter>(0);
            }
        }
        HashSet<Parameter> dependencies = new HashSet<Parameter>(markedParameterReferences.size());
        for (WeakReference<Parameter> ref : markedParameterReferences) {
            Parameter p = ref.get();
            if (p != null)
                dependencies.add(p);
        }
        return dependencies;
    }

    class ProxyResolverFactory extends BaseVariableResolverFactory {

        private Node node;
        private NodeAccessProxy proxy;
        private ProcessingContext context;


        public ProxyResolverFactory(Node node, ProcessingContext context) {
            this.node = node;
            proxy = new NodeAccessProxy(node);
            this.context = context;
            variableResolvers.putAll(defaultResolvers);
        }

        public ProxyResolverFactory(Node node, ProcessingContext context, Set<WeakReference<Parameter>> markedParameterReferences) {
            this.node = node;
            proxy = new NodeAccessProxy(node, markedParameterReferences);
            this.context = context;
            variableResolvers.putAll(defaultResolvers);
        }

        public Node getNode() {
            return node;
        }

        public NodeAccessProxy getProxy() {
            return proxy;
        }

        public VariableResolver createVariable(String name, Object value) {
            throw new CompileException("Variable assignment is not supported.");
        }

        public VariableResolver createVariable(String name, Object value, Class<?> type) {
            throw new CompileException("Variable assignment is not supported.");
        }

        @Override
        public VariableResolver getVariableResolver(String name) {
            if (variableResolvers == null) {
                variableResolvers = new HashMap<String, VariableResolver>();
                variableResolvers.putAll(defaultResolvers);
            }
            VariableResolver vr = variableResolvers.get(name);
            if (vr != null) {
                return vr;
            } else if (proxy.containsKey(name)) {
                vr = new ProxyResolver(proxy, proxy.get(name));
                variableResolvers.put(name, vr);
                return vr;
            } else if (context.containsKey(name)) {
                vr = new ProcessingContextResolver(context, name);
                variableResolvers.put(name, vr);
                return vr;
            } else if (nextFactory != null) {
                return nextFactory.getVariableResolver(name);
            }
            throw new UnresolveablePropertyException("unable to resolve variable '" + name + "'");
        }

        public boolean isResolveable(String name) {
            return (variableResolvers != null && variableResolvers.containsKey(name))
                    || (proxy.containsKey(name))
                    || (context.containsKey(name))
                    || (nextFactory != null && nextFactory.isResolveable(name));
        }

        public boolean isTarget(String name) {
            return variableResolvers != null && variableResolvers.containsKey(name);
        }

        @Override
        public Set<String> getKnownVariables() {
            Set<String> knownVariables = new HashSet<String>();
            knownVariables.addAll(proxy.keySet());
            knownVariables.addAll(context.keySet());
            return knownVariables;
        }
    }

    class ProxyResolver implements VariableResolver {

        private NodeAccessProxy proxy;
        private Object value;

        public ProxyResolver(NodeAccessProxy proxy, Object value) {
            this.proxy = proxy;
            this.value = value;
        }

        public NodeAccessProxy getProxy() {
            return proxy;
        }

        public Node getNode() {
            return proxy.getNode();
        }

        public String getName() {
            return proxy.getNode().getName();
        }

        public Class getType() {
            return Object.class;
        }

        public void setStaticType(Class type) {
            throw new RuntimeException("Not implemented");
        }

        public int getFlags() {
            return 0;
        }

        public Object getValue() {
            return value;
        }

        public void setValue(Object value) {
            throw new CompileException("Parameter values cannot be changed through expressions.");
        }
    }

    class ProcessingContextResolver implements VariableResolver {

        private String name;
        private ProcessingContext context;

        ProcessingContextResolver(ProcessingContext context, String name) {
            this.context = context;
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public Class getType() {
            return Object.class;
        }

        public void setStaticType(Class aClass) {
            throw new RuntimeException("Not implemented");
        }

        public int getFlags() {
            return 0;
        }

        public Object getValue() {
            return context.get(name);
        }

        public void setValue(Object o) {
            throw new CompileException("You cannot change the value of a constant.");
        }
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Expression other = (Expression) o;
        return expression.equals(other.expression);
    }

    @Override
    public int hashCode() {
        return expression.hashCode();
    }
}