/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * Licensed 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 com.DeviceTest.view;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Paint.Align;
import android.graphics.Paint.FontMetricsInt;
import android.util.AttributeSet;
import android.util.Log;
import android.view.*;
import android.view.View.OnTouchListener;
import android.widget.RelativeLayout;

import java.util.ArrayList;

public class PointerLocationView extends View implements OnTouchListener {
	public static class PointerState {
		private final ArrayList<Float> mXs = new ArrayList<Float>();
		private final ArrayList<Float> mYs = new ArrayList<Float>();
		private boolean mCurDown;
		private int mCurX;
		private int mCurY;
		private float mCurPressure;
		private float mCurSize;
		private int mCurWidth;
		private VelocityTracker mVelocity;
	}

	// private final ViewConfiguration mVC;
	private int NP = 0;
	private final Paint mTextPaint;
	// private final Paint mTextBackgroundPaint;
	// private final Paint mTextLevelPaint;
	private final Paint mPaint;
	private final Paint mTargetPaint;
	private final Paint mPathPaint;
	// private final FontMetricsInt mTextMetrics = new FontMetricsInt();
	// private int mHeaderBottom;
	private boolean mCurDown;
	private int mCurNumPointers;
	private int mMaxNumPointers;
	private final ArrayList<PointerState> mPointers = new ArrayList<PointerState>();

	private boolean mPrintCoords = true;

	public PointerLocationView(Context context, AttributeSet attrs) {
		this(context, attrs, 0);
	}

	public PointerLocationView(Context context, AttributeSet attrs, int defStyle) {
		super(context, attrs, defStyle);

		setFocusable(true);
		// mVC = ViewConfiguration.get(context);
		mTextPaint = new Paint();
		mTextPaint.setAntiAlias(true);
		mTextPaint.setTextSize(50 * getResources().getDisplayMetrics().density);
		mTextPaint.setARGB(255, 255, 0, 0);
		mTextPaint.setTextAlign(Align.RIGHT);
		/*
		 * mTextBackgroundPaint = new Paint();
		 * mTextBackgroundPaint.setAntiAlias(false);
		 * mTextBackgroundPaint.setARGB(128, 255, 255, 255); mTextLevelPaint =
		 * new Paint(); mTextLevelPaint.setAntiAlias(false);
		 * mTextLevelPaint.setARGB(192, 255, 0, 0);
		 */
		mPaint = new Paint();
		mPaint.setAntiAlias(true);
		mPaint.setARGB(255, 255, 255, 255);
		mPaint.setStyle(Paint.Style.STROKE);
		mPaint.setStrokeWidth(2);
		mTargetPaint = new Paint();
		mTargetPaint.setAntiAlias(false);
		mTargetPaint.setARGB(255, 0, 0, 192);
		mPathPaint = new Paint();
		mPathPaint.setAntiAlias(false);
		mPathPaint.setARGB(255, 0, 96, 255);
		mPaint.setStyle(Paint.Style.STROKE);
		mPaint.setStrokeWidth(1);

		PointerState ps = new PointerState();
		ps.mVelocity = VelocityTracker.obtain();
		mPointers.add(ps);
	}

	public void setPrintCoords(boolean state) {
		mPrintCoords = state;
	}

	
	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
		super.onMeasure(widthMeasureSpec, heightMeasureSpec);
		/*
		 * mTextPaint.getFontMetricsInt(mTextMetrics); mHeaderBottom =
		 * -mTextMetrics.ascent+mTextMetrics.descent+2;
		 */
		((ViewGroup)getParent()).setOnTouchListener(this);
	}

	
	protected void onDraw(Canvas canvas) {
		synchronized (mPointers) {
			NP = mPointers.size();

			/*
			 * final int w = getWidth(); final int itemW = w/7; final int base =
			 * -mTextMetrics.ascent+1; final int bottom = mHeaderBottom;
			 * 
			 * 
			 * if (NP > 0) { final PointerState ps = mPointers.get(0);
			 * canvas.drawRect(0, 0, itemW-1, bottom,mTextBackgroundPaint);
			 * canvas.drawText("P: " + mCurNumPointers + " / " +
			 * mMaxNumPointers, 1, base, mTextPaint);
			 * 
			 * final int N = ps.mXs.size(); if ((mCurDown && ps.mCurDown) || N
			 * == 0) { canvas.drawRect(itemW, 0, (itemW * 2) - 1, bottom,
			 * mTextBackgroundPaint); canvas.drawText("X: " + ps.mCurX, 1 +
			 * itemW, base, mTextPaint); canvas.drawRect(itemW * 2, 0, (itemW *
			 * 3) - 1, bottom, mTextBackgroundPaint); canvas.drawText("Y: " +
			 * ps.mCurY, 1 + itemW * 2, base, mTextPaint); } else { float dx =
			 * ps.mXs.get(N-1) - ps.mXs.get(0); float dy = ps.mYs.get(N-1) -
			 * ps.mYs.get(0); canvas.drawRect(itemW, 0, (itemW * 2) - 1, bottom,
			 * Math.abs(dx) < mVC.getScaledTouchSlop() ? mTextBackgroundPaint :
			 * mTextLevelPaint); canvas.drawText("dX: " + String.format("%.1f",
			 * dx), 1 + itemW, base, mTextPaint); canvas.drawRect(itemW * 2, 0,
			 * (itemW * 3) - 1, bottom, Math.abs(dy) < mVC.getScaledTouchSlop()
			 * ? mTextBackgroundPaint : mTextLevelPaint); canvas.drawText("dY: "
			 * + String.format("%.1f", dy), 1 + itemW * 2, base, mTextPaint); }
			 * 
			 * canvas.drawRect(itemW * 3, 0, (itemW * 4) - 1, bottom,
			 * mTextBackgroundPaint); int velocity = ps.mVelocity == null ? 0 :
			 * (int) (ps.mVelocity.getXVelocity() * 1000);
			 * canvas.drawText("Xv: " + velocity, 1 + itemW * 3, base,
			 * mTextPaint);
			 * 
			 * canvas.drawRect(itemW * 4, 0, (itemW * 5) - 1, bottom,
			 * mTextBackgroundPaint); velocity = ps.mVelocity == null ? 0 :
			 * (int) (ps.mVelocity.getYVelocity() * 1000);
			 * canvas.drawText("Yv: " + velocity, 1 + itemW * 4, base,
			 * mTextPaint);
			 * 
			 * canvas.drawRect(itemW * 5, 0, (itemW * 6) - 1, bottom,
			 * mTextBackgroundPaint); canvas.drawRect(itemW * 5, 0, (itemW * 5)
			 * + (ps.mCurPressure * itemW) - 1, bottom, mTextLevelPaint);
			 * canvas.drawText("Prs: " + String.format("%.2f", ps.mCurPressure),
			 * 1 + itemW * 5, base, mTextPaint);
			 * 
			 * canvas.drawRect(itemW * 6, 0, w, bottom, mTextBackgroundPaint);
			 * canvas.drawRect(itemW * 6, 0, (itemW * 6) + (ps.mCurSize * itemW)
			 * - 1, bottom, mTextLevelPaint); canvas.drawText("Size: " +
			 * String.format("%.2f", ps.mCurSize), 1 + itemW * 6, base,
			 * mTextPaint); }
			 */

			if (onPointCountChangeListener != null) {
				onPointCountChangeListener.onPointCountChange(mPointers.size());
			}
			canvas.drawText("Current Point:" + mCurNumPointers, getWidth() / 2, getHeight() / 2,
					mTextPaint);

			for (int p = 0; p < NP; p++) {
				final PointerState ps = mPointers.get(p);

				if (mCurDown && ps.mCurDown) {
					canvas.drawLine(0, (int) ps.mCurY, getWidth(),
							(int) ps.mCurY, mTargetPaint);
					canvas.drawLine((int) ps.mCurX, 0, (int) ps.mCurX,
							getHeight(), mTargetPaint);
					int pressureLevel = (int) (ps.mCurPressure * 255);
					mPaint.setARGB(255, pressureLevel, 128, 255 - pressureLevel);
					canvas.drawPoint(ps.mCurX, ps.mCurY, mPaint);
					canvas.drawCircle(ps.mCurX, ps.mCurY, ps.mCurWidth, mPaint);
				}
			}

			for (int p = 0; p < NP; p++) {
				final PointerState ps = mPointers.get(p);

				final int N = ps.mXs.size();
				float lastX = 0, lastY = 0;
				boolean haveLast = false;
				boolean drawn = false;
				mPaint.setARGB(255, 128, 255, 255);
				for (int i = 0; i < N; i++) {
					float x = ps.mXs.get(i);
					float y = ps.mYs.get(i);
					if (Float.isNaN(x)) {
						haveLast = false;
						continue;
					}
					if (haveLast) {
						canvas.drawLine(lastX, lastY, x, y, mPathPaint);
						canvas.drawPoint(lastX, lastY, mPaint);
						drawn = true;
					}
					lastX = x;
					lastY = y;
					haveLast = true;
				}

				if (drawn) {
					if (ps.mVelocity != null) {
						mPaint.setARGB(255, 255, 64, 128);
						float xVel = ps.mVelocity.getXVelocity() * (1000 / 60);
						float yVel = ps.mVelocity.getYVelocity() * (1000 / 60);
						canvas.drawLine(lastX, lastY, lastX + xVel, lastY
								+ yVel, mPaint);
					} else {
						canvas.drawPoint(lastX, lastY, mPaint);
					}
				}
			}
		}
	}

	public void addTouchEvent(MotionEvent event) {
		synchronized (mPointers) {
			int action = event.getAction();

			NP = mPointers.size();

			if (action == MotionEvent.ACTION_DOWN) {
				for (int p = 0; p < NP; p++) {
					final PointerState ps = mPointers.get(p);
					ps.mXs.clear();
					ps.mYs.clear();
					ps.mVelocity = VelocityTracker.obtain();
					ps.mCurDown = false;
				}
				mPointers.get(0).mCurDown = true;
				mMaxNumPointers = 0;
				if (mPrintCoords) {
					Log.i("Pointer", "Pointer 1: DOWN");
				}
			}

			if ((action & MotionEvent.ACTION_MASK) == MotionEvent.ACTION_POINTER_DOWN) {

				Log.i("Pointer", "action down");
				final int index = (action & MotionEvent.ACTION_POINTER_INDEX_MASK) >> MotionEvent.ACTION_POINTER_INDEX_SHIFT;
				final int id = event.getPointerId(index);
				while (NP <= id) {
					PointerState ps = new PointerState();
					ps.mVelocity = VelocityTracker.obtain();
					mPointers.add(ps);
					NP++;
				}
				final PointerState ps = mPointers.get(id);
				ps.mVelocity = VelocityTracker.obtain();
				ps.mCurDown = true;
				if (mPrintCoords) {
					Log.i("Pointer", "Pointer " + (id + 1) + ": DOWN");
				}
			}

			final int NI = event.getPointerCount();

			mCurDown = action != MotionEvent.ACTION_UP
					&& action != MotionEvent.ACTION_CANCEL;
			mCurNumPointers = mCurDown ? NI : 0;
			if (mMaxNumPointers < mCurNumPointers) {
				mMaxNumPointers = mCurNumPointers;
			}

			for (int i = 0; i < NI; i++) {
				final int id = event.getPointerId(i);
				final PointerState ps = mPointers.get(id);
				ps.mVelocity.addMovement(event);
				ps.mVelocity.computeCurrentVelocity(1);
				final int N = event.getHistorySize();
				for (int j = 0; j < N; j++) {
					if (mPrintCoords) {
						Log.i("Pointer",
								"Pointer " + (id + 1) + ": ("
										+ event.getHistoricalX(i, j) + ", "
										+ event.getHistoricalY(i, j) + ")"
										+ " Prs="
										+ event.getHistoricalPressure(i, j)
										+ " Size="
										+ event.getHistoricalSize(i, j));
					}
					ps.mXs.add(event.getHistoricalX(i, j));
					ps.mYs.add(event.getHistoricalY(i, j));
				}
				if (mPrintCoords) {
					Log.i("Pointer",
							"Pointer " + (id + 1) + ": (" + event.getX(i)
									+ ", " + event.getY(i) + ")" + " Prs="
									+ event.getPressure(i) + " Size="
									+ event.getSize(i));
				}
				ps.mXs.add(event.getX(i));
				ps.mYs.add(event.getY(i));
				ps.mCurX = (int) event.getX(i);
				ps.mCurY = (int) event.getY(i);
				// Log.i("Pointer", "Pointer #" + p + ": (" + ps.mCurX
				// + "," + ps.mCurY + ")");
				ps.mCurPressure = event.getPressure(i);
				ps.mCurSize = event.getSize(i);
				ps.mCurWidth = (int) (ps.mCurSize * (getWidth() / 3));
			}

			if ((action & MotionEvent.ACTION_MASK) == MotionEvent.ACTION_POINTER_UP) {

				Log.i("Pointer", "action up");
				final int index = (action & MotionEvent.ACTION_POINTER_INDEX_MASK) >> MotionEvent.ACTION_POINTER_INDEX_SHIFT;
				final int id = event.getPointerId(index);
				final PointerState ps = mPointers.get(id);
				ps.mXs.add(Float.NaN);
				ps.mYs.add(Float.NaN);
				ps.mCurDown = false;
				if (mPrintCoords) {
					Log.i("Pointer", "Pointer " + (id + 1) + ": UP");
				}
			}

			if (action == MotionEvent.ACTION_UP) {
				for (int i = 0; i < NI; i++) {
					final int id = event.getPointerId(i);
					final PointerState ps = mPointers.get(id);
					if (ps.mCurDown) {
						ps.mCurDown = false;
						if (mPrintCoords) {
							Log.i("Pointer", "Pointer " + (id + 1) + ": UP");
						}
					}
				}
			}

			postInvalidate();
		}
	}


	public interface OnPointCountChangeListener {
		public void onPointCountChange(int newPointCount);
	}

	private OnPointCountChangeListener onPointCountChangeListener;

	public void setOnPointCountChangeListener(
			OnPointCountChangeListener onPointCountChangeListener) {
		this.onPointCountChangeListener = onPointCountChangeListener;
	}
	
	
	public boolean onTouch(View v, MotionEvent event) {
		addTouchEvent(event);

		return true;
	}
}