package org.hedgewars.hedgeroid.netplay;

import java.util.Map;

import java.util.TreeMap;

import org.hedgewars.hedgeroid.Datastructures.Team;

import org.hedgewars.hedgeroid.Datastructures.TeamInGame;

import org.hedgewars.hedgeroid.Datastructures.TeamIngameAttributes;

import org.hedgewars.hedgeroid.frontlib.Flib;

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 if there is no running connection (==state is NOT_CONNECTED)

	private ThreadedNetConnection connection;

	public final Roomlist roomList = new Roomlist();

	public final MessageLog lobbyChatlog;

	public final MessageLog roomChatlog;

	private final Map<String, Team> roomRequestedTeams = new TreeMap<String, Team>();

	public Netplay(Context appContext) {

		this.appContext = appContext;

		broadcastManager = LocalBroadcastManager.getInstance(appContext);

		lobbyChatlog = new MessageLog(appContext);

		roomChatlog = new MessageLog(appContext);

	}

		lobbyPlayerlist.clear();

		roomList.clear();

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

		playerName = name;

		if(state != State.NOT_CONNECTED) {

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

		}

		changeState(State.CONNECTING);

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

	}

	public void sendNick(String nick) {

		playerName = nick;

	}

	public void sendAddTeam(Team newTeam) {

		roomRequestedTeams.put(newTeam.name, newTeam);

	}

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

	}

	public String getPlayerName() {

		return playerName;

	}

		return sendToNet(what, 0, null);

	}

		return sendToNet(what, 0, obj);

	}

		if(connection != null) {

			Handler handler = connection.toNetHandler;

		} 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.

	 */

	@SuppressLint("HandlerLeak")

	final class FromNetHandler extends Handler {

		public FromNetHandler() {

			super(Looper.getMainLooper());

		}

		@SuppressWarnings("unchecked")

		@Override

		public void handleMessage(Message msg) {

			case MSG_LOBBY_JOIN: {

				String name = (String)msg.obj;

				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;

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

				break;

			}

			case MSG_MESSAGE: {

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

				break;

			}

			case MSG_ROOM_ADD: {

				break;

			}

			case MSG_ROOM_UPDATE: {

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

				break;

			}

			case MSG_ROOM_DELETE: {

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

				break;

			}

			case MSG_ROOMLIST: {

				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;

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

				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;

				break;

			}

			case MSG_TEAM_ADDED: {

				Team newTeam = (Team)msg.obj;

				TeamInGame tig = new TeamInGame(newTeam, attrs);

					sendTeamColorIndex(newTeam.name, attrs.colorIndex);

					sendTeamHogCount(newTeam.name, attrs.hogCount);

				}

				break;

			}

			case MSG_TEAM_DELETED: {

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

				break;

			}

			case MSG_TEAM_ACCEPTED: {

				Team requestedTeam = roomRequestedTeams.remove(msg.obj);

				if(requestedTeam!=null) {

					TeamInGame tig = new TeamInGame(requestedTeam, attrs);

						sendTeamColorIndex(requestedTeam.name, attrs.colorIndex);

						sendTeamHogCount(requestedTeam.name, attrs.hogCount);

					}

				} else {

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

				}

				break;

			}

			case MSG_TEAM_COLOR_CHANGED: {

				if(oldEntry != null) {

				} else {

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

				}

				break;

			}

			case MSG_HOG_COUNT_CHANGED: {

				if(oldEntry != null) {

				} else {

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

				}

				break;

			}