/***
    *     Ambient - A music player for the Android platform
    Copyright (C) 2007 Martin Vysny
    
    This program 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.
    
   This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
   */
  package sk.baka.ambient.commons;
  
  import java.lang.reflect.Field;
  import java.lang.reflect.Method;
  import java.lang.reflect.Modifier;
  import java.text.ParseException;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Map;
  
  import sk.baka.ambient.AmbientApplication;
  import sk.baka.ambient.R;
  import android.content.SharedPreferences.Editor;
  import android.util.Log;
  import android.view.View;
  import android.widget.CheckBox;
  import android.widget.EditText;
  import android.widget.Spinner;
  
  /***
   * Binds a POJO bean to a view. Currently only public fields are supported - no
   * getters/setters.
   * 
   * @author Martin Vysny
   */
  public final class Binder {
  	private Binder() {
  		// prevent instantiation
  	}
  
  	/***
  	 * Copies all properties annotated by {@link Bind} to a map.
  	 * 
  	 * @param bean
  	 *            the bean to copy from/to
  	 * @param map
  	 *            the map to use
  	 * @param beanToMap
  	 *            if <code>true</code> then data from the bean are copied into
  	 *            the map. If <code>false</code> then map's data will be
  	 *            copied into the bean.
  	 * @param validate
  	 *            if <code>true</code> then validation constraints are
  	 *            checked.
  	 * @return an empty map if no validation constraints were violated; a map of
  	 *         view id to an error message if violation occured.
  	 */
  	public static Map<Integer, String> bindBeanMap(final Object bean,
  			final Map<String, Object> map, final boolean beanToMap,
  			final boolean validate) {
  		final Map<Integer, String> result = new HashMap<Integer, String>();
  		try {
  			for (final Field field : bean.getClass().getFields()) {
  				final Bind annotation = field.getAnnotation(Bind.class);
  				if (annotation == null)
  					continue;
  				if (!Modifier.isPublic(field.getModifiers()))
  					continue;
  				if (beanToMap) {
  					final Object fieldValue = field.get(bean);
  					if (validate) {
  						result.putAll(checkValidity(fieldValue, annotation));
  					}
  					map.put(field.getName(), fieldValue);
  				} else {
  					Object fieldValue = map.get(field.getName());
  					if (fieldValue == null)
  						continue;
  					if (validate)
  						result.putAll(checkValidity(fieldValue, annotation));
  					// handle special Enum case
  					if ((fieldValue instanceof Integer)
  							&& field.getType().isEnum()) {
  						final int ordinal = (Integer) fieldValue;
  						fieldValue = ordinal < 0 ? null : field.getType()
  								.getEnumConstants()[ordinal];
  					}
  					field.set(bean, fieldValue);
  				}
  			}
  		} catch (IllegalAccessException e) {
  			throw new RuntimeException(e);
 		}
 		return result;
 	}
 
 	/***
 	 * Copies all properties annotated by {@link Bind} to an editor.
 	 * 
 	 * @param bean
 	 *            the bean to copy from
 	 * @param editor
 	 *            the map to use
 	 * @param validate
 	 *            if <code>true</code> then validation constraints are
 	 *            checked.
 	 * @return an empty map if no validation constraints were violated; a map of
 	 *         view id to an error message if violation occured.
 	 */
 	public static Map<Integer, String> bindBeanToEditor(final Object bean,
 			final Editor editor, final boolean validate) {
 		final Map<Integer, String> result = new HashMap<Integer, String>();
 		try {
 			for (final Field field : bean.getClass().getFields()) {
 				final Bind annotation = field.getAnnotation(Bind.class);
 				if (annotation == null)
 					continue;
 				if (!Modifier.isPublic(field.getModifiers()))
 					continue;
 				final Object fieldValue = field.get(bean);
 				final Class<?> type = field.getType();
 				if (validate)
 					result.putAll(checkValidity(fieldValue, annotation));
 				final String k = field.getName();
 				final Object v = fieldValue;
 				put(k, v, type, editor);
 			}
 		} catch (IllegalAccessException e) {
 			throw new RuntimeException(e);
 		}
 		return result;
 	}
 
 	/***
 	 * Puts given object into an editor.
 	 * 
 	 * @param <V>
 	 *            the value type
 	 * @param k
 	 *            key name
 	 * @param v
 	 *            value
 	 * @param type
 	 *            the value class
 	 * @param editor
 	 *            the editor.
 	 */
 	public static <V> void put(final String k, final V v,
 			final Class<? extends V> type, final Editor editor) {
 		if (v instanceof String) {
 			editor.putString(k, (String) v);
 			return;
 		}
 		if (v instanceof Float) {
 			editor.putFloat(k, (Float) v);
 			return;
 		}
 		if (v instanceof Integer) {
 			editor.putInt(k, (Integer) v);
 			return;
 		}
 		if (v instanceof Boolean) {
 			editor.putBoolean(k, (Boolean) v);
 			return;
 		}
 		if (v instanceof Long) {
 			editor.putLong(k, (Long) v);
 			return;
 		}
 		if (type.isEnum()) {
 			editor.putInt(k, v == null ? -1 : ((Enum<?>) v).ordinal());
 			return;
 		}
 		throw new IllegalArgumentException("Object " + type.getName()
 				+ " not writable to an editor");
 	}
 
 	/***
 	 * Copies all properties annotated by {@link Bind} to the view.
 	 * 
 	 * @param bean
 	 *            the bean to copy from/to
 	 * @param parent
 	 *            the view to use for performing View lookup.
 	 * @param beanToView
 	 *            if <code>true</code> then data from the bean are copied into
 	 *            the view. If <code>false</code> then view's data will be
 	 *            copied into the bean.
 	 * @param validate
 	 *            if <code>true</code> then validation constraints are
 	 *            checked.
 	 * @return an empty map if no validation constraints were violated; a map of
 	 *         view id to an error message if violation occurred.
 	 */
 	public static Map<Integer, String> bindBeanView(final Object bean,
 			final View parent, final boolean beanToView, final boolean validate) {
 		if (bean == null) {
 			throw new NullArgumentException("bean");
 		}
 		if (parent == null) {
 			throw new NullArgumentException("parent");
 		}
 		final Map<Integer, String> result = new HashMap<Integer, String>();
 		try {
 			for (final Field field : bean.getClass().getFields()) {
 				final Bind annotation = field.getAnnotation(Bind.class);
 				if (annotation == null)
 					continue;
 				final View view = parent.findViewById(annotation.viewId());
 				if (view == null)
 					throw new RuntimeException("No view with ID "
 							+ annotation.viewId());
 				if (beanToView) {
 					final Object fieldValue = field.get(bean);
 					if (validate)
 						result.putAll(checkValidity(fieldValue, annotation));
 					assignValueToView(fieldValue, view, annotation.escape());
 				} else {
 					final Class<?> fieldClass = field.getType();
 					final Object fieldValue = assignViewToValue(fieldClass,
 							view, annotation.escape());
 					if (validate)
 						result.putAll(checkValidity(fieldValue, annotation));
 					field.set(bean, fieldValue);
 				}
 			}
 		} catch (IllegalAccessException e) {
 			throw new RuntimeException(e);
 		}
 		return result;
 	}
 
 	private static String formatErrMsg(final Bind bind, final int errorMsgId,
 			final Object... args) {
 		final String errMsg = MiscUtils.format(errorMsgId, args);
 		if (bind.captionId() == -1)
 			return errMsg;
 		final String caption = AmbientApplication.getInstance().getString(
 				bind.captionId());
 		return caption + ": " + errMsg;
 	}
 
 	@SuppressWarnings("unchecked")
 	private static Map<Integer, String> checkValidity(final Object object,
 			Bind annotation) {
 		if (object instanceof Number) {
 			final int intVal = ((Number) object).intValue();
 			if (intVal < annotation.min()) {
 				final String errMsg = formatErrMsg(annotation,
 						R.string.errNumberTooSmall, annotation.min());
 				return Collections.singletonMap(annotation.viewId(), errMsg);
 			}
 			if (intVal > annotation.max()) {
 				final String errMsg = formatErrMsg(annotation,
 						R.string.errNumberTooBig, annotation.max());
 				return Collections.singletonMap(annotation.viewId(), errMsg);
 			}
 		}
 		if ((object instanceof String) && annotation.tagFormat()) {
 			try {
 				new TagFormatter((String) object);
 			} catch (ParseException e) {
 				Log.i(Binder.class.getSimpleName(), e.getMessage(), e);
 				final String errMsg = formatErrMsg(annotation,
 						R.string.errStringNotTagFormat, e.getMessage());
 				return Collections.singletonMap(annotation.viewId(), errMsg);
 			}
 		}
 		return Collections.EMPTY_MAP;
 	}
 
 	/***
 	 * Assigns given value to the view
 	 * 
 	 * @param fieldValue
 	 *            the value
 	 * @param view
 	 *            the view
 	 * @param escape
 	 *            if <code>true</code> then the string value is
 	 *            {@link #escape(String) escaped}.
 	 */
 	private static void assignValueToView(final Object fieldValue,
 			final View view, boolean escape) {
 		if (view instanceof CheckBox) {
 			((CheckBox) view).setChecked((Boolean) fieldValue);
 		} else if (view instanceof EditText) {
 			String value = fieldValue == null ? "" : fieldValue.toString();
 			if (escape) {
 				value = escape(value);
 			}
 			((EditText) view).setText(value);
 		} else if (view instanceof Spinner) {
 			final int ordinal;
 			if (fieldValue instanceof Enum<?>) {
 				ordinal = ((Enum<?>) fieldValue).ordinal();
 			} else {
 				ordinal = ((Number) fieldValue).intValue();
 			}
 			((Spinner) view).setSelection(ordinal);
 		} else
 			throw new IllegalArgumentException("Unsupported view class: "
 					+ view.getClass().getName());
 	}
 
 	private static String escape(String value) {
 		if (value == null)
 			return null;
 		return value.replace("\n", "//n");
 	}
 
 	private static String unescape(String value) {
 		if (value == null)
 			return null;
 		return value.replace("//n", "\n");
 	}
 
 	/***
 	 * Retrieves a value from a control.
 	 * 
 	 * @param fieldClass
 	 *            class of the value.
 	 * @param view
 	 *            the control.
 	 * @param unescape
 	 *            if <code>true</code> then the string value is
 	 *            {@link #unescape(String) unescaped}.
 	 * @return value with given class.
 	 */
 	private static Object assignViewToValue(final Class<?> fieldClass,
 			final View view, final boolean unescape) {
 		final Class<?> fc = primitiveToClass(fieldClass);
 		if (view instanceof CheckBox) {
 			if (!Boolean.class.isAssignableFrom(fc))
 				throw new IllegalArgumentException(fc.getName()
 						+ " not assignable from CheckBox");
 			return ((CheckBox) view).isChecked();
 		} else if (view instanceof EditText) {
 			String text = ((EditText) view).getText().toString();
 			if (unescape) {
 				text = unescape(text);
 			}
 			if (String.class.isAssignableFrom(fieldClass)) {
 				return text;
 			}
 			final Class<?> targetClass = isNumber(fieldClass);
 			if (targetClass != null) {
 				// invoke .valueOf on the string
 				try {
 					final Method valueOf = targetClass.getMethod("valueOf",
 							new Class[] { String.class });
 					return valueOf.invoke(null, new Object[] { text });
 				} catch (final Exception ex) {
 					throw new RuntimeException(ex);
 				}
 			}
 			throw new IllegalArgumentException(fieldClass.getName()
 					+ " not assignable from EditText");
 		} else if (view instanceof Spinner) {
 			final int ordinal = ((Spinner) view).getSelectedItemPosition();
 			if (fieldClass.isEnum()) {
 				return fieldClass.getEnumConstants()[ordinal];
 			}
 			return Integer.valueOf(ordinal);
 		}
 		throw new IllegalArgumentException("Unsupported view class: "
 				+ view.getClass().getName());
 	}
 
 	private final static Map<Class<?>, Class<?>> primitiveToClass = new HashMap<Class<?>, Class<?>>();
 	static {
 		primitiveToClass.put(int.class, Integer.class);
 		primitiveToClass.put(double.class, Double.class);
 		primitiveToClass.put(float.class, Float.class);
 		primitiveToClass.put(boolean.class, Boolean.class);
 		primitiveToClass.put(byte.class, Byte.class);
 		primitiveToClass.put(char.class, Character.class);
 		primitiveToClass.put(long.class, Long.class);
 	}
 
 	private static Class<?> primitiveToClass(final Class<?> clazz) {
 		if (!clazz.isPrimitive())
 			return clazz;
 		return primitiveToClass.get(clazz);
 	}
 
 	private static Class<?> isNumber(final Class<?> clazz) {
 		final Class<?> counterpart = primitiveToClass(clazz);
 		if (Number.class.isAssignableFrom(counterpart))
 			return counterpart;
 		return null;
 	}
 
 	/***
 	 * Copies all bindable properties from given bean to given bean.
 	 * 
 	 * @param <T>
 	 *            the bean type
 	 * @param from
 	 *            source bean
 	 * @param to
 	 *            target bean
 	 */
 	public static <T> void copy(T from, T to) {
 		try {
 			for (final Field field : from.getClass().getFields()) {
 				final Bind annotation = field.getAnnotation(Bind.class);
 				if (annotation == null)
 					continue;
 				if (!Modifier.isPublic(field.getModifiers()))
 					continue;
 				final Object fieldValue = field.get(from);
 				field.set(to, fieldValue);
 			}
 		} catch (IllegalAccessException e) {
 			throw new RuntimeException(e);
 		}
 	}
 }