/*

 * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game

 * Copyright (C) 2012 Simeon Maxein <smaxein@googlemail.com>

 *

 * 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 2

 * 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, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

 */

package org.hedgewars.hedgeroid;

import java.io.File;

import java.io.FileNotFoundException;

import org.hedgewars.hedgeroid.Datastructures.MapFile;

import org.hedgewars.hedgeroid.Datastructures.MapRecipe;

import org.hedgewars.hedgeroid.EngineProtocol.PascalExports;

import org.hedgewars.hedgeroid.frontlib.Flib;

import org.hedgewars.hedgeroid.frontlib.Frontlib;

import org.hedgewars.hedgeroid.frontlib.Frontlib.MapRecipePtr;

import org.hedgewars.hedgeroid.frontlib.Frontlib.MapconnPtr;

import org.hedgewars.hedgeroid.frontlib.Frontlib.MapimageCallback;

import org.hedgewars.hedgeroid.frontlib.Frontlib.StrCallback;

import org.hedgewars.hedgeroid.util.FileUtils;

import android.content.Context;

import android.graphics.Bitmap;

import android.graphics.Bitmap.Config;

import android.graphics.Color;

import android.graphics.drawable.BitmapDrawable;

import android.graphics.drawable.Drawable;

import android.os.Handler;

import android.os.Looper;

import android.util.Log;

import com.sun.jna.Pointer;

/**

 * A class that asynchronously generates a map preview from a MapRecipe.

 * 

 * For named maps, this will load the preview image from the filesystem. For others,

 * it will call the Hedgewars engine to generate a preview image. The result is sent

 * back to a listener on the UI thread.

 */

public final class MapPreviewGenerator implements Runnable {

	private static final String TAG = MapPreviewGenerator.class.getSimpleName();

	private static final Handler mainHandler = new Handler(Looper.getMainLooper());

	private static final long TIMEOUT_NS = 20l * 1000 * 1000 * 1000;

	private final Context appContext;

	private final MapRecipe map;

	private final Listener listener;

	private boolean resultAvailable;

	private Drawable result;

	public static interface Listener {

		/**

		 * This is called on the UI thread once the preview is ready or failed.

		 * In case of failure, null is passed.

		 */

		void onMapPreviewResult(Drawable preview);

	}

	private MapPreviewGenerator(Context appContext, MapRecipe map, Listener listener) {

		this.appContext = appContext;

		this.map = map;

		this.listener = listener;

	}

	public void run() {

		if (map.mapgen == Frontlib.MAPGEN_NAMED) {

			postToListener(loadPreviewFromFile(appContext, map.name));

		} else {

			resultAvailable = false;

			result = null;

			MapconnPtr conn = Flib.INSTANCE.flib_mapconn_create(MapRecipePtr.createJavaOwned(map));

			if (conn == null) {

				postToListener(null);

				return;

			}

			try {

				int port = Flib.INSTANCE.flib_mapconn_getport(conn);

				Flib.INSTANCE.flib_mapconn_onSuccess(conn, successCb, null);

				Flib.INSTANCE.flib_mapconn_onFailure(conn, failureCb, null);

				String configPath;

				try {

					configPath = FileUtils.getCachePath(appContext).getAbsolutePath();

				} catch(FileNotFoundException e) {

					return;

				}

				startEngine(configPath, port);

				long startTime = System.nanoTime();

				do {

					Flib.INSTANCE.flib_mapconn_tick(conn);

					try {

						Thread.sleep(50);

					} catch (InterruptedException e) {

						// ignore

					}

					if(System.nanoTime()-startTime > TIMEOUT_NS) {

						Log.w(TAG, "Error generating map preview: timeout");

						resultAvailable = true;

					}

				} while(!resultAvailable); 

			} finally {

				Flib.INSTANCE.flib_mapconn_destroy(conn);

				postToListener(result);

			}

		}

	}

	public static void startPreviewGeneration(Context appContext, MapRecipe map, Listener listener) {

		new Thread(new MapPreviewGenerator(appContext, map, listener)).start();

	}

	private static Drawable loadPreviewFromFile(Context appContext, String mapName) {

		if(!mapName.startsWith("+")) {

			try {

				File previewFile = MapFile.getPreviewFile(appContext, mapName);

				return Drawable.createFromPath(previewFile.getAbsolutePath());

			} catch (FileNotFoundException e) {

				Log.w("MapPreviewGenerator", "Preview for map "+mapName+" not found.");

			}

		}

		return null;

	}

	private static void startEngine(final String configPath, final int port) {

		new Thread(new Runnable() {

			public void run() {

				Log.d(TAG, "Starting engine "+port);

				PascalExports.synchronizedGenLandPreview(port);

				Log.d(TAG, "Engine finished");

			}

		}).start();

	}

	private void postToListener(final Drawable result) {

		mainHandler.post(new Runnable() {

			public void run() {

				listener.onMapPreviewResult(result);

			}

		});

	}

	/**

	 * Let's be extra nice here and clip off the left and right sides, so the preview is centered...

	 * Since the image is present in bytes, we can save some effort by checking entire byte-columns first.

	 */

	private final MapimageCallback successCb = new MapimageCallback() {

			int leftmostPixel = Frontlib.MAPIMAGE_WIDTH;

			int rightmostPixel = -1;

			int bytesPerLine = Frontlib.MAPIMAGE_WIDTH/8;

			// Find the leftmost pixel

			for(int xbyte=0; xbyte<bytesPerLine; xbyte++) {

				for(int y=0; y<Frontlib.MAPIMAGE_HEIGHT; y++) {

					int b = 0xff&mapdata[xbyte+y*bytesPerLine];

					if(b != 0) {

						leftmostPixel = Math.min(leftmostPixel, Integer.numberOfLeadingZeros(b)-24+xbyte*8);

					}

				}

				if(leftmostPixel!=Frontlib.MAPIMAGE_WIDTH) break;

			}

			// Find the rightmost pixel

			for(int xbyte=bytesPerLine-1; xbyte>=0; xbyte--) {

				for(int y=0; y<Frontlib.MAPIMAGE_HEIGHT; y++) {

					int b = mapdata[xbyte+y*bytesPerLine];

					if(b != 0) {

						rightmostPixel = Math.max(rightmostPixel, xbyte*8+7-Integer.numberOfTrailingZeros(b));

					}

				}

				if(rightmostPixel!=-1) break;

			}

			// No pixel was set at all -> use default width

			if(rightmostPixel==-1) {

				leftmostPixel = 0;

				rightmostPixel = Frontlib.MAPIMAGE_WIDTH-1;

			}

			Bitmap bitmap = Bitmap.createBitmap(rightmostPixel-leftmostPixel+1, Frontlib.MAPIMAGE_HEIGHT, Config.ARGB_8888);

			for(int y=0; y<Frontlib.MAPIMAGE_HEIGHT; y++) {

				for(int x=0; x<bitmap.getWidth(); x++) {

					bitmap.setPixel(x, y, isPixelSet(mapdata, x+leftmostPixel, y) ? Color.YELLOW : Color.TRANSPARENT);

				}

			}

			result = new BitmapDrawable(bitmap);

			resultAvailable = true;

		}

	};

	private static boolean isPixelSet(byte[] imgdata, int x, int y) {

		int pixelnum = x+Frontlib.MAPIMAGE_WIDTH*y;

		return (imgdata[pixelnum>>3] & (128>>(pixelnum&7))) != 0;

	}

	private final StrCallback failureCb = new StrCallback() {

		public void callback(Pointer context, String reason) {

			Log.w(TAG, "Error generating map preview: "+reason);

			result = null;

			resultAvailable = true;

		}

	};

}