/*
 * 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 freemarker.ext.jython;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;

import org.python.core.Py;
import org.python.core.PyDictionary;
import org.python.core.PyFloat;
import org.python.core.PyInteger;
import org.python.core.PyLong;
import org.python.core.PyObject;
import org.python.core.PySequence;
import org.python.core.PyString;
import org.python.core.PyStringMap;

import freemarker.ext.util.ModelCache;
import freemarker.ext.util.WrapperTemplateModel;
import freemarker.template.AdapterTemplateModel;
import freemarker.template.ObjectWrapper;
import freemarker.template.TemplateBooleanModel;
import freemarker.template.TemplateHashModel;
import freemarker.template.TemplateHashModelEx;
import freemarker.template.TemplateMethodModel;
import freemarker.template.TemplateMethodModelEx;
import freemarker.template.TemplateModel;
import freemarker.template.TemplateModelAdapter;
import freemarker.template.TemplateModelException;
import freemarker.template.TemplateNumberModel;
import freemarker.template.TemplateScalarModel;
import freemarker.template.TemplateSequenceModel;
import freemarker.template.utility.OptimizerUtil;

An object wrapper that wraps Jython objects into FreeMarker template models
and vice versa.
/**
 * An object wrapper that wraps Jython objects into FreeMarker template models
 * and vice versa.
 */
public class JythonWrapper implements ObjectWrapper {
    private static final Class PYOBJECT_CLASS = PyObject.class;
    public static final JythonWrapper INSTANCE = new JythonWrapper();

    private final ModelCache modelCache = new JythonModelCache(this);

    private boolean attributesShadowItems = true;

    public JythonWrapper() {
    }
    
    
Sets whether this wrapper caches model instances. Default is false. When set to true, calling wrap(Object) multiple times for the same object will return the same model. /**
     * Sets whether this wrapper caches model instances. Default is false.
     * When set to true, calling {@link #wrap(Object)} multiple times for
     * the same object will return the same model.
     */
    public void setUseCache(boolean useCache) {
        modelCache.setUseCache(useCache);
    }
    
    
Sets whether attributes shadow items in wrapped objects. When true 
(this is the default value), ${object.name} will first try to locate a python attribute with the specified name on the object using __findattr__.__findattr__(String), and only if it doesn't find the attribute will it call __getitem__.__getitem__(PyObject). When set to false, the lookup order is reversed and items are looked up before attributes. /**
     * Sets whether attributes shadow items in wrapped objects. When true 
     * (this is the default value), <code>${object.name}</code> will first 
     * try to locate a python attribute with the specified name on the object
     * using {@link PyObject#__findattr__(java.lang.String)}, and only if it 
     * doesn't find the attribute will it call 
     * {@link PyObject#__getitem__(org.python.core.PyObject)}.
     * When set to false, the lookup order is reversed and items
     * are looked up before attributes.
     */
    public synchronized void setAttributesShadowItems(boolean attributesShadowItems) {
        this.attributesShadowItems = attributesShadowItems;
    }
    
    boolean isAttributesShadowItems() {
        return attributesShadowItems;
    }
    
    
Wraps the passed Jython object into a FreeMarker template model. If the object is not a Jython object, it's first coerced into one using java2py.java2py(Object). PyDictionary and PyStringMap are wrapped into a hash model, PySequence descendants are wrapped into a sequence model, PyInteger, PyLong, and PyFloat are wrapped into a number model. All objects are wrapped into a scalar model (using Object.toString() and a boolean model (using __nonzero__.__nonzero__(). For internal general-purpose PyObjects returned from a call to unwrap(TemplateModel), the template model that was passed to unwrap is returned.
/**
     * Wraps the passed Jython object into a FreeMarker template model. If
     * the object is not a Jython object, it's first coerced into one using
     * {@link Py#java2py(java.lang.Object)}. {@link PyDictionary} and {@link
     * PyStringMap} are wrapped into a hash model, {@link PySequence}
     * descendants are wrapped into a sequence model, {@link PyInteger}, {@link
     * PyLong}, and {@link PyFloat} are wrapped into a number model. All objects
     * are wrapped into a scalar model (using {@link Object#toString()} and a
     * boolean model (using {@link PyObject#__nonzero__()}. For internal
     * general-purpose {@link PyObject}s returned from a call to {@link
     * #unwrap(TemplateModel)}, the template model that was passed to
     * <code>unwrap</code> is returned.
     */
    public TemplateModel wrap(Object obj) {
        if (obj == null) {
            return null;
        }
        return modelCache.getInstance(obj);
    }
    
    
Coerces a template model into a PyObject. 
Params:
model – the model to coerce
Returns:
the coerced model.


AdapterTemplateModels (i.e. BeanModel) are marshalled using the standard Python marshaller java2py.java2py(Object) on the result of getWrappedObject(PyObject.class)s. The 
  native JythonModel instances will just return the underlying PyObject. 
All other models that are scalars are marshalled as PyString. 
All other models that are numbers are marshalled using the standard Python marshaller java2py.java2py(Object) on their underlying Number
All other models  are marshalled to a generic internal 
  PyObject subclass that'll correctly pass
  __finditem__, __len__,
  __nonzero__, and __call__ invocations to 
  appropriate hash, sequence, and method models.
/**
     * Coerces a template model into a {@link PyObject}.
     * @param model the model to coerce
     * @return the coerced model.
     * <ul>
     * <li>
     * <li>{@link AdapterTemplateModel}s (i.e. {@link freemarker.ext.beans.BeanModel}) are marshalled
     *   using the standard Python marshaller {@link Py#java2py(Object)} on 
     *   the result of <code>getWrappedObject(PyObject.class)</code>s. The 
     *   native JythonModel instances will just return the underlying PyObject. 
     * <li>All other models that are {@link TemplateScalarModel scalars} are 
     *   marshalled as {@link PyString}.
     * <li>All other models that are {@link TemplateNumberModel numbers} are 
     *   marshalled using the standard Python marshaller
     *   {@link Py#java2py(Object)} on their underlying <code>Number</code></li>
     * <li>All other models  are marshalled to a generic internal 
     *   <code>PyObject</code> subclass that'll correctly pass
     *   <code>__finditem__</code>, <code>__len__</code>,
     *   <code>__nonzero__</code>, and <code>__call__</code> invocations to 
     *   appropriate hash, sequence, and method models.</li>
     * </ul>
     */
    public PyObject unwrap(TemplateModel model) throws TemplateModelException {
        if (model instanceof AdapterTemplateModel) {
            return Py.java2py(((AdapterTemplateModel) model).getAdaptedObject(
                    PYOBJECT_CLASS));
        }
        if (model instanceof WrapperTemplateModel) {
            return Py.java2py(((WrapperTemplateModel) model).getWrappedObject());
        }

        // Scalars are marshalled to PyString.
        if (model instanceof TemplateScalarModel) {
            return new PyString(((TemplateScalarModel) model).getAsString());
        }
        
        // Numbers are wrapped to Python built-in numeric types.
        if (model instanceof TemplateNumberModel) {
            Number number = ((TemplateNumberModel) model).getAsNumber();
            if (number instanceof BigDecimal) {
                number = OptimizerUtil.optimizeNumberRepresentation(number);
            }
            if (number instanceof BigInteger) {
                // Py.java2py can't automatically coerce a BigInteger into
                // a PyLong. This will probably get fixed in later Jython
                // release.
                return new PyLong((BigInteger) number);
            } else {
                return Py.java2py(number);
            }
        }
        // Return generic TemplateModel-to-Python adapter
        return new TemplateModelToJythonAdapter(model);
    }

    private class TemplateModelToJythonAdapter extends PyObject 
    implements TemplateModelAdapter {
        private final TemplateModel model;
        
        TemplateModelToJythonAdapter(TemplateModel model) {
            this.model = model;
        }
        
        public TemplateModel getTemplateModel() {
            return model;
        }
        
        @Override
        public PyObject __finditem__(PyObject key) {
            if (key instanceof PyInteger) {
                return __finditem__(((PyInteger) key).getValue());
            }
            return __finditem__(key.toString());
        }

        @Override
        public PyObject __finditem__(String key) {
            if (model instanceof TemplateHashModel) {
                try {
                    return unwrap(((TemplateHashModel) model).get(key));
                } catch (TemplateModelException e) {
                    throw Py.JavaError(e);
                }
            }
            throw Py.TypeError("item lookup on non-hash model (" + getModelClass() + ")");
        }
        
        @Override
        public PyObject __finditem__(int index) {
            if (model instanceof TemplateSequenceModel) {
                try {
                    return unwrap(((TemplateSequenceModel) model).get(index));
                } catch (TemplateModelException e) {
                    throw Py.JavaError(e);
                }
            }
            throw Py.TypeError("item lookup on non-sequence model (" + getModelClass() + ")");
        }
        
        @Override
        public PyObject __call__(PyObject args[], String keywords[]) {
            if (model instanceof TemplateMethodModel) {
                boolean isEx = model instanceof TemplateMethodModelEx;
                List list = new ArrayList(args.length);
                try {
                    for (int i = 0; i < args.length; ++i) {
                        list.add(
                            isEx 
                            ? (Object) wrap(args[i]) 
                            : (Object) (
                                args[i] == null 
                                ? null 
                                : args[i].toString()));
                    }
                    return unwrap((TemplateModel) ((TemplateMethodModelEx) model).exec(list));
                } catch (TemplateModelException e) {
                    throw Py.JavaError(e);
                }
            }
            throw Py.TypeError("call of non-method model (" + getModelClass() + ")");
        }
        
        @Override
        public int __len__() {
            try {
                if (model instanceof TemplateSequenceModel) {
                    return ((TemplateSequenceModel) model).size();
                }
                if (model instanceof TemplateHashModelEx) {
                    return ((TemplateHashModelEx) model).size();
                }
            } catch (TemplateModelException e) {
                throw Py.JavaError(e);
            }
            
            return 0;
        }
        
        @Override
        public boolean __nonzero__() {
            try {
                if (model instanceof TemplateBooleanModel) {
                    return ((TemplateBooleanModel) model).getAsBoolean();
                }
                if (model instanceof TemplateSequenceModel) {
                    return ((TemplateSequenceModel) model).size() > 0;
                }
                if (model instanceof TemplateHashModel) {
                    return !((TemplateHashModelEx) model).isEmpty();
                }
            } catch (TemplateModelException e) {
                throw Py.JavaError(e);
            }
            return false;
        }
        
        private String getModelClass() {
            return model == null ? "null" : model.getClass().getName();
        }
    }
}