package org.hedgewars.hedgeroid.netplay;

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

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

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

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

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

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

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

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

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

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

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

import java.util.Arrays;

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

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 implements RoomStateManager {

	private List<RoomStateManager.Observer> observers = new LinkedList<RoomStateManager.Observer>();

	private Netplay netplay;

	boolean chief;

	String gameStyle;

	Scheme scheme;

	MapRecipe map;

	Weaponset weaponset;

	public NetRoomState(Netplay netplay) {

		this.netplay = netplay;

		this.map = MapRecipe.makeRandomMap(0, "seed", GameConfig.DEFAULT_THEME);

	}

	public MapRecipe getMapRecipe() {

		return map;

	}

	public boolean getChiefStatus() {

		return chief;

	}

	public Scheme getScheme() {

		return scheme;

	}

	public String getGameStyle() {

		return gameStyle;

	}

	public Weaponset getWeaponset() {

		return weaponset;

	}

	public void changeWeaponset(Weaponset weaponset) {

		if(chief && !weaponset.equals(this.weaponset)) {

			sendToNet(MSG_SEND_WEAPONSET, weaponset);

			setWeaponset(weaponset);

		}

	}

	public void changeMapRecipe(MapRecipe mapRecipe) {

		if(chief && !mapRecipe.equals(this.map)) {

			sendToNet(MSG_SEND_MAP, mapRecipe);

			setMapRecipe(mapRecipe);

		}

	}

	public void changeMapNameAndGenerator(String mapName) {

		if(chief && !mapName.equals(this.map.name)) {

			int newGenerator = MapRecipe.generatorForMapname(mapName);

			if(newGenerator != this.map.mapgen) {

				sendToNet(MSG_SEND_MAP_GENERATOR, newGenerator, null);

			}

			sendToNet(MSG_SEND_MAP_NAME, mapName);

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

		}

	}

	public void changeMapTemplate(int template) {

		if(chief && template != this.map.templateFilter) {

			sendToNet(MSG_SEND_MAP_TEMPLATE, template, null);

			setMapRecipe(map.withTemplateFilter(template));

		}

	}

	public void changeMazeSize(int mazeSize) {

		if(chief && mazeSize != this.map.mazeSize) {

			sendToNet(MSG_SEND_MAZE_SIZE, mazeSize, 0);

			setMapRecipe(map.withMazeSize(mazeSize));

		}

	}

	public void changeMapSeed(String seed) {

		if(chief && !seed.equals(this.map.seed)) {

			sendToNet(MSG_SEND_MAP_SEED, seed);

			setMapRecipe(map.withSeed(seed));

		}

	}

	public void changeMapTheme(String theme) {

		if(chief && !theme.equals(this.map.theme)) {

			sendToNet(MSG_SEND_MAP_THEME, theme);

			setMapRecipe(map.withTheme(theme));

		}

	}

	public void changeMapDrawdata(byte[] drawdata) {

		if(chief && !Arrays.equals(drawdata, this.map.getDrawData())) {

			sendToNet(MSG_SEND_MAP_DRAWDATA, drawdata);

			setMapRecipe(map.withDrawData(drawdata));

		}

	}

	public void changeGameStyle(String gameStyle) {

		if(chief && !gameStyle.equals(this.gameStyle)) {

			sendToNet(MSG_SEND_GAMESTYLE, gameStyle);

			setGameStyle(gameStyle);

		}

	}

	public void changeScheme(Scheme scheme) {

		if(chief && !scheme.equals(this.scheme)) {

			sendToNet(MSG_SEND_SCHEME, scheme);

			setScheme(scheme);

		}

	}

	void setWeaponset(Weaponset weaponset) {

		if(!weaponset.equals(this.weaponset)) {

			this.weaponset = weaponset;

			for(RoomStateManager.Observer observer : observers) {

				observer.onWeaponsetChanged(weaponset);

			}

		}

	}

	void setMapRecipe(MapRecipe map) {

		if(!map.equals(this.map)) { 

			this.map = map;

			for(RoomStateManager.Observer observer : observers) {

				observer.onMapChanged(map);

			}

		}

	}

	void setGameStyle(String gameStyle) {

		if(!gameStyle.equals(this.gameStyle)) {

			this.gameStyle = gameStyle;

			for(RoomStateManager.Observer observer : observers) {

				observer.onGameStyleChanged(gameStyle);

			}

		}

	}

	void setScheme(Scheme scheme) {

		if(!scheme.equals(this.scheme)) {

			this.scheme = scheme;

			for(RoomStateManager.Observer observer : observers) {

				observer.onSchemeChanged(scheme);

			}

		}

	}

	void setChief(boolean chief) {

		if(chief != this.chief) {

			this.chief = chief;

			for(RoomStateManager.Observer observer : observers) {

				observer.onChiefStatusChanged(chief);

			}

		}

	}

	void sendFullConfig() {

		if(chief) {

			sendToNet(MSG_SEND_GAMESTYLE, gameStyle);

			sendToNet(MSG_SEND_SCHEME, scheme);

			sendToNet(MSG_SEND_WEAPONSET, weaponset);

			sendToNet(MSG_SEND_MAP, map);

		}

	}

	public void registerObserver(Observer observer) {

		observers.add(observer);

	}

	public void unregisterObserver(Observer observer) {

		observers.remove(observer);

	}

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

	}

}