/*

 * 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 static org.hedgewars.hedgeroid.util.ObjectUtils.equal;

import java.util.Arrays;

import java.util.Collections;

import java.util.Map;

import java.util.TreeMap;

import org.hedgewars.hedgeroid.BasicRoomState;

import org.hedgewars.hedgeroid.Datastructures.GameConfig;

import org.hedgewars.hedgeroid.Datastructures.MapRecipe;

import org.hedgewars.hedgeroid.Datastructures.Scheme;

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.netplay.ThreadedNetConnection.ToNetMsgType;

/**

 * This class manages the room state in a network game.

 */

class NetRoomState extends BasicRoomState {

    final Map<String, TeamInGame> requestedTeams = new TreeMap<String, TeamInGame>();

    private Netplay netplay;

    public NetRoomState(Netplay netplay) {

        this.netplay = netplay;

        initRoomState(false);

    }

    public void changeWeaponset(Weaponset weaponset) {

        if(getChiefStatus() && !equal(weaponset, getWeaponset())) {

            sendToNet(MSG_SEND_WEAPONSET, weaponset);

            setWeaponset(weaponset);

        }

    }

    public void changeMapRecipe(MapRecipe mapRecipe) {

        if(getChiefStatus() && !equal(mapRecipe, getMapRecipe())) {

            sendToNet(MSG_SEND_MAP, mapRecipe);

            setMapRecipe(mapRecipe);

        }

    }

    public void changeMapNameAndGenerator(String mapName) {

        if(getChiefStatus() && !equal(mapName, getMapRecipe().name)) {

            int newGenerator = MapRecipe.generatorForMapname(mapName);

            if(newGenerator != getMapRecipe().mapgen) {

                sendToNet(MSG_SEND_MAP_GENERATOR, newGenerator, null);

            }

            sendToNet(MSG_SEND_MAP_NAME, mapName);

            setMapRecipe(getMapRecipe().withName(mapName).withMapgen(newGenerator));

        }

    }

    public void changeMapTemplate(int template) {

        if(getChiefStatus() && template != getMapRecipe().templateFilter) {

            sendToNet(MSG_SEND_MAP_TEMPLATE, template, null);

            setMapRecipe(getMapRecipe().withTemplateFilter(template));

        }

    }

    public void changeMazeSize(int mazeSize) {

        if(getChiefStatus() && mazeSize != getMapRecipe().mazeSize) {

            sendToNet(MSG_SEND_MAZE_SIZE, mazeSize, 0);

            setMapRecipe(getMapRecipe().withMazeSize(mazeSize));

        }

    }

    public void changeMapSeed(String seed) {

        if(getChiefStatus() && !equal(seed, getMapRecipe().seed)) {

            sendToNet(MSG_SEND_MAP_SEED, seed);

            setMapRecipe(getMapRecipe().withSeed(seed));

        }

    }

    public void changeMapTheme(String theme) {

        if(getChiefStatus() && !equal(theme, getMapRecipe().theme)) {

            sendToNet(MSG_SEND_MAP_THEME, theme);

            setMapRecipe(getMapRecipe().withTheme(theme));

        }

    }

    public void changeMapDrawdata(byte[] drawdata) {

        if(getChiefStatus() && !Arrays.equals(drawdata, getMapRecipe().getDrawData())) {

            sendToNet(MSG_SEND_MAP_DRAWDATA, drawdata);

            setMapRecipe(getMapRecipe().withDrawData(drawdata));

        }

    }

    public void changeGameStyle(String gameStyle) {

        if(getChiefStatus() && !equal(gameStyle, getGameStyle())) {

            sendToNet(MSG_SEND_GAMESTYLE, gameStyle);

            setGameStyle(gameStyle);

        }

    }

    public void changeScheme(Scheme scheme) {

        if(getChiefStatus() && !equal(scheme, getScheme())) {

            sendToNet(MSG_SEND_SCHEME, scheme);

            setScheme(scheme);

        }

    }

    void initRoomState(boolean chief) {

        setTeams(Collections.<String, TeamInGame>emptyMap());

        requestedTeams.clear();

        setChief(chief);

        setGameStyle(GameConfig.DEFAULT_STYLE);

        setMapRecipe(MapRecipe.makeRandomMap(0, "seed", GameConfig.DEFAULT_THEME));

        setScheme(netplay.defaultScheme);

        setWeaponset(netplay.defaultWeaponset);

        sendFullConfig();

    }

    void sendFullConfig() {

        if(getChiefStatus()) {

            sendToNet(MSG_SEND_GAMESTYLE, getGameStyle());

            sendToNet(MSG_SEND_SCHEME, getScheme());

            sendToNet(MSG_SEND_WEAPONSET, getWeaponset());

            sendToNet(MSG_SEND_MAP, getMapRecipe());

        }

    }

    private boolean sendToNet(ToNetMsgType what, Object obj) {

        return netplay.sendToNet(what, 0, obj);

    }

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

        return netplay.sendToNet(what, arg1, obj);

    }

    public void requestAddTeam(Team team, int colorIndex) {

        TeamIngameAttributes tia = new TeamIngameAttributes(netplay.getPlayerName(), colorIndex, TeamIngameAttributes.DEFAULT_HOG_COUNT, false);

        TeamInGame newTeamInGame = new TeamInGame(team, tia);

        requestedTeams.put(team.name, newTeamInGame);

        sendToNet(MSG_SEND_ADD_TEAM, newTeamInGame);

    }

    public void requestRemoveTeam(String teamname) {

        sendToNet(MSG_SEND_REMOVE_TEAM, teamname);

    }

    public void changeTeamColorIndex(String teamname, int colorIndex) {

        if(getChiefStatus()) {

            TeamInGame team = getTeams().get(teamname);

            if(team.ingameAttribs.colorIndex != colorIndex) {

                sendToNet(MSG_SEND_TEAM_COLOR_INDEX, colorIndex, teamname);

                putTeam(team.withAttribs(team.ingameAttribs.withColorIndex(colorIndex)));

            }

        }

    }

    public void changeTeamHogCount(String teamname, int hogcount) {

        if(getChiefStatus()) {

            TeamInGame team = getTeams().get(teamname);

            if(team.ingameAttribs.hogCount != hogcount) {

                sendToNet(MSG_SEND_TEAM_HOG_COUNT, hogcount, teamname);

                putTeam(team.withAttribs(team.ingameAttribs.withHogCount(hogcount)));

            }

        }

    }

}