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 com.sun.jna.Pointer;

import android.support.v4.content.LocalBroadcastManager;

	// Parameter extras for starting the service

	public static final String EXTRA_PLAYERNAME = "playername";

	public static final String EXTRA_PORT = "port";

	public static final String EXTRA_HOST = "host";

	// Extras in broadcasts

	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";

	private static final JnaFrontlib FLIB = Flib.INSTANCE;

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

	public static final int DEFAULT_PORT = 46631;

	private static final long TICK_INTERVAL_MS_BOUND = 100;

	private static final long TICK_INTERVAL_MS_UNBOUND = 2000;

	// null if the service is not active. Only updated from the main thread.

	public static NetplayService instance;

	private TickHandler tickHandler;

	private LocalBroadcastManager broadcastManager;

	private String playerName;

	private NetconnPtr conn;

	private boolean joined; // True once we have been admitted to the lobby

	public final PlayerList playerList = new PlayerList();

	public final RoomList roomList = new RoomList();

	public MessageLog lobbyChatlog;

	public MessageLog roomChatlog;

		Log.d("NetplayService", "onBind");

		tickHandler.setInterval(TICK_INTERVAL_MS_BOUND);

	public void onRebind(Intent intent) {

		Log.d("NetplayService", "onRebind");

		tickHandler.setInterval(TICK_INTERVAL_MS_BOUND);

	}

	@Override

	public boolean onUnbind(Intent intent) {

		Log.d("NetplayService", "onUnbind");

		tickHandler.setInterval(TICK_INTERVAL_MS_UNBOUND);

		return true;

	}

	@Override

	public int onStartCommand(Intent intent, int flags, int startId) {

		Log.d("NetplayService", "onStartCommand");

		if(conn != null) {

			Log.e("NetplayService", "Attempt to start while running");

			return START_NOT_STICKY;

		}

		joined = false;

		playerList.clear();

		roomList.clear();

		lobbyChatlog.clear();

		roomChatlog.clear();

		playerName = intent.getStringExtra(EXTRA_PLAYERNAME);

		if(playerName == null) playerName = "Player";

		int port = intent.getIntExtra(EXTRA_PORT, DEFAULT_PORT);

		String host = intent.getStringExtra(EXTRA_HOST);

		if(host==null) host = DEFAULT_SERVER;

		MetaschemePtr meta = null;

		File dataPath;

		try {

			dataPath = Utils.getDataPathFile(getApplicationContext());

		} catch (FileNotFoundException e) {

			stopWithError(getString(R.string.sdcard_not_mounted));

			return START_NOT_STICKY;

		}

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

		meta = FLIB.flib_metascheme_from_ini(metaschemePath);

		if(meta == null) {

			stopWithError(getString(R.string.error_unexpected, "Missing metasettings.ini"));

			return START_NOT_STICKY;

		}

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

		if(conn == null) {

			stopWithError(getString(R.string.error_connection_failed));

			return START_NOT_STICKY;

		}

		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_metascheme_release(meta);

		tickHandler.start();

		instance = this;

		return START_NOT_STICKY;

	}

	private void stopWithoutError() {

		Intent intent = new Intent(ACTION_DISCONNECTED);

		intent.putExtra(EXTRA_HAS_ERROR, false);

		broadcastManager.sendBroadcast(intent);

		stopSelf();

	}

	private void stopWithError(String userMessage) {

		Intent intent = new Intent(ACTION_DISCONNECTED);

		intent.putExtra(EXTRA_MESSAGE, userMessage);

		intent.putExtra(EXTRA_HAS_ERROR, true);

		broadcastManager.sendBroadcast(intent);

		stopSelf();

	}

	@Override

		Log.d("NetplayService", "onCreate");

		broadcastManager = LocalBroadcastManager.getInstance(getApplicationContext());

		lobbyChatlog = new MessageLog(getApplicationContext());

		roomChatlog = new MessageLog(getApplicationContext());

		tickHandler = new TickHandler(getMainLooper(), TICK_INTERVAL_MS_UNBOUND, new Runnable() {

			public void run() {

				if(conn != null) {

					FLIB.flib_netconn_tick(conn);

		});

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

			stopWithError(getString(R.string.error_unexpected, "Unable to start frontlib"));

		}

		instance = null;

		Log.d("NetplayService", "onDestroy");

		tickHandler.stop();

		if(conn != null) {

			FLIB.flib_netconn_destroy(conn);

			conn = null;

		}

		NetplayService getService() {

            return NetplayService.this;

	private StrCallback lobbyJoinCb = new StrCallback() {

		public void callback(Pointer context, String arg1) {

			playerList.addPlayerWithNewId(arg1);

			lobbyChatlog.appendPlayerJoin(arg1);

		}

	};

	private StrStrCallback lobbyLeaveCb = new StrStrCallback() {

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

			playerList.removePlayer(name);

			lobbyChatlog.appendPlayerLeave(name, msg);

		}

	};

	private StrStrCallback chatCb = new StrStrCallback() {

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

			getCurrentLog().appendChat(name, msg);

		}

	};

	private IntStrCallback messageCb = new IntStrCallback() {

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

			getCurrentLog().appendMessage(type, msg);

		}

	};

	private RoomCallback roomAddCb = new RoomCallback() {

		public void callback(Pointer context, RoomPtr roomPtr) {

			roomList.addRoomWithNewId(roomPtr);

		}

	};

	private StrRoomCallback roomUpdateCb = new StrRoomCallback() {

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

			roomList.updateRoom(name, roomPtr);

		}

	};

	private StrCallback roomDeleteCb = new StrCallback() {

		public void callback(Pointer context, String name) {

			roomList.removeRoom(name);

		}

	};

	private VoidCallback connectedCb = new VoidCallback() {

		public void callback(Pointer context) {

			broadcastManager.sendBroadcast(new Intent(ACTION_CONNECTED));

			joined = true;

			FLIB.flib_netconn_send_request_roomlist(conn);

		}

	};

	private RoomListCallback roomlistCb = new RoomListCallback() {

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

			roomList.updateList(arg1.getRooms(count));

		}

	};

	private IntStrCallback disconnectCb = new IntStrCallback() {

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

			switch(reason) {

			case JnaFrontlib.NETCONN_DISCONNECT_AUTH_FAILED:

				stopWithError(getString(R.string.error_auth_failed));

				break;

			case JnaFrontlib.NETCONN_DISCONNECT_CONNLOST:

				stopWithError(getString(R.string.error_connection_lost));

				break;

			case JnaFrontlib.NETCONN_DISCONNECT_INTERNAL_ERROR:

				stopWithError(getString(R.string.error_unexpected, arg2));

				break;

			case JnaFrontlib.NETCONN_DISCONNECT_NORMAL:

				stopWithoutError();

				break;

			case JnaFrontlib.NETCONN_DISCONNECT_SERVER_TOO_OLD:

				stopWithError(getString(R.string.error_server_too_old));

				break;

			default:

				stopWithError(arg2);

				break;

			}

			FLIB.flib_netconn_destroy(conn);

			conn = null;

		}

	};

	public void disconnect() {

		if(conn != null) {

			FLIB.flib_netconn_send_quit(conn, "User quit");

			FLIB.flib_netconn_destroy(conn);

			conn = null;

		}

		stopWithoutError();

	}

	public void sendChat(String s) {

		FLIB.flib_netconn_send_chat(conn, s);

		if(FLIB.flib_netconn_is_in_room_context(conn)) {

			roomChatlog.appendChat(playerName, s);

		} else {

			lobbyChatlog.appendChat(playerName, s);

		}

	}

	private MessageLog getCurrentLog() {

		if(FLIB.flib_netconn_is_in_room_context(conn)) {

			return roomChatlog;

		} else {

			return lobbyChatlog;

		}

	}

	public void sendNick(String nick) { FLIB.flib_netconn_send_nick(conn, nick); }

	public void sendPassword(String password) { FLIB.flib_netconn_send_password(conn, password); }

	public void sendQuit(String message) { FLIB.flib_netconn_send_quit(conn, message); }

	public void sendRoomlistRequest() { if(joined) FLIB.flib_netconn_send_request_roomlist(conn); }

	public void sendPlayerInfoQuery(String name) { FLIB.flib_netconn_send_playerInfo(conn, name); }

	public boolean isConnected() {

		return conn != null;

	}

	public static boolean isActive() {

		return instance!=null;