package com.icystar.findnumber;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import java.util.Random;

import java.util.Timer;

import java.util.TimerTask;

import android.content.Context;

import android.graphics.Canvas;

import android.graphics.Paint;

import android.graphics.Point;

import android.graphics.Rect;

import android.graphics.Typeface;

import android.text.TextPaint;

import android.util.FloatMath;

import android.view.View;

import android.widget.TextView;

public class Game {

	public static Game[] games = new Game[] { new Game(), new Game() };

	public static class Number {

		public int number;

		public String text;

		public int digits;

		public int sizeIndex;

		public float size;

		public float scaleX;

		public int fontIndex;

		Typeface font;

		public Rect rect = new Rect();

		public Point position = new Point();

		public void save(FileOutputStream fos) throws IOException {

			Serializer.writeInt(fos, number);

			Serializer.writeFloat(fos, size);

			Serializer.writeFloat(fos, scaleX);

			Serializer.writeInt(fos, fontIndex);

			Serializer.writeInt(fos, rect.left);

			Serializer.writeInt(fos, rect.right);

			Serializer.writeInt(fos, rect.top);

			Serializer.writeInt(fos, rect.bottom);

			Serializer.writeInt(fos, position.x);

			Serializer.writeInt(fos, position.y);

		}

		public void load(FileInputStream fis) throws IOException {

			number 		= Serializer.readInt(fis);

			size 		= Serializer.readFloat(fis);

			scaleX 		= Serializer.readFloat(fis);

			fontIndex 	= Serializer.readInt(fis);

			rect.left 	= Serializer.readInt(fis);

			rect.right 	= Serializer.readInt(fis);

			rect.top 	= Serializer.readInt(fis);

			rect.bottom = Serializer.readInt(fis);

			position.x 	= Serializer.readInt(fis);

			position.y 	= Serializer.readInt(fis);

			text = Integer.toString(number);

			digits = text.length();

			sizeIndex = 0;

			font = fonts[fontIndex];

		}

	}

	public interface Listener {

		public void onLock(Game game);

		public void onWin(Game game, float time);

		public void onTouchNumber(Game game, int touchedNumber, int maxNumber, boolean win);

	}

	private static final String filename = "game.sav";

	private static final int sizesCount = 100;

	private static final int generationTrials = 100;

	private static final int fontTrials = 100;

	private static final int positionTrials = 100;

	public static final Typeface[] fonts = new Typeface[] {

		Typeface.create(Typeface.SERIF, Typeface.NORMAL),

		Typeface.create(Typeface.SERIF, Typeface.BOLD),

		Typeface.create(Typeface.SERIF, Typeface.ITALIC),

		Typeface.create(Typeface.SERIF, Typeface.BOLD_ITALIC),

		Typeface.create(Typeface.SANS_SERIF, Typeface.NORMAL),

		Typeface.create(Typeface.SANS_SERIF, Typeface.BOLD),

		Typeface.create(Typeface.SANS_SERIF, Typeface.ITALIC),

		Typeface.create(Typeface.SANS_SERIF, Typeface.BOLD_ITALIC)

	};

	private static Object staticHandle = new Object();

	private static boolean stateLoaded = false;

	private static String[] playerNames;

	private int width = 0;

	private int height = 0;

	private float minSize; 

	private float maxSize; 

	private int initialMaxSizeIndex; 

	private int maxDigits; 

	private Rect[][][] sizes;

	private TextPaint paint = new TextPaint(Paint.ANTI_ALIAS_FLAG);

	private TextView numberTextView;

	private TextView timeTextView;

	private TextView playerNameTextView;

	private NumbersView numbersView;

	private View lockView;

	private Listener listener;

	private Timer timer;

	private Object handle = new Object();

	private int waitToGenerate = 0;

	private List<point> invalidTouches = new ArrayList<point>();
</point></point>

	// serialization data

	private Number[] numbers = new Number[0];

	private int currentNumberIndex = -1;

	private int currentNumber = 0;

	private float time = 0;

	private float lockTime = 0;

	private boolean paused = true;

	private boolean playing = false;

	private boolean isWin = false;

	private boolean isLose = false;

	public void save(FileOutputStream fos) throws IOException {

		synchronized (handle) {

			Serializer.writeInt(fos, currentNumberIndex);

			Serializer.writeInt(fos, Math.round(time));

			Serializer.writeInt(fos, Math.round(lockTime));

			Serializer.writeInt(fos, paused ? 1 : 0);

			Serializer.writeInt(fos, playing ? 1 : 0);

			Serializer.writeInt(fos, numbers.length);

			for(Number number : numbers)

				number.save(fos);

		}

	}

	public void load(FileInputStream fis) throws IOException {

		synchronized (handle) {

			currentNumberIndex	= Serializer.readInt(fis);

			time				= Serializer.readInt(fis);

			lockTime			= Serializer.readInt(fis);

			paused				= Serializer.readInt(fis) != 0;

			playing				= Serializer.readInt(fis) != 0;

			numbers = new Number[Serializer.readInt(fis)];

			for(int i = 0; i < numbers.length; i++) {

				numbers[i] = new Number();

				numbers[i].load(fis);

			}

			currentNumber = currentNumberIndex >= 0 && currentNumberIndex < numbers.length

			              ? numbers[currentNumberIndex].number : 0; 

		}

	}

	Game() {

		timer = new Timer();

		timer.schedule(new TimerTask() {

			@Override

			public void run() { onTime(1); }

		}, 1000, 1000);

	}

	private float internalCalcSize(int index) {

		return minSize + (maxSize - minSize)*(float)index/(float)(sizesCount-1);

	}

	private void internalCalcSizes(int count) {

		maxSize = Math.min(width, height)/2f;

		minSize = count < 50 ? maxSize/5f : maxSize/10f;

		initialMaxSizeIndex = sizesCount/2;

		if (count > 25) initialMaxSizeIndex = sizesCount/4;

		if (count > 50) initialMaxSizeIndex = sizesCount/6;

		if (initialMaxSizeIndex < 1) initialMaxSizeIndex = 1;

		String template = "MMMMMMMMMMMMMMMMMMMMMMMMMMMMM";

		sizes = new Rect[fonts.length][sizesCount][maxDigits + 1];

		paint.setTextScaleX(1f);

		for(int fontIndex = 0; fontIndex < fonts.length; fontIndex++) {

			paint.setTypeface(fonts[fontIndex]);

			for(int sizeIndex = 0; sizeIndex < sizesCount; sizeIndex++) {

				paint.setTextSize(internalCalcSize(sizeIndex));

				for(int digits = 0; digits <= maxDigits; digits++) {

					sizes[fontIndex][sizeIndex][digits] = new Rect();

					paint.getTextBounds(template, 0, digits, sizes[fontIndex][sizeIndex][digits]);

				}

			}

		}

	}

	private boolean internalCheckRect(Rect rect, int count, int exclude) {

		if (rect.left < 0 || rect.top < 0 || rect.right > width || rect.bottom > height)

			return false;

		for(int i = 0; i < count; i++)

			if (Rect.intersects(rect, numbers[i].rect))

				return false;

		return true;

	}

	private void internalGenerate(int count) {

		waitToGenerate = 0;

		time = 0;

		lockTime = 0;

		playing = false;

		isWin = false;

		isLose = false;

		if (timer != null) timer.cancel();

		timer = null;

		maxDigits = count < 10 ? 1 : (count < 100 ? 2 : (count < 1000 ? 3 : 4));

		internalCalcSizes(count);

		numbers = new Number[count];

		Random random = new Random();

		// fill digits

		int[] remainingNumbers = new int[count];

		for(int i = 0; i < count; i++) remainingNumbers[i] = i+1;

		for(int i = 0; i < count; i++) {

			int j = random.nextInt(count - i);

			numbers[i] = new Number();

			numbers[i].number = remainingNumbers[j];

			numbers[i].text = Integer.toString(numbers[i].number);

			numbers[i].digits = numbers[i].text.length();

			for(int k = j+1; k < count-i; k++) remainingNumbers[k-1] = remainingNumbers[k];

		}

		// generate numbers

		boolean success = false;

		for(int generationTry = 0; !success && generationTry < generationTrials; generationTry++) {

			for(int i = 0; i < count; i++) {

				success = false;

				Number number = numbers[i];

				for(int fontTry = 0; !success && fontTry < fontTrials && fontTry < initialMaxSizeIndex; fontTry++) {

					number.fontIndex = random.nextInt(fonts.length);

					number.sizeIndex = random.nextInt(initialMaxSizeIndex - fontTry);

					number.font = fonts[number.fontIndex];

					number.size = internalCalcSize(number.sizeIndex);					

					number.scaleX = 1f; //random.nextFloat()*1.5f + 0.5f;

					Rect r = sizes[number.fontIndex][number.sizeIndex][number.digits];

					int w = Math.round((r.right - r.left)*number.scaleX);

					int h = r.bottom - r.top;

					if (w < width && h < height) {

						for(int positionTry = 0; !success && positionTry < positionTrials; positionTry++) {

							int x = random.nextInt(width - w);

							int y = random.nextInt(height - h);

							number.rect.set(x, y, x+w, y+h);

							number.position.set(number.rect.left - r.left, number.rect.top - r.top);

							if (internalCheckRect(number.rect, i, -1))

								success = true;

						}

					}

				}

				if (!success) break;

			}

		}

		if (success) {

			// enlarge numbers

			boolean enlarged = false;

			Rect[] rects = new Rect[] { new Rect(), new Rect(), new Rect(), new Rect() }; 

			while (enlarged) {

				enlarged = true;

				for(int i = 0; i < count; i++) {

					Number number = numbers[i];

					if (number.sizeIndex < sizesCount) {

						Rect r = sizes[number.fontIndex][number.sizeIndex+1][number.digits];

						int w = Math.round((r.right - r.left)*number.scaleX);

						int h = r.bottom - r.top;

						int validCount = 0;

						for(int j = 0; j < 3; j++) {

							int x = j % 2 == 0 ? number.rect.left : number.rect.right - w; 

							int y = j / 2 == 0 ? number.rect.top : number.rect.bottom - h;

							rects[validCount].set(x, y, x+w, y+h);

							if (internalCheckRect(rects[validCount], count, i)) validCount++;

						}

						if (validCount > 0) {

							number.sizeIndex++;

							number.size = internalCalcSize(number.sizeIndex);

							number.rect.set(rects[random.nextInt(validCount)]);

							number.position.set(number.rect.left - r.left, number.rect.top - r.top);

							enlarged = true;

						}

					}

				}

			}

		} else {

			numbers = new Number[0];

		}

		time = 0;

		lockTime = 0;

		playing = true;

		internalSetCurrentNumber(1);

		internalUpdateViews();

		timer = new Timer();

		timer.schedule(new TimerTask() {

			@Override

			public void run() { onTime(1); }

		}, 1000, 1000);

	}

	private static boolean checkDistance(int x0, int y0, int x1, int y1, int distSqr)

		{ return (x1-x0)*(x1-x0) + (y1-y0)*(y1-y0) < distSqr; }

	private boolean internalCheckTouch(int x, int y) {

		Number number = null;

		try { number = numbers[currentNumberIndex]; } catch (Exception e) { }

		if (number != null) {

			int radius = Math.min(width, height)/20;

			int radiusSqr = radius*radius;

			Rect rect = number.rect;

			if (new Rect(rect.left - radius, rect.top, rect.right + 2*radius, rect.bottom ).contains(x, y)

			 || new Rect(rect.left, rect.top - radius, rect.right, rect.bottom + 2*radius ).contains(x, y)

			 || checkDistance(x, y, rect.left, rect.top, radiusSqr) 

			 || checkDistance(x, y, rect.right, rect.top, radiusSqr) 

			 || checkDistance(x, y, rect.left, rect.bottom, radiusSqr) 

			 || checkDistance(x, y, rect.right, rect.bottom, radiusSqr) 

			) {

				return true;

			}

		}

		return false;

	}

	private void internalSetCurrentNumber(int value) {

		currentNumberIndex = -1;

		currentNumber = 0;

		for(int i = 0; i < numbers.length; i++)

			if (numbers[i].number == value)

				{ currentNumberIndex = i; currentNumber = value; break; }

		internalUpdateNumberTextView();

	}

	private void internalUpdateNumberTextView() {

		if (numberTextView != null) {

			int numbersCount = numbers.length; 

			int numbersFound = isWin ? numbersCount : currentNumber - 1;

			int id = R.string.currentNumber;

			if (isLose) id = R.string.currentNumberLose;

			if (isWin) { id = R.string.currentNumberWin; numbersFound = numbersCount; } 

			final TextView textView = numberTextView;

			final String text = textView.getContext().getString(id, currentNumber, numbersFound, numbersCount);

			textView.post(new Runnable() { @Override public void run() { textView.setText(text); } });

		}

	}

	private void internalUpdateTimeTextView() {

		if (timeTextView != null) {

			int min = (int)FloatMath.floor(time/60);

			int sec = (int)FloatMath.floor(time - min*60);

			String minStr = Integer.toString(min);

			String secStr = Integer.toString(sec);

			while (minStr.length()  < 2) minStr = "0" + minStr;

			while (secStr.length()  < 2) secStr = "0" + secStr;

			final TextView textView = timeTextView;

			final String text = minStr + ":" + secStr;

			textView.post(new Runnable() { @Override public void run() { textView.setText(text); } });

		}

	}

	private void internalUpdatePlayerNameTextView() {

		if (playerNameTextView != null) {

			final TextView textView = playerNameTextView;

			final int visibility = playing ? View.VISIBLE : View.GONE;

			textView.post(new Runnable() { @Override public void run() { textView.setVisibility(visibility); } });

		}

	}

	private void internalUpdateNumbersView() {

		if (numbersView != null) {

			final NumbersView view = numbersView;

			view.post(new Runnable() { @Override public void run() { view.invalidate(); } });

		}

	}

	private void internalUpdateLockView() {

		if (lockView != null) {

			final View view = lockView;

			final int visibility = lockTime <= 0 ? View.GONE : View.VISIBLE;

			view.post(new Runnable() { @Override public void run() {

				if (view.getVisibility() != visibility) view.setVisibility(visibility);

				if (visibility == View.VISIBLE) view.invalidate();

			} });

		}

	}

	private void internalUpdateViews() {

		internalUpdateNumberTextView();

		internalUpdateTimeTextView();

		internalUpdatePlayerNameTextView();

		internalUpdateNumbersView();

		internalUpdateLockView();

	}

	public void start(int count) {

		synchronized (handle) {

			if (width > 0 && height > 0)

				internalGenerate(count);

			else

				waitToGenerate = count;

		}

	}

	public void stop() {

		synchronized (handle) {

			playing = false;

			isWin = false;

			isLose = false;

			numbers = new Number[0];

			internalUpdateNumberTextView();

			internalUpdatePlayerNameTextView();

		}

	}

	public void lose() {

		synchronized (handle) {

			playing = false;

			isWin = false;

			isLose = true;

			internalUpdateNumberTextView();

			internalUpdatePlayerNameTextView();

		}

	}

	public void win() {

		synchronized (handle) {

			playing = false;

			isWin = true;

			isLose = false;

			internalUpdateNumberTextView();

			internalUpdatePlayerNameTextView();

		}

	}

	public static void lock() {

		for(Game game : games) {

			synchronized (game.handle) {

				game.lockTime = 5;

				game.internalUpdateLockView();

			}

			if (game.listener != null) game.listener.onLock(game);

		}

	}

	public boolean getPlaying()

		{ synchronized (handle) { return playing; } }

	public boolean getPaused()

		{ synchronized (handle) { return paused; } }

	public void setPaused(boolean value)

		{ synchronized (handle) { paused = value; } }

	public int getCount()

		{ synchronized (handle) { return numbers.length; } }

	public int getCurrentNumber() {

		synchronized (handle) {

			try { return numbers[currentNumberIndex].number; } catch (Exception e) { }

			return 0;

		}

	}

	public void onLayout(int width, int height) {

		synchronized (handle) {

			this.width = width;

			this.height = height;

			if (width > 0 && height > 0 && waitToGenerate > 0)

				internalGenerate(waitToGenerate);

		}

	}

	public void onTouch(int x, int y) {

		boolean touch = false;

		int touchedNumber = 0;

		int maxNumber = 0;

		boolean win = false;

		float winTime = 0;

		synchronized (handle) {

			if (playing && !paused && lockTime <= 0) {

				if (internalCheckTouch(x, y)) {

					touch = true;

					touchedNumber = currentNumber;

					maxNumber = numbers.length;

					if (currentNumber < numbers.length) {

						internalSetCurrentNumber(currentNumber + 1);

					} else {

						this.win();

						win = true;

						winTime = time;

					}

					invalidTouches.clear();

				} else {

					invalidTouches.add(new Point(x, y));

					if (invalidTouches.size() > 1) {

						int maxDist = Math.min(width, height)/4;

						int places = 1;

						Point min = new Point(width, height);

						Point max = new Point(0, 0);

						for(Point p : invalidTouches) {

							min.x = Math.min(min.x, p.x);

							min.y = Math.min(min.y, p.y);

							max.x = Math.max(max.x, p.x);

							max.y = Math.max(max.y, p.y);

							if (max.x - min.x > maxDist || max.y - min.y > maxDist) {

								places++;

								min.set(p.x, p.y);

								max.set(p.x, p.y);

							}

						}

						if (places > 3) {

							lock();

							invalidTouches.clear();

						}

					}

				}

			}

		}

		if (touch && listener != null) listener.onTouchNumber(this, touchedNumber, maxNumber, win);

		if (win && listener != null) listener.onWin(this, winTime);

	}

	public void onTime(float time) {

		synchronized (handle) {

			if (playing && !paused) {

				this.time += time;

				lockTime -= time;

				if (lockTime <= 0) lockTime = 0;

				internalUpdateTimeTextView();

				internalUpdateLockView();

				if (Math.round(this.time) % 3 == 0 && invalidTouches.size() > 0)

					invalidTouches.remove(0);

			}

		}

	}

	public void draw(Canvas canvas) {

		synchronized (handle) {

			for(int i = 0; i < numbers.length; i++) {

				Number number = numbers[i];

				paint.setTypeface(number.font);

				paint.setTextSize(number.size);

				paint.setTextScaleX(number.scaleX);

				canvas.drawText(number.text, number.position.x, number.position.y, paint);

			}

		}

	}

	public void setListener(Listener value)

		{ synchronized (handle) { listener = value; } }

	public void setNumberTextView(TextView value)

		{ synchronized (handle) { numberTextView = value; internalUpdateNumberTextView(); } }

	public void setTimeTextView(TextView value)

		{ synchronized (handle) { timeTextView = value; internalUpdateTimeTextView(); } }

	public void setPlayerNameTextView(TextView value)

		{ synchronized (handle) { playerNameTextView = value; internalUpdatePlayerNameTextView(); } }

	public void setNumbersView(NumbersView value)

		{ synchronized (handle) { numbersView = value; internalUpdateNumbersView(); } }

	public void setLockView(View value)

		{ synchronized (handle) { lockView = value; internalUpdateLockView(); } }

	private static void save(Context context) {

		try {

			FileOutputStream fos = context.openFileOutput(filename, Context.MODE_PRIVATE);

			for(Game game : games) game.save(fos);

			Serializer.writeInt(fos, playerNames.length);

			if (playerNames == null) playerNames = new String[0];

			for(String name : playerNames)

				Serializer.writeString(fos, name);

			ScoreboardActivity.save(fos);

			Serializer.writeInt(fos, SoundPlayer.getEnabled() ? 1 : 0);

		} catch (Exception e) { }

	}

	private static void load(Context context) {

		for(Game game : games) game.stop();

		try {

			FileInputStream fis = context.openFileInput(filename);

			for(Game game : games) game.load(fis);

			playerNames = new String[Serializer.readInt(fis)];

			for(int i = 0; i < playerNames.length; i++)

				playerNames[i] = Serializer.readString(fis);

			ScoreboardActivity.load(fis);

			SoundPlayer.setEnabled(Serializer.readInt(fis) != 0);

		} catch (Exception e) {

			for(Game game : games) game.stop();

			//e.printStackTrace();

		}

		if (playerNames == null) playerNames = new String[0];

	}

	public static void saveState(Context context) {

		synchronized (staticHandle) {

			save(context);

		}

	}

	public static void loadState(Context context) {

		synchronized (staticHandle) {

			if (!stateLoaded) {

				stateLoaded = true;

				load(context);

			}

		}

	}

	public static int getMode() {

		boolean g0 = games[0].getCount() > 0;

		boolean g1 = games[1].getCount() > 0;

		if (g0 && g1) return 2;	

		if (g0 && !g1) return 1;

		return 0;

	}

	public static boolean getAnyPlaying() {

		switch (getMode()) {

		case 1:

			return games[0].getPlaying();

		case 2:

			return games[0].getPlaying() || games[1].getPlaying();

		}

		return false;

	}

	public static String getPlayerName(int index) {

		synchronized (staticHandle) {

			try { return playerNames[index] == null ? "" : playerNames[index]; } catch (Exception e) { }

			return "";

		}

	}

	public static void setPlayerName(int index, String name) {

		synchronized (staticHandle) {

			if (name != null && name.length() > 0) {

				try {

					playerNames = Serializer.enlargeArrayIfNeed(String.class, playerNames, index+1);

					playerNames[index] = name;

				} catch (Exception e) {	}

			}

		}

	}

}