/* Property.java

	Purpose:
		
	Description:
		
	History:
		Sun Apr 16 14:55:35     2006, Created by tomyeh

Copyright (C) 2006 Potix Corporation. All Rights Reserved.

{{IS_RIGHT
	This program is distributed under LGPL Version 2.1 in the hope that
	it will be useful, but WITHOUT ANY WARRANTY.
}}IS_RIGHT
*/
package org.zkoss.zk.ui.metainfo;

import java.lang.reflect.Method;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.zkoss.lang.Classes;
import org.zkoss.lang.Exceptions;
import org.zkoss.zk.ui.Component;
import org.zkoss.zk.ui.Desktop;
import org.zkoss.zk.ui.Execution;
import org.zkoss.zk.ui.Executions;
import org.zkoss.zk.ui.Page;
import org.zkoss.zk.ui.UiException;
import org.zkoss.zk.ui.ext.DynamicPropertied;
import org.zkoss.zk.ui.ext.Native;
import org.zkoss.zk.ui.sys.ComponentCtrl;
import org.zkoss.zk.ui.sys.ExecutionCtrl;
import org.zkoss.zk.ui.sys.PropertyAccess;
import org.zkoss.zk.ui.sys.WebAppCtrl;
import org.zkoss.zk.ui.util.ConditionImpl;
import org.zkoss.zk.xel.EvaluatorRef;
import org.zkoss.zk.xel.ExValue;

/**
 * Information about how to initialize a property (a.k.a., a field of a component).
 * There are two kind of properties: one is a String instance (either
 * a string value or an expression), and the other is
 * a {@link NativeInfo} instance. The later is also called the native content.
 *
 * @author tomyeh
 */
public class Property extends ConditionValue {
	private static final Logger log = LoggerFactory.getLogger(Property.class);
	private static final long serialVersionUID = 20060622L;

	private final String _name;
	/** The value if it is not the native content.
	 * Exactly one of _value and _navval is non-null.
	 */
	private final ExValue _value;
	/** The value if it is the native content.
	 * Exactly one of _value and _navval is non-null.
	 */
	private final NativeInfo _navval;
	/** Used to optimize {@link #resolve}. */
	private transient volatile Class _lastcls;
	/** The method, or null if more than two methods are found
	 * (and use {@link #_mtds} in this case).
	 */
	private transient Method _mtd;
	/** Used more than two methods are found, or null if only one method
	 * (and use {@link #_mtd} in this case).
	 */
	private transient Method[] _mtds;

	/** Constructs a property with a class that is known in advance.
	 * @exception IllegalArgumentException if name is null
	 */
	public Property(EvaluatorRef evalr, String name, String value, ConditionImpl cond) {
		this(evalr, name, value, null, cond);
	}

	/** Constructs a property with the native content.
	 * The native content is represented by {@link NativeInfo},
	 * i.e., a XML fragment (a.k.a., a tree of {@link ComponentInfo}.
	 * @since 3.5.0
	 */
	public Property(EvaluatorRef evalr, String name, NativeInfo value, ConditionImpl cond) {
		this(evalr, name, null, value, cond);
	}

	private Property(EvaluatorRef evalr, String name, String value, NativeInfo navval, ConditionImpl cond) {
		super(evalr, cond);

		if (name == null)
			throw new IllegalArgumentException("null");

		_name = name;
		_navval = navval;
		_value = navval != null ? null : new ExValue(value, Object.class);
		//type will be fixed when mapped to a method
	}

	/** Returns the name of the property.
	 */
	public String getName() {
		return _name;
	}

	/** Returns the raw value of the property.
	 * Note: it is the original value without evaluation.
	 * In other words, it may contain EL expressions.
	 * @exception UnsupportedOperationException if value is the native content,
	 * i.e., it is constructed by use of {@link #Property(EvaluatorRef, String, NativeInfo, ConditionImpl)}.
	 * @since 3.0.0
	 */
	public String getRawValue() {
		if (_value == null)
			throw new UnsupportedOperationException("native content");
		return _value.getRawValue();
	}

	/** Sets the raw value of the property.
	 * @exception UnsupportedOperationException if value is the native content,
	 * i.e., it is constructed by use of {@link #Property(EvaluatorRef, String, NativeInfo, ConditionImpl)}.
	 * @since 3.0.0
	 */
	public void setRawValue(String value) {
		if (_value == null)
			throw new UnsupportedOperationException("native content");
		_value.setRawValue(value);
	}

	/** Evaluates the value to an Object.
	 * Note: it does NOT call {@link #isEffective} and it doesn't coerce
	 * the result (i.e., Object.class is assumed).
	 */
	public Object getValue(Component comp) {
		if (_value != null)
			return _value.getValue(_evalr, comp);

		Desktop desktop = comp.getDesktop();
		Page page;
		if (desktop == null) {
			Execution exec = Executions.getCurrent();
			if (exec == null)
				throw new IllegalStateException("Not attached, nor execution");
			desktop = exec.getDesktop();
			page = ((ExecutionCtrl) exec).getCurrentPage();
		} else {
			page = comp.getPage();
		}
		return ((WebAppCtrl) desktop.getWebApp()).getUiEngine().getNativeContent(comp, _navval.getChildren(),
				((Native) _navval.newInstance(page, comp)).getHelper());
	}

	/** Evaluates the value to an Object.
	 * Note: it does NOT call {@link #isEffective} and it doesn't coerce
	 * the result (i.e., Object.class is assumed).
	 * @exception UnsupportedOperationException if value is the native content,
	 * i.e., it is constructed by use of {@link #Property(EvaluatorRef, String, NativeInfo, ConditionImpl)}.
	 */
	public Object getValue(Page page) {
		if (_value == null)
			throw new UnsupportedOperationException("native content");
		return _value.getValue(_evalr, page);
	}

	/** Assigns the value of this member to the specified component.
	 *
	 * <p>Note: this method does nothing if {@link #isEffective} returns false.
	 */
	public void assign(Component comp) {
		if (isEffective(comp)) {
			try {
				assign0(comp);
			} catch (Exception ex) {
				log.error("Failed to assign " + this + " to " + comp + "\n" + Exceptions.getMessage(ex));
				throw UiException.Aide.wrap(ex);
			}
		}
	}

	/** Assigns a property.
	 *
	 * <p>Don't use the reflection directly since this method searches
	 * more signatures.
	 *
	 * @exception PropertyNotFoundException if the property is not found,
	 * i.e., no corresponding method and {@link DynamicPropertied} not
	 * implemented.
	 * @exception UiException if fail to assign
	 * @since 3.5.0
	 */
	public static final void assign(Component comp, String name, String value) {
		final Method mtd = resolveMethod(comp.getClass(), name);
		if (mtd != null) {
			try {
				Object val = Classes.coerce(mtd.getParameterTypes()[0], value);
				mtd.invoke(comp, val);
			} catch (Exception ex) {
				log.error("Failed to assign " + value + " to " + comp + "\n" + Exceptions.getMessage(ex));
				throw UiException.Aide.wrap(ex);
			}
		} else {
			((DynamicPropertied) comp).setDynamicProperty(name, value);
		}
	}

	private Object[] resolve(Class cls) {
		Method mtd = null;
		Method[] mtds = null;
		final String mtdnm = Classes.toMethodName(_name, "set");
		if (_value == null) {
			mtd = resolveMethod0(cls, mtdnm);
		} else {
			mtds = Classes.getCloseMethods(cls, mtdnm, new Class[] { null });
			if (mtds.length == 0) {
				if (!DynamicPropertied.class.isAssignableFrom(cls))
					throw new PropertyNotFoundException("Method " + mtdnm + " not found for " + cls);
				mtds = null;
			} else if (mtds.length == 1) {
				mtd = mtds[0];
				mtds = null;
			}
		}
		return new Object[] { mtd, mtds };
	}

	private void assign0(Component comp) throws Exception {
		if (comp instanceof ComponentCtrl) {
			ComponentCtrl ctrl = ((ComponentCtrl) comp);
			PropertyAccess propertyAccess = ctrl.getPropertyAccess(_name);
			if (propertyAccess != null) {
				try {
					propertyAccess.setValue(comp, Classes.coerce(propertyAccess.getType(), getValue(comp)));
					return;
				} catch (ClassCastException cce) {
					// yes, ignore it here and use the old EL way.
				}
			}
		}
		//Note: we have to synchronize since metainfo is shared
		//(unless it is initialized at the constructor)
		final Class cls = comp.getClass();
		if (_lastcls == null) { //first tiime
			synchronized (this) {
				if (_lastcls == null) { //not being initialized
					final Object[] mi = resolve(cls);
					_mtd = (Method) mi[0];
					_mtds = (Method[]) mi[1];
					_lastcls = cls;
				}
			}
		}

		Method mtd;
		Method[] mtds;
		if (_lastcls == cls) {
			mtd = _mtd;
			mtds = _mtds;
		} else { //two or more different compopent classes (use="${x?a:b}")
			//We don't cache methods for 2nd class (only cache 1st)
			final Object[] mi = resolve(cls);
			mtd = (Method) mi[0];
			mtds = (Method[]) mi[1];
		}

		//Note: if mtd and mtds are both null, it must be dyna-attr
		//However, if dyna-attr, mtd or mtds might not be null
		Class type = mtd != null ? mtd.getParameterTypes()[0] : Object.class;
		if (_value != null)
			_value.setExpectedType(type);
		Object val = getValue(comp);

		Method m = null;
		if (mtd != null) {
			m = mtd;
		} else if (mtds == null) {
			//it must be dynamic attribute
			((DynamicPropertied) comp).setDynamicProperty(_name, val);
			return; //done
		} else { //mtds != null && val != null
			if ((m = findExact(mtds, val)) == null && (m = findAssignable(mtds, val)) == null
					&& (m = findNullable(mtds, val)) == null) {
				//primitive
				if (val != null)
					for (int j = 0; j < mtds.length; ++j) {
						type = mtds[j].getParameterTypes()[0];
						if (type.isPrimitive()) {
							try {
								val = Classes.coerce(type, val);
								m = mtds[j];
								break;
							} catch (Throwable ex) {
							}
						}
					}

				if (m == null) {
					//non primitive, non string
					Method strmtd = null;
					for (int j = 0; j < mtds.length; ++j) {
						type = mtds[j].getParameterTypes()[0];
						if (String.class.equals(type)) {
							strmtd = mtds[j];
						} else if (!type.isPrimitive()) {
							try {
								val = Classes.coerce(type, val);
								m = mtds[j];
								break;
							} catch (Throwable ex) {
							}
						}
					}
					if (m == null) {
						if (strmtd != null) {
							try {
								val = Classes.coerce(String.class, val);
								m = strmtd;
							} catch (Throwable ex) {
							}
						}
						if (m == null)
							throw new ClassCastException(
									"Unable to find a setter named " + _name + " that supports " + val);
					}
				}
			}
		}
		m.invoke(comp, val);
	}

	private static Method findExact(final Method[] mtds, final Object val) {
		if (val != null) {
			final Class vcls = val.getClass();
			for (int j = 0; j < mtds.length; ++j)
				if (vcls.equals(mtds[j].getParameterTypes()[0]))
					return mtds[j]; //found
		}
		return null;
	}

	private static Method findAssignable(final Method[] mtds, final Object val) {
		if (val != null) {
			//Look for the most 'extended' and isInstance class
			Method m = null;
			Class<?> t = null;
			for (int j = 0; j < mtds.length; ++j) {
				final Class<?> type = mtds[j].getParameterTypes()[0];
				if (type.isInstance(val) && (t == null || t.isAssignableFrom(type))) {
					t = type;
					m = mtds[j];
				}
			}
			return m;
		}
		return null;
	}

	private static Method findNullable(final Method[] mtds, final Object val) {
		if (val == null) {
			//Look for the most 'extended' class
			Method m = null;
			Class<?> t = null;
			for (int j = 0; j < mtds.length; ++j) {
				final Class<?> type = mtds[j].getParameterTypes()[0];
				if (!type.isPrimitive() && (t == null || t.isAssignableFrom(type))) {
					t = type;
					m = mtds[j];
				}
			}
			return m;
		}
		return null;
	}

	public String toString() {
		return "[" + _name + (_navval != null ? "" + _navval : "=" + _value) + ']';
	}

	//static utilities//
	/** Resolves the method for the specified property, or null
	 * if {@link DynamicPropertied#setDynamicProperty} shall be used instead.
	 *
	 * <p>Use this method to retrieve the method when you want to assign a value
	 * to a component's property.
	 *
	 * <p>Don't use the reflection directly since this method searches
	 * more signatures.
	 * @param name the property name, such as "title".
	 * @exception PropertyNotFoundException if the property is not found,
	 * i.e., no corresponding method and {@link DynamicPropertied} not
	 * implemented.
	 * @since 3.5.0
	 */
	public static final Method resolveMethod(Class cls, String name) throws PropertyNotFoundException {
		return resolveMethod0(cls, Classes.toMethodName(name, "set"));
	}

	private static final Method resolveMethod0(Class cls, String mtdnm) throws PropertyNotFoundException {
		try {
			return Classes.getCloseMethod(cls, mtdnm, new Class[] { String.class });
		} catch (NoSuchMethodException ex) {
			try {
				return Classes.getCloseMethod(cls, mtdnm, new Class[] { null });
			} catch (NoSuchMethodException e2) {
				if (!DynamicPropertied.class.isAssignableFrom(cls))
					throw new PropertyNotFoundException("Method, " + mtdnm + ", not found for " + cls);
				return null;
			}
		}
	}
}
