package org.hedgewars.hedgeroid;

import org.hedgewars.hedgeroid.Datastructures.GameConfig;
import org.hedgewars.hedgeroid.frontlib.Flib;
import org.hedgewars.hedgeroid.frontlib.Frontlib;
import org.hedgewars.hedgeroid.frontlib.Frontlib.BytesCallback;
import org.hedgewars.hedgeroid.frontlib.Frontlib.GameSetupPtr;
import org.hedgewars.hedgeroid.frontlib.Frontlib.GameconnPtr;
import org.hedgewars.hedgeroid.frontlib.Frontlib.IntCallback;
import org.hedgewars.hedgeroid.frontlib.Frontlib.StrBoolCallback;
import org.hedgewars.hedgeroid.frontlib.Frontlib.StrCallback;
import org.hedgewars.hedgeroid.frontlib.Frontlib.VoidCallback;
import org.hedgewars.hedgeroid.netplay.GameMessageListener;
import org.hedgewars.hedgeroid.netplay.Netplay;
import org.hedgewars.hedgeroid.util.TickHandler;

import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.util.Log;

import com.sun.jna.Memory;
import com.sun.jna.NativeLong;
import com.sun.jna.Pointer;

public final class GameConnection {
	private static final Handler mainHandler = new Handler(Looper.getMainLooper());
	
	private final HandlerThread thread;
	private final Handler handler;
	private final TickHandler tickHandler;
	private final Netplay netplay; // ==null if not a netgame
	private GameconnPtr conn;

	/**
	 * The actual connection has to be set up on a separate thread because networking
	 * is not allowed on the UI thread, so the port can't be queried immediately after
	 * creating the GameConnection object. Instead, one of these interface methods is
	 * called once we know which port we are listening on (or once we fail to set this up).
	 * Methods will be called on the UI thread.
	 */
	public static interface Listener {
		/**
		 * We are listening for the engine at $port, go start the engine.
		 */
		void gameConnectionReady(int port);
		
		/**
		 * The connection has stopped, either because the game has ended or was interrupted,
		 * or maybe we failed to create the connection at all (in that case gameConnectionReady wasn't called).
		 */
		void gameConnectionDisconnected(int reason);
	}
	
	private GameConnection(Netplay netplay) {
		this.netplay = netplay;
		thread = new HandlerThread("IPCThread");
		thread.start();
		handler = new Handler(thread.getLooper());
		tickHandler = new TickHandler(thread.getLooper(), 50, new Runnable() {
			public void run() {
				if(conn != null) {
					Flib.INSTANCE.flib_gameconn_tick(conn);
				}
			}
		});
		tickHandler.start();
	}
	
	public static GameConnection forNetgame(final GameConfig config, Netplay netplay, final Listener listener) {
		final GameConnection result = new GameConnection(netplay);
		final String playerName = netplay.getPlayerName();
		result.handler.post(new Runnable() {
			public void run() {
				GameconnPtr conn = Flib.INSTANCE.flib_gameconn_create(playerName, GameSetupPtr.createJavaOwned(config), true);
				result.setupConnection(conn, true, listener);
			}
		});
		return result;
	}
	
	public static GameConnection forLocalGame(final GameConfig config, final Listener listener) {
		final GameConnection result = new GameConnection(null);
		result.handler.post(new Runnable() {
			public void run() {
				GameconnPtr conn = Flib.INSTANCE.flib_gameconn_create("Player", GameSetupPtr.createJavaOwned(config), false);
				result.setupConnection(conn, false, listener);
			}
		});
		return result;
	}
	
	// runs on the IPCThread
	private void setupConnection(GameconnPtr conn, final boolean netgame, final Listener listener) {
		if(conn == null) {
			mainHandler.post(new Runnable() {
				public void run() { listener.gameConnectionDisconnected(Frontlib.GAME_END_ERROR); }
			});
			shutdown();
		} else {
			this.conn = conn;
			final int port = Flib.INSTANCE.flib_gameconn_getport(conn);
			mainHandler.post(new Runnable() {
				public void run() { 
					listener.gameConnectionReady(port);
					if(netgame) {
						netplay.registerGameMessageListener(gameMessageListener);
					}
				}
			});
			Flib.INSTANCE.flib_gameconn_onConnect(conn, connectCb, null);
			Flib.INSTANCE.flib_gameconn_onDisconnect(conn, disconnectCb, null);
			Flib.INSTANCE.flib_gameconn_onErrorMessage(conn, errorMessageCb, null);
			if(netgame) {
				Flib.INSTANCE.flib_gameconn_onChat(conn, chatCb, null);
				Flib.INSTANCE.flib_gameconn_onEngineMessage(conn, engineMessageCb, null);
			}
		}
	}
	
	// runs on the IPCThread
	private void shutdown() {
		tickHandler.stop();
		thread.quit();
		Flib.INSTANCE.flib_gameconn_destroy(conn);
		if(netplay != null) {
			mainHandler.post(new Runnable() {
				public void run() {
					netplay.unregisterGameMessageListener(gameMessageListener);
				}
			});
		}
	}
	
	// runs on the IPCThread
	private final StrBoolCallback chatCb = new StrBoolCallback() {
		public void callback(Pointer context, String message, boolean teamChat) {
			if(teamChat) {
				netplay.sendTeamChat(message);
			} else {
				netplay.sendChat(message);
			}
		}
	};
	
	// runs on the IPCThread
	private final VoidCallback connectCb = new VoidCallback() {
		public void callback(Pointer context) {
			Log.i("GameConnection", "Connected");
		}
	};
	
	// runs on the IPCThread
	private final IntCallback disconnectCb = new IntCallback() {
		public void callback(Pointer context, int reason) {
			if(netplay != null) {
				netplay.sendRoundFinished(reason==Frontlib.GAME_END_FINISHED);
			}
			shutdown();
		}
	};
	
	// runs on the IPCThread
	private final BytesCallback engineMessageCb = new BytesCallback() {
		public void callback(Pointer context, Pointer buffer, NativeLong size) {
			netplay.sendEngineMessage(buffer.getByteArray(0, size.intValue()));
		}
	};
	
	// runs on the IPCThread
	private final StrCallback errorMessageCb = new StrCallback() {
		public void callback(Pointer context, String message) {
			Log.e("GameConnection", message);
		}
	};
	
	// runs on any thread
	private final GameMessageListener gameMessageListener = new GameMessageListener() {
		public void onNetDisconnected() {
			handler.post(new Runnable() {
				public void run() {
					shutdown();
				}
			});
		}
		
		public void onMessage(final int type, final String message) {
			handler.post(new Runnable() {
				public void run() {
					Flib.INSTANCE.flib_gameconn_send_textmsg(conn, type, message);
				}
			});
		}
		
		public void onEngineMessage(final byte[] em) {
			handler.post(new Runnable() {
				public void run() {
					Memory mem = new Memory(em.length);
					mem.write(0, em, 0, em.length);
					Flib.INSTANCE.flib_gameconn_send_enginemsg(conn, mem, new NativeLong(em.length));
				}
			});
			
		}
		
		public void onChatMessage(final String nick, final String message) {
			handler.post(new Runnable() {
				public void run() {
					Flib.INSTANCE.flib_gameconn_send_chatmsg(conn, nick, message);
				}
			});
		}
	};
}