/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to you under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.myfaces.test.mock;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import javax.faces.application.Application;
import javax.faces.component.StateHolder;
import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;
import javax.faces.el.EvaluationException;
import javax.faces.el.PropertyNotFoundException;
import javax.faces.el.PropertyResolver;
import javax.faces.el.ReferenceSyntaxException;
import javax.faces.el.ValueBinding;
import javax.faces.el.VariableResolver;


/**
 * <p>Mock implementation of <code>ValueBinding</code>.</p>
 */

public class MockValueBinding extends ValueBinding implements StateHolder {


    // ------------------------------------------------------------ Constructors


    /**
     * <p>Construct a default instance.</p>
     */
    public MockValueBinding() {

        this(null, null);

    }


    /**
     * <p>Construct a new value binding for the specified expression.</p>
     *
     * @param application Application instance to be wrapped
     * @param ref Expression to be wrapped
     */
    public MockValueBinding(Application application, String ref) {

        this.application = application;
        if (ref != null) {
            if (ref.startsWith("#{") && ref.endsWith("}")) {
                ref = ref.substring(2, ref.length() - 1);
            }
        }
        this.ref = ref;

    }


    // ----------------------------------------------------- Mock Object Methods


    /**
     * <p>Return the expression string for this value binding.</p>
     */
    public String ref() {

        return this.ref;

    }


    // ------------------------------------------------------ Instance Variables


    /**
     * <p>The <code>Application</code> instance for this application.</p>
     */
    private transient Application application; // Restored as necessary


    /**
     * <p>The expression this value binding will evaluate.</p>
     */
    private String ref;


    // ---------------------------------------------------- ValueBinding Methods


    /** {@inheritDoc} */
    public Object getValue(FacesContext context)
        throws EvaluationException, PropertyNotFoundException {

        if (context == null) {
            throw new NullPointerException();
        }
        List names = parse(ref);

        // Resolve the variable name
        VariableResolver vr = application().getVariableResolver();
        String name = (String) names.get(0);
        Object base = vr.resolveVariable(context, name);
        if (names.size() < 2) {
            return (base);
        }

        // Resolve the property names
        PropertyResolver pr = application().getPropertyResolver();
        for (int i = 1; i < names.size(); i++) {
            base = pr.getValue(base, (String) names.get(i));
        }

        // Return the resolved value
        return (base);

    }


    /** {@inheritDoc} */
    public void setValue(FacesContext context, Object value)
        throws EvaluationException, PropertyNotFoundException {

        if (context == null) {
            throw new NullPointerException();
        }
        List names = parse(ref);

        // Resolve the variable name
        VariableResolver vr = application().getVariableResolver();
        String name = (String) names.get(0);
        Object base = vr.resolveVariable(context, name);
        if (names.size() < 2) {
            if ("applicationScope".equals(name)
                || "requestScope".equals(name)
                || "sessionScope".equals(name)) {
                throw new ReferenceSyntaxException("Cannot set '"
                                                   + name + "'");
            }
            Map map = econtext().getRequestMap();
            if (map.containsKey(name)) {
                map.put(name, value);
                return;
            }
            map = econtext().getSessionMap();
            if ((map != null) && (map.containsKey(name))) {
                map.put(name, value);
                return;
            }
            map = econtext().getApplicationMap();
            if (map.containsKey(name)) {
                map.put(name, value);
                return;
            }
            econtext().getRequestMap().put(name, value);
            return;
        }

        // Resolve the property names
        PropertyResolver pr = application().getPropertyResolver();
        for (int i = 1; i < (names.size() - 1); i++) {
            // System.out.println("  property=" + names.get(i));
            base = pr.getValue(base, (String) names.get(i));
        }

        // Update the last property
        pr.setValue(base, (String) names.get(names.size() - 1), value);

    }


    /** {@inheritDoc} */
    public boolean isReadOnly(FacesContext context)
        throws PropertyNotFoundException {

        if (context == null) {
            throw new NullPointerException();
        }
        List names = parse(ref);

        // Resolve the variable name
        VariableResolver vr = application().getVariableResolver();
        String name = (String) names.get(0);
        Object base = vr.resolveVariable(context, name);
        if (names.size() < 2) {
            return true;
        }

        // Resolve the property names
        PropertyResolver pr = application().getPropertyResolver();
        for (int i = 1; i < names.size() - 1; i++) {
            base = pr.getValue(base, (String) names.get(i));
        }

        // Return the read only state of the final property
        return pr.isReadOnly(base, (String) names.get(names.size() - 1));

    }


    /** {@inheritDoc} */
    public Class getType(FacesContext context)
        throws PropertyNotFoundException {

        if (context == null) {
            throw new NullPointerException();
        }
        List names = parse(ref);

        // Resolve the variable name
        VariableResolver vr = application().getVariableResolver();
        String name = (String) names.get(0);
        Object base = vr.resolveVariable(context, name);
        if (names.size() < 2) {
            return base.getClass();
        }

        // Resolve the property names
        PropertyResolver pr = application().getPropertyResolver();
        for (int i = 1; i < names.size() - 1; i++) {
            base = pr.getValue(base, (String) names.get(i));
        }

        // Return the type of the final property
        return pr.getType(base, (String) names.get(names.size() - 1));

    }

    /** {@inheritDoc} */
    public String getExpressionString() {

        return "#{" + ref + "}";

    }


    // ----------------------------------------------------- StateHolder Methods


    /** {@inheritDoc} */
    public Object saveState(FacesContext context) {

        Object[] values = new Object[1];
        values[0] = ref;
        return values;

    }


    /** {@inheritDoc} */
    public void restoreState(FacesContext context, Object state) {

        Object[] values = (Object[]) state;
        ref = (String) values[0];

    }


    /**
     * <p>Flag indicating that this value is transient.</p>
     */
    private boolean transientFlag = false;


    /** {@inheritDoc} */
    public boolean isTransient() {

        return this.transientFlag;

    }


    /** {@inheritDoc} */
    public void setTransient(boolean transientFlag) {

        this.transientFlag = transientFlag;

    }


    // --------------------------------------------------------- Private Methods


    /**
     * <p>Return the relevant <code>Application</code> instance.</p>
     */
    private Application application() {

        if (application == null) {
            application = FacesContext.getCurrentInstance().getApplication();
        }
        return (application);

    }


    /**
     * <p>Return the relevant <code>ExternalContext</code> instance.</p>
     */
    private ExternalContext econtext() {

        return (FacesContext.getCurrentInstance().getExternalContext());

    }


    /**
     * <p>Return a list of the expression elements in this expression.</p>
     *
     * @param ref Expression to be parsed
     */
    private List parse(String ref) {

        List names = new ArrayList();
        StringBuffer expr = new StringBuffer(ref);
        boolean isBlockOn = false;
        for (int i = expr.length() - 1; i > -1; i--) {
            if (expr.charAt(i) == ' ') {
                expr.deleteCharAt(i);
            } else if (expr.charAt(i) == ']') {
                expr.deleteCharAt(i);
            } else if (expr.charAt(i) == '[') {
                expr.deleteCharAt(i);
            } else if (expr.charAt(i) == '\'') {
                if (!isBlockOn) {
                    expr.deleteCharAt(i);
                } else {
                    names.add(0, expr.substring(i + 1));
                    expr.delete(i, expr.length());
                }
                isBlockOn = !isBlockOn;
            } else if (expr.charAt(i) == '.' && !isBlockOn) {
                names.add(0, expr.substring(i + 1));
                expr.delete(i, expr.length());
            }
        }

        if (expr.length() > 0) {
            names.add(0, expr.toString());
        }

        if (names.size() < 1) {
            throw new ReferenceSyntaxException("No expression in '"
                    + ref + "'");
        }
        for (int i = 0; i < names.size(); i++) {
            String name = (String) names.get(i);
            if (name.length() < 1) {
                throw new ReferenceSyntaxException("Invalid expression '"
                        + ref + "'");
            }
        }
        return (names);

    }


}