package org.hedgewars.hedgeroid.netplay;

import static org.hedgewars.hedgeroid.netplay.ThreadedNetConnection.ToNetMsgType.*;

import java.io.IOException;

import java.util.Arrays;

import java.util.Collections;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

import java.util.TreeMap;

import org.hedgewars.hedgeroid.RoomStateManager;

import org.hedgewars.hedgeroid.Datastructures.GameConfig;

import org.hedgewars.hedgeroid.Datastructures.MapRecipe;

import org.hedgewars.hedgeroid.Datastructures.Player;

import org.hedgewars.hedgeroid.Datastructures.PlayerInRoom;

import org.hedgewars.hedgeroid.Datastructures.Room;

import org.hedgewars.hedgeroid.Datastructures.Scheme;

import org.hedgewars.hedgeroid.Datastructures.Schemes;

import org.hedgewars.hedgeroid.Datastructures.Team;

import org.hedgewars.hedgeroid.Datastructures.TeamInGame;

import org.hedgewars.hedgeroid.Datastructures.TeamIngameAttributes;

import org.hedgewars.hedgeroid.Datastructures.Weaponset;

import org.hedgewars.hedgeroid.Datastructures.Weaponsets;

import org.hedgewars.hedgeroid.frontlib.Flib;

import org.hedgewars.hedgeroid.netplay.ThreadedNetConnection.ToNetMsgType;

import org.hedgewars.hedgeroid.util.ObservableTreeMap;

import android.annotation.SuppressLint;

import android.content.Context;

import android.content.Intent;

import android.os.Handler;

import android.os.Looper;

import android.os.Message;

import android.support.v4.content.LocalBroadcastManager;

import android.util.Log;

import android.util.Pair;

/**

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

	public static final String EXTRA_REASON = "reason";

	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 ACTION_ENTERED_ROOM_FROM_LOBBY = ACTIONPREFIX+"ENTERED_ROOM";

	public static final String ACTION_LEFT_ROOM = ACTIONPREFIX+"LEFT_ROOM";

	public static final String ACTION_STATE_CHANGED = ACTIONPREFIX+"STATE_CHANGED";

	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 = State.NOT_CONNECTED;

	private String playerName;

	// null or stale if not in room state

	private final NetRoomState netRoomState = new NetRoomState(this);

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

	private ThreadedNetConnection connection;

	public final ObservableTreeMap<String, Player> lobbyPlayerlist = new ObservableTreeMap<String, Player>();

	public final ObservableTreeMap<String, PlayerInRoom> roomPlayerlist = new ObservableTreeMap<String, PlayerInRoom>();

	public final Roomlist roomList = new Roomlist();

	public final MessageLog lobbyChatlog;

	public final MessageLog roomChatlog;

	public final ObservableTreeMap<String, TeamInGame> roomTeamlist = new ObservableTreeMap<String, TeamInGame>();

	private final List<GameMessageListener> gameMessageListeners = new LinkedList<GameMessageListener>();

	private final List<RunGameListener> runGameListeners = new LinkedList<RunGameListener>();

	public Netplay(Context appContext) {

		this.appContext = appContext;

		broadcastManager = LocalBroadcastManager.getInstance(appContext);

		lobbyChatlog = new MessageLog(appContext);

		roomChatlog = new MessageLog(appContext);

	}

	public RoomStateManager getRoomStateManager() {

		return netRoomState;

	}

	private void clearLobbyState() {

		lobbyPlayerlist.clear();

		roomList.clear();

		lobbyChatlog.clear();

	}

	private void initRoomState(boolean chief) {

		roomChatlog.clear();

		roomPlayerlist.clear();

		roomTeamlist.clear();

		roomRequestedTeams.clear();

		try {

			netRoomState.setChief(chief);

			netRoomState.setGameStyle(GameConfig.DEFAULT_STYLE);

			List<Scheme> schemes = Schemes.loadBuiltinSchemes(appContext);

			netRoomState.setScheme(schemes.get(Schemes.toNameList(schemes).indexOf(GameConfig.DEFAULT_SCHEME)));

			netRoomState.setMapRecipe(MapRecipe.makeRandomMap(0, MapRecipe.makeRandomSeed(), GameConfig.DEFAULT_THEME));

			List<Weaponset> weaponsets = Weaponsets.loadBuiltinWeaponsets(appContext);

			netRoomState.setWeaponset(weaponsets.get(Weaponsets.toNameList(weaponsets).indexOf(GameConfig.DEFAULT_WEAPONSET)));

			netRoomState.sendFullConfig();

		} catch(IOException e) {

			throw new RuntimeException(e);

		}

	}

	public void registerGameMessageListener(GameMessageListener listener) {

		gameMessageListeners.add(listener);

	}

	public void unregisterGameMessageListener(GameMessageListener listener) {

		gameMessageListeners.remove(listener);

	}

	public void registerRunGameListener(RunGameListener listener) {

		runGameListeners.add(listener);

	}

	public void unregisterRunGameListener(RunGameListener listener) {

		runGameListeners.remove(listener);

	}

	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) {

		playerName = name;

		if(state != State.NOT_CONNECTED) {

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

		}

		clearLobbyState();

		changeState(State.CONNECTING);

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

		connection.setFastTickRate(true);

	}

	public void sendNick(String nick) {

		playerName = nick;

		sendToNet(MSG_SEND_NICK, nick);

	}

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

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

	public void sendRoomlistRequest() { sendToNet(MSG_SEND_ROOMLIST_REQUEST); }

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

	public void sendChat(String s) { sendToNet(MSG_SEND_CHAT, s); }

	public void sendTeamChat(String s) { sendToNet(MSG_SEND_TEAMCHAT, s); }

	public void sendFollowPlayer(String nick) { sendToNet(MSG_SEND_FOLLOW_PLAYER, nick); }

	public void sendJoinRoom(String name) { sendToNet(MSG_SEND_JOIN_ROOM, name); }

	public void sendCreateRoom(String name) { sendToNet(MSG_SEND_CREATE_ROOM, name); }

	public void sendLeaveRoom(String message) { sendToNet(MSG_SEND_LEAVE_ROOM, message); }

	public void sendKick(String player) { sendToNet(MSG_SEND_KICK, player); }

	}

	public void sendRemoveTeam(String teamName) { sendToNet(MSG_SEND_REMOVE_TEAM, teamName); }

	public void sendEngineMessage(byte[] engineMessage) { sendToNet(MSG_SEND_ENGINE_MESSAGE, engineMessage); }

	public void sendRoundFinished(boolean withoutError) { sendToNet(MSG_SEND_ROUND_FINISHED, Boolean.valueOf(withoutError)); }

	public void sendToggleReady() { sendToNet(MSG_SEND_TOGGLE_READY); }

	public void disconnect() { sendToNet(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;

	}

	private void changeState(State newState) {

		if(newState != state) {

			state = newState;

			broadcastManager.sendBroadcastSync(new Intent(ACTION_STATE_CHANGED));

		}

	}

	public boolean isChief() {

		if(netRoomState != null) {

			return netRoomState.chief;

		} else {

			return false;

		}

	}

	public String getPlayerName() {

		return playerName;

	}

	boolean sendToNet(ToNetMsgType what) {

		return sendToNet(what, 0, null);

	}

	boolean sendToNet(ToNetMsgType what, Object obj) {

		return sendToNet(what, 0, obj);

	}

	boolean sendToNet(ToNetMsgType what, int arg1, Object obj) {

		if(connection != null) {

			Handler handler = connection.toNetHandler;

			return handler.sendMessage(handler.obtainMessage(what.ordinal(), arg1, 0, obj));

		} else {

			return false;

		}

	}

	private MessageLog getCurrentLog() {

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

			return roomChatlog;

		} else {

			return lobbyChatlog;

		}

	}

	public static enum FromNetMsgType {

		MSG_LOBBY_JOIN,

		MSG_LOBBY_LEAVE,

		MSG_ROOM_JOIN,

		MSG_ROOM_LEAVE,

		MSG_CHAT,

		MSG_MESSAGE,

		MSG_ROOM_ADD,

		MSG_ROOM_UPDATE,

		MSG_ROOM_DELETE,

		MSG_ROOMLIST,

		MSG_CONNECTED,

		MSG_DISCONNECTED,

		MSG_PASSWORD_REQUEST,

		MSG_ENTER_ROOM_FROM_LOBBY,

		MSG_LEAVE_ROOM,

		MSG_READYSTATE,

		MSG_TEAM_ADDED,

		MSG_TEAM_DELETED,

		MSG_TEAM_ACCEPTED,

		MSG_TEAM_COLOR_CHANGED,

		MSG_HOG_COUNT_CHANGED,

		MSG_ENGINE_MESSAGE,

		MSG_RUN_GAME,

		MSG_SCHEME_CHANGED,

		MSG_MAP_CHANGED,

		MSG_ROOM_CHIEF_STATUS_CHANGED,

		MSG_SCRIPT_CHANGED,

		MSG_WEAPONSET_CHANGED;

		static final List<FromNetMsgType> values = Collections.unmodifiableList(Arrays.asList(FromNetMsgType.values()));

	}

	/**

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

	 */

	@SuppressLint("HandlerLeak")

	final class FromNetHandler extends Handler {

		public FromNetHandler() {

			super(Looper.getMainLooper());

		}

		@SuppressWarnings("unchecked")

		@Override

		public void handleMessage(Message msg) {

			switch(FromNetMsgType.values.get(msg.what)) {

			case MSG_LOBBY_JOIN: {

				String name = (String)msg.obj;

				lobbyPlayerlist.put(name, new Player(name, false, false));

				lobbyChatlog.appendPlayerJoin(name);

				break;

			}

			case MSG_LOBBY_LEAVE: {

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

				lobbyPlayerlist.remove(args.first);

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

				break;

			}

			case MSG_ROOM_JOIN: {

				String name = (String)msg.obj;

				Player p = lobbyPlayerlist.get(name);

				if(p==null) {

					Log.w("Netplay", "Unknown player joined room: "+name);

					p = new Player(name, false, false);

				}

				roomPlayerlist.put(name, new PlayerInRoom(p, false));

				roomChatlog.appendPlayerJoin(name);

				break;

			}

			case MSG_ROOM_LEAVE: {

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

				roomPlayerlist.remove(args.first);

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

				break;

			}

			case MSG_CHAT: {

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

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

				for(GameMessageListener listener : gameMessageListeners) {

					listener.onChatMessage(args.first, args.second);

				}

				break;

			}

			case MSG_MESSAGE: {

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

				for(GameMessageListener listener : gameMessageListeners) {

					listener.onMessage(1, (String)msg.obj);

				}

				break;

			}

			case MSG_ROOM_ADD: {

				Room room = (Room)msg.obj;

				roomList.addRoomWithNewId(room);

				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.remove((String)msg.obj);

				break;

			}

			case MSG_ROOMLIST: {

				Room[] rooms = (Room[])msg.obj;

				roomList.updateList(rooms);

				break;

			}

			case MSG_CONNECTED: {

				playerName = (String)msg.obj;

				changeState(State.LOBBY);

				broadcastManager.sendBroadcast(new Intent(ACTION_CONNECTED));

				break;

			}

			case MSG_DISCONNECTED: {

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

				for(GameMessageListener listener : gameMessageListeners) {

					listener.onNetDisconnected();

				}

				changeState(State.NOT_CONNECTED);

				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;

			}

			case MSG_ENTER_ROOM_FROM_LOBBY: {

				initRoomState((Boolean)msg.obj);

				changeState(State.ROOM);

				Intent intent = new Intent(ACTION_ENTERED_ROOM_FROM_LOBBY);

				broadcastManager.sendBroadcastSync(intent);

				break;

			}

			case MSG_LEAVE_ROOM: {

				changeState(State.LOBBY);

				Intent intent = new Intent(ACTION_LEFT_ROOM);

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

				intent.putExtra(EXTRA_REASON, msg.arg1);

				broadcastManager.sendBroadcastSync(intent);

				break;

			}

			case MSG_READYSTATE: {

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

				String name = args.first;

				Boolean newReadyState = args.second;

				PlayerInRoom oldEntry = roomPlayerlist.get(name);

				if(oldEntry==null) {

					Log.e("Netplay", "Setting readystate for unknown player "+name);

				} else {

					roomPlayerlist.put(name, new PlayerInRoom(oldEntry.player, newReadyState));

				}

				break;

			}

			case MSG_TEAM_ADDED: {

				if(isChief()) {

				}

				break;

			}

			case MSG_TEAM_DELETED: {

				roomTeamlist.remove((String)msg.obj);

				break;

			}

			case MSG_TEAM_ACCEPTED: {

				if(requestedTeam!=null) {

					if(isChief()) {

					}

				} else {

					Log.e("Netplay", "Got accepted message for team that was never requested.");

				}

				break;

			}

			case MSG_TEAM_COLOR_CHANGED: {

				TeamInGame oldEntry = roomTeamlist.get((String)msg.obj);

				if(oldEntry != null) {

				} else {

					Log.e("Netplay", "Color update for unknown team "+msg.obj);

				}

				break;

			}

			case MSG_HOG_COUNT_CHANGED: {

				TeamInGame oldEntry = roomTeamlist.get((String)msg.obj);

				if(oldEntry != null) {

					TeamIngameAttributes newAttribs = oldEntry.ingameAttribs.withHogCount(msg.arg1);

					roomTeamlist.put(oldEntry.team.name, oldEntry.withAttribs(newAttribs));

				} else {

					Log.e("Netplay", "Hog count update for unknown team "+msg.obj);

				}

				break;

			}

			case MSG_ENGINE_MESSAGE: {

				byte[] em = (byte[])msg.obj;

				for(GameMessageListener listener : gameMessageListeners) {

					listener.onEngineMessage(em);

				}

				break;

			}

			case MSG_RUN_GAME: {

				GameConfig config = (GameConfig)msg.obj;