/*

 * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game

 * Copyright (C) 2012 Simeon Maxein <smaxein@googlemail.com>

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

 */

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 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.TeamInGame;

import org.hedgewars.hedgeroid.Datastructures.TeamIngameAttributes;

import org.hedgewars.hedgeroid.Datastructures.Weaponset;

import org.hedgewars.hedgeroid.Datastructures.Weaponsets;

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 }

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

    public final Scheme defaultScheme;

    public final Weaponset defaultWeaponset;

    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;

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

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

    public Netplay(Context appContext, Scheme defaultScheme, Weaponset defaultWeaponset) {

        this.appContext = appContext;

        broadcastManager = LocalBroadcastManager.getInstance(appContext);

        lobbyChatlog = new MessageLog(appContext);

        roomChatlog = new MessageLog(appContext);

        this.defaultScheme = defaultScheme;

        this.defaultWeaponset = defaultWeaponset;

    }

    public RoomStateManager getRoomStateManager() {

        return netRoomState;

    }

    private void clearLobbyState() {

        lobbyPlayerlist.clear();

        roomList.clear();

        lobbyChatlog.clear();

    }

    private void initRoomState(boolean chief) {

        roomChatlog.clear();

        roomPlayerlist.clear();

        netRoomState.initRoomState(chief);

    }

    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 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 sendStartGame() { sendToNet(MSG_SEND_START_GAME); }

    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 will need some default values for rooms, best load them here

            Scheme defaultScheme = null;

            Weaponset defaultWeaponset = null;

            try {

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

                for(Scheme scheme : schemes) {

                    if(scheme.name.equals(GameConfig.DEFAULT_SCHEME)) {

                        defaultScheme = scheme;

                    }

                }

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

                for(Weaponset weaponset : weaponsets) {

                    if(weaponset.name.equals(GameConfig.DEFAULT_WEAPONSET)) {

                        defaultWeaponset = weaponset;

                    }

                }

            } catch(IOException e) {

                throw new RuntimeException(e);

            }

            if(defaultScheme==null || defaultWeaponset==null) {

                throw new RuntimeException("Unable to load default scheme or weaponset");

            }

            instance = new Netplay(applicationContext, defaultScheme, defaultWeaponset);

        }

        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.getChiefStatus();

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

            return roomChatlog;

        } else {

            return lobbyChatlog;

        }

    }

    public static enum FromNetMsgType {

        MSG_LOBBY_JOIN,

        MSG_LOBBY_LEAVE,

        MSG_ROOM_JOIN,

        MSG_ROOM_LEAVE,

        MSG_CLIENT_FLAGS,

        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_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_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, 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_CLIENT_FLAGS: {

                ClientFlagsUpdate upd = (ClientFlagsUpdate)msg.obj;

                PlayerInRoom pir = roomPlayerlist.get(upd.nick);

                if(pir != null) {

                    roomPlayerlist.put(upd.nick, upd.applyTo(pir));

                }

                Player p = lobbyPlayerlist.get(upd.nick);

                if(p != null) {

                    lobbyPlayerlist.put(upd.nick, upd.applyTo(p));

                } else {

                    Log.w("Netplay", "Received client flags for unknown player "+upd.nick);

                }

                if(playerName.equals(upd.nick) && upd.appliesTo(ClientFlagsUpdate.FLAG_CHIEF)) {

                    netRoomState.setChief(upd.newFlagState);

                }

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

                TeamInGame newTeam = (TeamInGame)msg.obj;

                if(isChief()) {

                    int freeColor = TeamInGame.getUnusedOrRandomColorIndex(netRoomState.getTeams().values());

                    sendToNet(MSG_SEND_TEAM_HOG_COUNT, newTeam.ingameAttribs.hogCount, newTeam.team.name);

                    sendToNet(MSG_SEND_TEAM_COLOR_INDEX, freeColor, newTeam.team.name);

                    newTeam = newTeam.withAttribs(newTeam.ingameAttribs.withColorIndex(freeColor));

                }

                netRoomState.putTeam(newTeam);

                break;

            }

            case MSG_TEAM_DELETED: {

                netRoomState.removeTeam((String)msg.obj);

                break;

            }

            case MSG_TEAM_ACCEPTED: {

                TeamInGame requestedTeam = netRoomState.requestedTeams.remove(msg.obj);

                if(requestedTeam!=null) {

                    netRoomState.putTeam(requestedTeam);

                    if(isChief()) {

                        // Not strictly necessary, but QtFrontend does it...

                        sendToNet(MSG_SEND_TEAM_HOG_COUNT, requestedTeam.ingameAttribs.hogCount, requestedTeam.team.name);

                    }

                } else {

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

                }

                break;

            }

            case MSG_TEAM_COLOR_CHANGED: {

                TeamInGame oldEntry = netRoomState.getTeams().get((String)msg.obj);

                if(oldEntry != null) {

                    /*

                     * If we are chief, we ignore colors from the outside. They only come from the server

                     * when someone adds a team then, and we override that choice anyway.

                     * Worse, that color message arrives *after* we have overridden the color, so it would

                     * re-override it right back.

                     */

                    if(!isChief()) {

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

                        netRoomState.putTeam(oldEntry.withAttribs(newAttribs));

                    }

                } else {

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

                }

                break;

            }

            case MSG_HOG_COUNT_CHANGED: {

                TeamInGame oldEntry = netRoomState.getTeams().get((String)msg.obj);

                if(oldEntry != null) {

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

                    netRoomState.putTeam(oldEntry.withAttribs(newAttribs));

                } else {

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

                }