package {
	import flash.events.EventDispatcher;
	
	public class GameStateModel extends EventDispatcher {
		public var level:LevelModel;
		public var tiles:Vector.<TileModel>;
		public var doodads:Vector.<TileModel>;
		public var objects:Vector.<GameObjectModel>;
		public var timeOfDay:Number;
		public var productivity:Number;
		private var officeTilesByOwner:Vector.<Vector.<Vector2>>;
		private var _coffeePotPosition:Vector2;
		private var _fridgePosition:Vector2;
		private var _mensRoomPosition:Vector2;
		private var _womensRoomPosition:Vector2;
		private var _elevatorPositions:Vector.<Vector2>;
		
		public function GameStateModel(level:LevelModel) {
			var tileClass:Class;
			
			this.level = level;
			tiles = new Vector.<TileModel>();
			doodads = new Vector.<TileModel>();
			officeTilesByOwner = new Vector.<Vector.<Vector2>>();
			for (var workerIndex:int = 0; workerIndex <= level.coworkers.length; workerIndex++) {
				officeTilesByOwner.push(new Vector.<Vector2>());
			}
			_elevatorPositions = new Vector.<Vector2>();
			for (var tileIndexZ:int = 0; tileIndexZ < level.sizeZ; tileIndexZ++) {
				for (var tileIndexX:int = 0; tileIndexX < level.sizeX; tileIndexX++) {
					tileClass = tileModelClassForType(level.tiles[tileIndexZ * level.sizeX + tileIndexX]);
					if (tileClass != null) {
						tiles.push(new tileClass(level.tiles[tileIndexZ * level.sizeX + tileIndexX], tileIndexX, tileIndexZ));
					} else {
						tiles.push(null);
					}
					
					tileClass = tileModelClassForType(level.doodads[tileIndexZ * level.sizeX + tileIndexX]);
					if (tileClass != null) {
						doodads.push(new tileClass(level.doodads[tileIndexZ * level.sizeX + tileIndexX], tileIndexX, tileIndexZ));
					} else {
						doodads.push(null);
					}
					
					if (level.officeOwners[tileIndexZ * level.sizeX + tileIndexX] != -1) {
						officeTilesByOwner[level.officeOwners[tileIndexZ * level.sizeX + tileIndexX]].push(new Vector2(tileIndexX, tileIndexZ));
					}
					
					switch (level.tiles[tileIndexZ * level.sizeX + tileIndexX]) {
						case TileModel.TILE_FridgeE:
						case TileModel.TILE_FridgeS:
							_fridgePosition = new Vector2(tileIndexX, tileIndexZ);
							break;
							
						case TileModel.TILE_BathroomDoorFE:
							_womensRoomPosition = new Vector2(tileIndexX, tileIndexZ);
							break;
							
						case TileModel.TILE_BathroomDoorME:
							_mensRoomPosition = new Vector2(tileIndexX, tileIndexZ);
							break;
							
						case TileModel.TILE_ElevatorLeftS:
						case TileModel.TILE_ElevatorRightS:
							_elevatorPositions.push(new Vector2(tileIndexX, tileIndexZ));
							break;
					}
					
					switch (level.doodads[tileIndexZ * level.sizeX + tileIndexX]) {
						case TileModel.TILE_CoffeemakerE:
						case TileModel.TILE_CoffeemakerS:
							_coffeePotPosition = new Vector2(tileIndexX, tileIndexZ);
							break;
					}
				}
			}
			objects = new Vector.<GameObjectModel>();
			timeOfDay = 0;
			productivity = 0;
		}
		
		private function tileModelClassForType(type:int):Class {
			switch (type) {
				case TileModel.TILE_CoffeemakerE:
				case TileModel.TILE_CoffeemakerS:
					return CoffeePotModel;
					
				case TileModel.TILE_DoorFrameE:
				case TileModel.TILE_DoorFrameN:
				case TileModel.TILE_DoorFrameS:
				case TileModel.TILE_DoorFrameW:
					return OfficeDoorFrameModel;
					
				case TileModel.TILE_FridgeE:
				case TileModel.TILE_FridgeS:
					return FridgeModel;
					
				default:
					return TileModel;
			}
		}
		
		public function addObject(object:GameObjectModel):void {
			objects.push(object);
			dispatchEvent(new GameObjectEvent(GameObjectEvent.ADDED, object));
		}
		
		private function tileTypeAtPositionInternal(array:Vector.<TileModel>, tileIndexX:int, tileIndexZ:int):int {
			if (tileIndexX < 0 || tileIndexX >= level.sizeX || tileIndexZ < 0 || tileIndexZ >= level.sizeZ) {
				return -1;
			}
			if (array[tileIndexZ * level.sizeX + tileIndexX] == null) {
				return -1;
			}
			return array[tileIndexZ * level.sizeX + tileIndexX].tileType;
		}
		
		public function tileTypeAtPosition(tileIndexX:int, tileIndexZ:int):int {
			return tileTypeAtPositionInternal(tiles, tileIndexX, tileIndexZ);
		}
		
		public function doodadTypeAtPosition(tileIndexX:int, tileIndexZ:int):int {
			return tileTypeAtPositionInternal(doodads, tileIndexX, tileIndexZ);
		}
		
		public function isSolidTileAtPosition(tileIndexX:int, tileIndexZ:int):Boolean {
			if (tileIndexX < 0 || tileIndexX >= level.sizeX || tileIndexZ < 0 || tileIndexX >= level.sizeZ) {
				return true;
			}
			if (tiles[tileIndexZ * level.sizeX + tileIndexX] == null) {
				return false;
			}
			switch (tiles[tileIndexZ * level.sizeX + tileIndexX].tileType) {
				case TileModel.TILE_DoorFrameE:
				case TileModel.TILE_DoorFrameN:
				case TileModel.TILE_DoorFrameS:
				case TileModel.TILE_DoorFrameW:
					return !OfficeDoorFrameModel(tiles[tileIndexZ * level.sizeX + tileIndexX]).open;
				default:
					return TileModel.isSolidTileType(tiles[tileIndexZ * level.sizeX + tileIndexX].tileType);
			}
		}
		
		public function validOfficeTilesForWorker(workerID:int):Vector.<Vector2> {
			return officeTilesByOwner[workerID];
		}
		
		public function get coffeePotPosition():Vector2 {
			return _coffeePotPosition;
		}
		
		public function get fridgePosition():Vector2 {
			return _fridgePosition;
		}
		
		public function get mensRoomPosition():Vector2 {
			return _mensRoomPosition;
		}
		
		public function get womensRoomPosition():Vector2 {
			return _womensRoomPosition;
		}
		
		public function get elevatorPositions():Vector.<Vector2> {
			return _elevatorPositions;
		}
		
		public function get player():PlayerModel {
			// HACK
			return objects[0] as PlayerModel;
		}
	}
}