/***
    *     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.views;
  
  import java.text.CharacterIterator;
  import java.text.StringCharacterIterator;
  import java.util.Collection;
  import java.util.StringTokenizer;
  
  import sk.baka.ambient.R;
  import android.app.AlertDialog;
  import android.app.Dialog;
  import android.content.Context;
  import android.content.DialogInterface;
  import android.content.DialogInterface.OnCancelListener;
  import android.graphics.Bitmap;
  import android.graphics.Paint;
  import android.graphics.Point;
  import android.graphics.Paint.FontMetricsInt;
  import android.text.Editable;
  import android.text.SpannableStringBuilder;
  import android.text.Spanned;
  import android.text.TextWatcher;
  import android.text.style.ImageSpan;
  import android.text.util.Linkify;
  import android.view.MotionEvent;
  import android.view.View;
  import android.view.View.OnClickListener;
  import android.widget.Button;
  import android.widget.EditText;
  import android.widget.TextView;
  
  /***
   * Utility methods for views. Not thread safe.
   * 
   * @author Martin Vysny
   */
  public final class ViewUtils {
  	/***
  	 * Clones given point
  	 * 
  	 * @param point
  	 *            the point to clone
  	 * @return cloned point
  	 */
  	public static final Point clone(final Point point) {
  		return new Point(point.x, point.y);
  	}
  
  	/***
  	 * {@link Bitmap#recycle() Recycles} given collection of bitmap. The
  	 * collection is emptied afterwards.
  	 * 
  	 * @param bitmaps
  	 *            bitmaps to recycle.
  	 */
  	public static void recycleBitmaps(final Collection<Bitmap> bitmaps) {
  		for (final Bitmap b : bitmaps) {
  			if (!b.isRecycled()) {
  				b.recycle();
  			}
  		}
  		bitmaps.clear();
  	}
  
  	/***
  	 * Here the temporary results of all translate* methods are stored. This is
  	 * just a cache, to prevent an array creation on each call.
  	 */
  	final int[] translatedPoint = new int[] { 0, 0 };
  
  	/***
  	 * Translates given point into target view's coordinate system and stores
  	 * the result into the {@link #translated} point.
  	 * 
  	 * @param point
  	 *            the point to translate. Will not get modified. If
  	 *            <code>null</code> then the {@link #translated} point data will
  	 *            be taken instead.
  	 * @param view
  	 *            the point belongs to the coordinate system of this view. If
  	 *            <code>null</code> then the point is an absolute screen
  	 *            position.
 	 * @param targetView
 	 *            translate the view to this view coordinate system. If
 	 *            <code>null</code> then the point will be returned as an
 	 *            absolute screen position.
 	 */
 	public void translateCoordinates(final Point point, final View view,
 			final View targetView) {
 		if (point != null) {
 			translated.x = point.x;
 			translated.y = point.y;
 		}
 		if (view == targetView)
 			return;
 		if (view != null) {
 			// transform the point into the absolute screen coordinate system
 			view.getLocationOnScreen(translatedPoint);
 			translated.x += translatedPoint[0];
 			translated.y += translatedPoint[1];
 		}
 		if (targetView != null) {
 			targetView.getLocationOnScreen(translatedPoint);
 			translated.x -= translatedPoint[0];
 			translated.y -= translatedPoint[1];
 		}
 	}
 
 	/***
 	 * A result of translate* operations is stored here.
 	 */
 	public final Point translated = new Point();
 
 	/***
 	 * Translates given point into root view's coordinate system. Does nothing
 	 * if the supplied view is <code>null</code>.
 	 * 
 	 * @param point
 	 *            the point to translate. Will not get modified.
 	 * @param view
 	 *            the point belongs to the coordinate system of this view. If
 	 *            <code>null</code> then the point is an absolute screen
 	 *            position.
 	 */
 	public void translateCoordinatesToRoot(final Point point, final View view) {
 		if (view == null)
 			return;
 		translateCoordinates(point, view, view.getRootView());
 	}
 
 	/***
 	 * Returns the text height.
 	 * 
 	 * @param paint
 	 *            the paint to use
 	 * @param text
 	 *            the text to measure
 	 * @return text height, in pixels.
 	 */
 	public static int getTextHeight(final Paint paint, final String text) {
 		final CharacterIterator i = new StringCharacterIterator(text);
 		int rows = 1;
 		for (char c = i.current(); c != CharacterIterator.DONE; c = i.next()) {
 			if (c == '\n')
 				rows++;
 		}
 		final FontMetricsInt f = paint.getFontMetricsInt();
 		return (f.bottom - f.top) * rows;
 	}
 
 	/***
 	 * Measures given text width/height and sets them to the given point.
 	 * 
 	 * @param paint
 	 *            the paint
 	 * @param text
 	 *            text to measure
 	 * @param point
 	 *            overwrites this point.
 	 */
 	public static void measureText(final Paint paint, final String text,
 			final Point point) {
 		point.x = intMeasureText(paint, text);
 		point.y = getTextHeight(paint, text);
 	}
 
 	/***
 	 * Measures text with given paint. Correctly handles newlines.
 	 * 
 	 * @param paint
 	 *            the paint
 	 * @param text
 	 *            the text to measure
 	 * @return text width.
 	 */
 	public static int intMeasureText(final Paint paint, final String text) {
 		int result = 0;
 		final StringTokenizer t = new StringTokenizer(text, "\n");
 		while (t.hasMoreElements()) {
 			int measured = (int) paint.measureText(t.nextToken());
 			if (result < measured) {
 				result = measured;
 			}
 		}
 		return result;
 	}
 	
 	/***
 	 * Measures given text width/height and returns the result as a point.
 	 * 
 	 * @param paint
 	 *            the paint
 	 * @param text
 	 *            text to measure
 	 * @return the text sizes
 	 */
 	public static Point measureText(final Paint paint, final String text) {
 		final Point result = new Point();
 		measureText(paint, text, result);
 		return result;
 	}
 
 	/***
 	 * Measures given text width/height and sets them to the
 	 * {@link #measuredText cached point}.
 	 * 
 	 * @param paint
 	 *            the paint
 	 * @param text
 	 *            text to measure
 	 */
 	public void measureTextCache(final Paint paint, final String text) {
 		measuredText.x = intMeasureText(paint, text);
 		measuredText.y = getTextHeight(paint, text);
 	}
 
 	/***
 	 * The result of {@link #measureTextCache(Paint, String)} is stored here.
 	 */
 	public final Point measuredText = new Point();
 
 	/***
 	 * Fired when a text has been successfully entered.
 	 * 
 	 * @author Martin Vysny
 	 */
 	public static interface OnTextSubmit {
 		/***
 		 * Validates given text. If the text is valid then return
 		 * <code>null</code>.
 		 * 
 		 * @param text
 		 *            the text to validate, never <code>null</code>.
 		 * @return <code>null</code> if the text is valid, error message
 		 *         otherwise.
 		 */
 		String validate(final String text);
 
 		/***
 		 * A text has been submitted, never <code>null</code>.
 		 * 
 		 * @param text
 		 *            the text.
 		 */
 		void submit(final String text);
 
 		/***
 		 * The dialog has been canceled.
 		 */
 		void cancel();
 	}
 
 	/***
 	 * Listens for dialog events.
 	 * 
 	 * @author Martin Vysny
 	 */
 	private static class AlertDlgListener implements TextWatcher,
 			OnClickListener, OnCancelListener {
 		private final TextView errorText;
 		private final EditText edit;
 		private final OnTextSubmit listener;
 		private final Dialog dlg;
 
 		/***
 		 * Creates new listener.
 		 * 
 		 * @param listener
 		 *            the listener
 		 * @param dlg
 		 *            the dialog instance.
 		 */
 		public AlertDlgListener(final OnTextSubmit listener, final Dialog dlg) {
 			super();
 			edit = (EditText) dlg.findViewById(R.id.texteditText);
 			errorText = (TextView) dlg.findViewById(R.id.texteditErrorMsg);
 			this.listener = listener;
 			this.dlg = dlg;
 			edit.addTextChangedListener(this);
 			((Button) dlg.findViewById(R.id.texteditSubmit))
 					.setOnClickListener(this);
 			((Button) dlg.findViewById(R.id.texteditCancel))
 					.setOnClickListener(this);
 			dlg.setOnCancelListener(this);
 			validate();
 		}
 
 		/***
 		 * Returns currently entered text.
 		 * 
 		 * @return currently entered text, never <code>null</code>.
 		 */
 		public String getText() {
 			String text = edit.getText().toString();
 			if (text == null)
 				text = "";
 			return text;
 		}
 
 		private boolean validate() {
 			final String text = getText();
 			final String validate = listener.validate(text);
 			final boolean isValid = validate == null;
 			if (!isValid) {
 				errorText.setVisibility(View.VISIBLE);
 				errorText.setText(validate);
 			} else {
 				errorText.setText("");
 				errorText.setVisibility(View.INVISIBLE);
 			}
 			return isValid;
 		}
 
 		public void beforeTextChanged(CharSequence s, int start, int count,
 				int after) {
 			// do nothing
 		}
 
 		public void onTextChanged(CharSequence s, int start, int before,
 				int count) {
 			validate();
 		}
 
 		public void onClick(View arg0) {
 			switch (arg0.getId()) {
 			case R.id.texteditSubmit:
 				if (!validate())
 					return;
 				listener.submit(getText());
 				dlg.dismiss();
 				break;
 			case R.id.texteditCancel:
 				dlg.cancel();
 				break;
 			}
 		}
 
 		public void onCancel(DialogInterface arg0) {
 			listener.cancel();
 		}
 
 		public void afterTextChanged(Editable s) {
 			// do nothing
 		}
 	}
 
 	/***
 	 * Creates new text dialog with a text enter capability. When the dialog is
 	 * submitted the text submit event is fired.
 	 * 
 	 * @param context
 	 *            the context
 	 * @param submitButtonCaption
 	 *            the submit button caption, if <code>null</code> then OK will
 	 *            be shown.
 	 * @param cancelButtonCaption
 	 *            the cancel button caption, if <code>null</code> then Cancel
 	 *            will be shown.
 	 * @param dialogCaption
 	 *            the dialog caption
 	 * @param text
 	 *            the text to show in the dialog.
 	 * @param listener
 	 *            fire events on this listener
 	 * @return the dialog instance. The dialog is already shown.
 	 */
 	public static Dialog showTextEditor(final Context context,
 			final String submitButtonCaption, final String cancelButtonCaption,
 			final String dialogCaption, final String text,
 			final OnTextSubmit listener) {
 		if (listener == null)
 			throw new IllegalArgumentException("listener is null");
 		final Dialog dlg = new Dialog(context);
 		dlg.setTitle(dialogCaption);
 		dlg.setContentView(R.layout.texteditor);
 		((TextView) dlg.findViewById(R.id.texteditCaption)).setText(text);
 		if (submitButtonCaption != null) {
 			((Button) dlg.findViewById(R.id.texteditSubmit))
 					.setText(submitButtonCaption);
 		}
 		if (cancelButtonCaption != null) {
 			((Button) dlg.findViewById(R.id.texteditCancel))
 					.setText(cancelButtonCaption);
 		}
 		dlg.setCancelable(true);
 		new AlertDlgListener(listener, dlg);
 		dlg.show();
 		return dlg;
 	}
 
 	/***
 	 * Cancels the dialog on invocation.
 	 */
 	public final static DialogInterface.OnClickListener CANCEL = new DialogInterface.OnClickListener() {
 		public void onClick(DialogInterface arg0, int arg1) {
 			arg0.cancel();
 		}
 	};
 
 	/***
 	 * Shows a simple yes/no question dialog.
 	 * 
 	 * @param context
 	 *            the context.
 	 * @param question
 	 *            the question body.
 	 * @param yesButtonListener
 	 *            invoked when user presses the 'Yes' button.
 	 * @return the dialog instance. The dialog is already shown.
 	 */
 	public static AlertDialog showYesNoDialog(final Context context,
 			final String question,
 			final DialogInterface.OnClickListener yesButtonListener) {
 		final AlertDialog.Builder builder = new AlertDialog.Builder(context);
 		final AlertDialog dlg = builder.setMessage(question).create();
 		dlg.setButton(context.getResources().getString(R.string.yes),
 				yesButtonListener);
 		dlg.setButton2(context.getResources().getString(R.string.no),
 				ViewUtils.CANCEL);
 		dlg.show();
 		return dlg;
 	}
 
 	/***
 	 * Shows a simple OK dialog.
 	 * 
 	 * @param context
 	 *            the context.
 	 * @param caption
 	 *            the dialog caption
 	 * @param text
 	 *            the text body.
 	 * @param icon
 	 *            optional dialog icon, may be -1 if it should not be shown.
 	 * @return the dialog instance. The dialog is already shown.
 	 */
 	public static AlertDialog showOkDialog(final Context context,
 			final CharSequence caption, final CharSequence text, final int icon) {
 		final AlertDialog.Builder builder = new AlertDialog.Builder(context);
 		if (icon != -1) {
 			builder.setIcon(icon);
 		}
 		final SpannableStringBuilder b = new SpannableStringBuilder(text);
 		Linkify.addLinks(b, Linkify.ALL);
 		final AlertDialog dlg = builder.setTitle(caption).setMessage(b)
 				.create();
 		dlg.setButton(context.getResources().getString(R.string.ok),
 				ViewUtils.CANCEL);
 		dlg.show();
 		return dlg;
 	}
 
 	/***
 	 * Checks if given event is a {@link MotionEvent#ACTION_UP} or
 	 * {@link MotionEvent#ACTION_CANCEL} event.
 	 * 
 	 * @param event
 	 *            the event to check
 	 * @return <code>true</code> if pen is up or the motion is canceled,
 	 *         <code>false</code> otherwise.
 	 */
 	public static boolean isPenUp(final MotionEvent event) {
 		final int action = event.getAction();
 		return (action == MotionEvent.ACTION_UP)
 				|| (action == MotionEvent.ACTION_CANCEL);
 	}
 
 	/***
 	 * Checks if given event is a {@link MotionEvent#ACTION_CANCEL} event.
 	 * 
 	 * @param event
 	 *            the event to check
 	 * @return <code>true</code> if the motion is canceled, <code>false</code>
 	 *         otherwise.
 	 */
 	public static boolean isCancel(final MotionEvent event) {
 		final int action = event.getAction();
 		return action == MotionEvent.ACTION_CANCEL;
 	}
 
 	/***
 	 * Appends an {@link ImageSpan} to given builder.
 	 * 
 	 * @param c
 	 *            the context
 	 * @param s
 	 *            the builder
 	 * @param resId
 	 *            image id.
 	 */
 	public static void addImage(final Context c,
 			final SpannableStringBuilder s, final int resId) {
 		s.append("W");
 		s.setSpan(new ImageSpan(c, resId), s.length() - 1, s.length(),
 				Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
 	}
 }