package org.hedgewars.hedgeroid.netplay;

import java.io.File;

import java.io.FileNotFoundException;

import org.hedgewars.hedgeroid.R;

import org.hedgewars.hedgeroid.Utils;

import org.hedgewars.hedgeroid.netplay.JnaFrontlib.IntStrCallback;

import org.hedgewars.hedgeroid.netplay.JnaFrontlib.MetaschemePtr;

import org.hedgewars.hedgeroid.netplay.JnaFrontlib.NetconnPtr;

import org.hedgewars.hedgeroid.netplay.JnaFrontlib.RoomArrayPtr;

import org.hedgewars.hedgeroid.netplay.JnaFrontlib.RoomCallback;

import org.hedgewars.hedgeroid.netplay.JnaFrontlib.RoomListCallback;

import org.hedgewars.hedgeroid.netplay.JnaFrontlib.RoomPtr;

import org.hedgewars.hedgeroid.netplay.JnaFrontlib.StrCallback;

import org.hedgewars.hedgeroid.netplay.JnaFrontlib.StrRoomCallback;

import org.hedgewars.hedgeroid.netplay.JnaFrontlib.StrStrCallback;

import org.hedgewars.hedgeroid.netplay.JnaFrontlib.VoidCallback;

import android.content.Context;

import android.content.Intent;

import android.content.res.Resources;

import android.os.Handler;

import android.os.HandlerThread;

import android.os.Looper;

import android.os.Message;

import android.support.v4.content.LocalBroadcastManager;

import android.util.Log;

import android.util.Pair;

import com.sun.jna.Pointer;

/**

 * This class manages the application's networking state.

 */

public class Netplay {

	public static enum State { NOT_CONNECTED, CONNECTING, LOBBY, ROOM, INGAME }

	// Extras in broadcasts

	public static final String EXTRA_PLAYERNAME = "playerName";

	public static final String EXTRA_MESSAGE = "message";

	public static final String EXTRA_HAS_ERROR = "hasError";

	private static final String ACTIONPREFIX = "org.hedgewars.hedgeroid.netconn.";

	public static final String ACTION_DISCONNECTED = ACTIONPREFIX+"DISCONNECTED";

	public static final String ACTION_CONNECTED = ACTIONPREFIX+"CONNECTED";

	public static final String ACTION_PASSWORD_REQUESTED = ACTIONPREFIX+"PASSWORD_REQUESTED";

	public static final String DEFAULT_SERVER = "netserver.hedgewars.org";

	public static final int DEFAULT_PORT = 46631;

	private final Context appContext;

	private final LocalBroadcastManager broadcastManager;

	private final FromNetHandler fromNetHandler = new FromNetHandler();

	private State state;

	// null if there is no running connection (==state is NOT_CONNECTED)

	private ThreadedNetConnection connection;

	public final MessageLog lobbyChatlog;

	public final MessageLog roomChatlog;

	public Netplay(Context appContext) {

		this.appContext = appContext;

		broadcastManager = LocalBroadcastManager.getInstance(appContext);

		lobbyChatlog = new MessageLog(appContext);

		roomChatlog = new MessageLog(appContext);

		state = State.NOT_CONNECTED;

	}

	private void clearState() {

		playerList.clear();

		roomList.clear();

		lobbyChatlog.clear();

		roomChatlog.clear();

	}

	public void connectToDefaultServer(String playerName) {

		connect(playerName, DEFAULT_SERVER, DEFAULT_PORT);

	}

	/**

	 * Establish a new connection. Only call if the current state is NOT_CONNECTED.

	 * 

	 * The state will switch to CONNECTING immediately. After that, it can asynchronously change to any other state.

	 * State changes are indicated by broadcasts. In particular, if an error occurs while trying to connect, the state

	 * will change back to NOT_CONNECTED and an ACTION_DISCONNECTED broadcast is sent.

	 */

	public void connect(String name, String host, int port) {

		if(state != State.NOT_CONNECTED) {

			throw new IllegalStateException("Attempt to start a new connection while the old one was still running.");

		}

		clearState();

		connection = ThreadedNetConnection.startConnection(appContext, fromNetHandler, name, host, port);

		connection.setFastTickRate(foregroundUsers > 0);

	}

	public void sendNick(String nick) { sendToNet(ThreadedNetConnection.ToNetHandler.MSG_SEND_NICK, nick); }

	public void sendPassword(String password) { sendToNet(ThreadedNetConnection.ToNetHandler.MSG_SEND_PASSWORD, password); }

	public void sendQuit(String message) { sendToNet(ThreadedNetConnection.ToNetHandler.MSG_SEND_QUIT, message); }

	public void sendRoomlistRequest() { sendToNet(ThreadedNetConnection.ToNetHandler.MSG_SEND_ROOMLIST_REQUEST); }

	public void sendPlayerInfoQuery(String name) { sendToNet(ThreadedNetConnection.ToNetHandler.MSG_SEND_PLAYER_INFO_REQUEST, name); }

	public void disconnect() { sendToNet(ThreadedNetConnection.ToNetHandler.MSG_DISCONNECT, "User Quit"); }

	private static Netplay instance;

	/**

	 * Retrieve the single app-wide instance of the netplay interface, creating it if it

	 * does not exist yet.

	 * 

	 * @param applicationContext

	 * @return

	 */

	public static Netplay getAppInstance(Context applicationContext) {

		if(instance == null) {

			// We'll just do it here and never quit it again...

			if(Flib.INSTANCE.flib_init() != 0) {

				throw new RuntimeException("Unable to start frontlib");

			}

			instance = new Netplay(applicationContext);

		}

		return instance;

	}

	public State getState() {

		return state;

	}

	/**

	 * Indicate that you want network messages to be checked regularly (several times per second).

	 * As long as nobody requests fast ticks, the network is only checked once every few seconds

	 * to conserve battery power.

	 * Once you no longer need fast updates, call unrequestFastTicks.

	 */

	public void requestFastTicks() {

		if(foregroundUsers == Integer.MAX_VALUE) {

			throw new RuntimeException("Reference counter overflow");

		}

		if(foregroundUsers == 0 && connection != null) {

			connection.setFastTickRate(true);

		}

		foregroundUsers++;

	}

	public void unrequestFastTicks() {

		if(foregroundUsers == 0) {

			throw new RuntimeException("Reference counter underflow");

		}

		foregroundUsers--;

		if(foregroundUsers == 0 && connection != null) {

			connection.setFastTickRate(false);

		}

	}

	private boolean sendToNet(int what) {

		if(connection != null) {

			Handler handler = connection.toNetHandler;

			return handler.sendMessage(handler.obtainMessage(what));

		} else {

			return false;

		}

	}

	private boolean sendToNet(int what, Object obj) {

		if(connection != null) {

			Handler handler = connection.toNetHandler;

			return handler.sendMessage(handler.obtainMessage(what, obj));

		} else {

			return false;

		}

	}

	private MessageLog getCurrentLog() {

		if(state == State.ROOM || state == State.INGAME) {

			return roomChatlog;

		} else {

			return lobbyChatlog;

		}

	}

	/**

	 * Processes messages from the networking system. Always runs on the main thread.

	 */

	final class FromNetHandler extends Handler {

		public static final int MSG_LOBBY_JOIN = 0;

		public static final int MSG_LOBBY_LEAVE = 1;

		public FromNetHandler() {

			super(Looper.getMainLooper());

		}

		@SuppressWarnings("unchecked")

		@Override

		public void handleMessage(Message msg) {

			switch(msg.what) {

			case MSG_LOBBY_JOIN: {

				String name = (String)msg.obj;

				playerList.addPlayerWithNewId(name);

				lobbyChatlog.appendPlayerJoin(name);

				break;

			}

			case MSG_LOBBY_LEAVE: {

				Pair<String, String> args = (Pair<String, String>)msg.obj;

				playerList.removePlayer(args.first);

				lobbyChatlog.appendPlayerLeave(args.first, args.second);

				break;

			}

			case MSG_CHAT: {

				Pair<String, String> args = (Pair<String, String>)msg.obj;

				getCurrentLog().appendChat(args.first, args.second);

				break;

			}

			case MSG_MESSAGE: {

				getCurrentLog().appendMessage(msg.arg1, (String)msg.obj);

				break;

			}

			case MSG_ROOM_ADD: {

				roomList.addRoomWithNewId((Room)msg.obj);

				break;

			}

			case MSG_ROOM_UPDATE: {

				Pair<String, Room> args = (Pair<String, Room>)msg.obj;

				roomList.updateRoom(args.first, args.second);

				break;

			}

			case MSG_ROOM_DELETE: {

				roomList.removeRoom((String)msg.obj);

				break;

			}

			case MSG_ROOMLIST: {

				roomList.updateList((Room[])msg.obj);

				break;

			}

			case MSG_CONNECTED: {

				broadcastManager.sendBroadcast(new Intent(ACTION_CONNECTED));

				break;

			}

			case MSG_DISCONNECTED: {

				Pair<Boolean, String> args = (Pair<Boolean, String>)msg.obj;

				connection = null;

				Intent intent = new Intent(ACTION_DISCONNECTED);

				intent.putExtra(EXTRA_HAS_ERROR, args.first);

				intent.putExtra(EXTRA_MESSAGE, args.second);

				broadcastManager.sendBroadcastSync(intent);

				break;

			}

			case MSG_PASSWORD_REQUEST: {

				Intent intent = new Intent(ACTION_PASSWORD_REQUESTED);

				intent.putExtra(EXTRA_PLAYERNAME, (String)msg.obj);

				broadcastManager.sendBroadcast(intent);

				break;

			}

			default: {

				Log.e("FromNetHandler", "Unknown message type: "+msg.what);

				break;

			}

			}

		}

	}

	/**

	 * This class handles the actual communication with the networking library, on a separate thread.

	 */

	private static class ThreadedNetConnection {

		private static final long TICK_INTERVAL_FAST = 100;

		private static final long TICK_INTERVAL_SLOW = 5000;

		private static final JnaFrontlib FLIB = Flib.INSTANCE;

		public final ToNetHandler toNetHandler;

		private final Context appContext;

		private final FromNetHandler fromNetHandler;

		private final TickHandler tickHandler;

		/**

		 * conn can only be null while connecting (the first thing in the thread), and directly after disconnecting,

		 * in the same message (the looper is shut down on disconnect, so there will be no messages after that).

		 */

		private NetconnPtr conn;

		private String playerName;

		private ThreadedNetConnection(Context appContext, FromNetHandler fromNetHandler) {

			this.appContext = appContext;

			this.fromNetHandler = fromNetHandler;

			HandlerThread thread = new HandlerThread("NetThread");

			thread.start();

			toNetHandler = new ToNetHandler(thread.getLooper());

			tickHandler = new TickHandler(thread.getLooper(), TICK_INTERVAL_FAST, tickCb);

		}

		private void connect(final String name, final String host, final int port) {

			toNetHandler.post(new Runnable() {

				public void run() {

					playerName = name == null ? "Player" : name;

					MetaschemePtr meta = null;

					File dataPath;

					try {

						dataPath = Utils.getDataPathFile(appContext);

					} catch (FileNotFoundException e) {

						shutdown(true, appContext.getString(R.string.sdcard_not_mounted));

						return;

					}

					String metaschemePath = new File(dataPath, "metasettings.ini").getAbsolutePath();

					meta = FLIB.flib_metascheme_from_ini(metaschemePath);

					if(meta == null) {

						shutdown(true, appContext.getString(R.string.error_unexpected, "Missing metasettings.ini"));

						return;

					}

					conn = FLIB.flib_netconn_create(playerName, meta, dataPath.getAbsolutePath(), host, port);

					if(conn == null) {

						shutdown(true, appContext.getString(R.string.error_connection_failed));

						return;

					}

					FLIB.flib_netconn_onLobbyJoin(conn, lobbyJoinCb, null);

					FLIB.flib_netconn_onLobbyLeave(conn, lobbyLeaveCb, null);

					FLIB.flib_netconn_onChat(conn, chatCb, null);

					FLIB.flib_netconn_onMessage(conn, messageCb, null);

					FLIB.flib_netconn_onRoomAdd(conn, roomAddCb, null);

					FLIB.flib_netconn_onRoomUpdate(conn, roomUpdateCb, null);

					FLIB.flib_netconn_onRoomDelete(conn, roomDeleteCb, null);

					FLIB.flib_netconn_onConnected(conn, connectedCb, null);

					FLIB.flib_netconn_onRoomlist(conn, roomlistCb, null);

					FLIB.flib_netconn_onDisconnected(conn, disconnectCb, null);

					FLIB.flib_netconn_onPasswordRequest(conn, passwordRequestCb, null);

					FLIB.flib_metascheme_release(meta);

					tickHandler.start();

				}

			});

		}

		public static ThreadedNetConnection startConnection(Context appContext, FromNetHandler fromNetHandler, String playerName, String host, int port) {

			ThreadedNetConnection result = new ThreadedNetConnection(appContext, fromNetHandler);

			result.connect(playerName, host, port);

			return result;

		}

		public void setFastTickRate(boolean fastTickRate) {

			tickHandler.setInterval(fastTickRate ? TICK_INTERVAL_FAST : TICK_INTERVAL_SLOW);

		}

		private final Runnable tickCb = new Runnable() {

			public void run() {

				FLIB.flib_netconn_tick(conn);

			}

		};

		private final StrCallback lobbyJoinCb = new StrCallback() {

			public void callback(Pointer context, String name) {

				sendFromNet(FromNetHandler.MSG_LOBBY_JOIN, name);

			}

		};

		private final StrStrCallback lobbyLeaveCb = new StrStrCallback() {

			public void callback(Pointer context, String name, String msg) {

				sendFromNet(FromNetHandler.MSG_LOBBY_LEAVE, Pair.create(name, msg));

			}

		};

		private final StrStrCallback chatCb = new StrStrCallback() {

			public void callback(Pointer context, String name, String msg) {

				sendFromNet(FromNetHandler.MSG_CHAT, Pair.create(name, msg));

			}

		};

		private final IntStrCallback messageCb = new IntStrCallback() {

			public void callback(Pointer context, int type, String msg) {

				sendFromNet(FromNetHandler.MSG_MESSAGE, type, msg);

			}

		};

		private final RoomCallback roomAddCb = new RoomCallback() {

			public void callback(Pointer context, RoomPtr roomPtr) {

				sendFromNet(FromNetHandler.MSG_ROOM_ADD, roomPtr.deref());

			}

		};

		private final StrRoomCallback roomUpdateCb = new StrRoomCallback() {

			public void callback(Pointer context, String name, RoomPtr roomPtr) {

				sendFromNet(FromNetHandler.MSG_ROOM_UPDATE, Pair.create(name, roomPtr.deref()));

			}

		};

		private final StrCallback roomDeleteCb = new StrCallback() {

			public void callback(Pointer context, final String name) {

				sendFromNet(FromNetHandler.MSG_ROOM_DELETE, name);

			}

		};

		private final RoomListCallback roomlistCb = new RoomListCallback() {

			public void callback(Pointer context, RoomArrayPtr arg1, int count) {

				sendFromNet(FromNetHandler.MSG_ROOMLIST, arg1.getRooms(count));

			}

		};

		private final VoidCallback connectedCb = new VoidCallback() {

			public void callback(Pointer context) {

				FLIB.flib_netconn_send_request_roomlist(conn);

				playerName = FLIB.flib_netconn_get_playername(conn);

				sendFromNet(FromNetHandler.MSG_CONNECTED, playerName);

			}

		};

		private final StrCallback passwordRequestCb = new StrCallback() {

			public void callback(Pointer context, String nickname) {

				sendFromNet(FromNetHandler.MSG_PASSWORD_REQUEST, playerName);

			}

		};

		private void shutdown(boolean error, String message) {

			if(conn != null) {

				FLIB.flib_netconn_destroy(conn);

				conn = null;

			}

			tickHandler.stop();

			toNetHandler.getLooper().quit();

			sendFromNet(FromNetHandler.MSG_DISCONNECTED, Pair.create(error, message));

		}

		private final IntStrCallback disconnectCb = new IntStrCallback() {

			public void callback(Pointer context, int reason, String message) {