using System;
using System.Collections.Generic;

namespace UnityEngine.Networking
{
	// Token: 0x02000056 RID: 86
	internal class NetworkScene
	{
		// Token: 0x1700009A RID: 154
		// (get) Token: 0x0600039E RID: 926 RVA: 0x00014BE4 File Offset: 0x00012DE4
		internal Dictionary<NetworkInstanceId, NetworkIdentity> localObjects
		{
			get
			{
				return this.m_LocalObjects;
			}
		}

		// Token: 0x1700009B RID: 155
		// (get) Token: 0x0600039F RID: 927 RVA: 0x00014C00 File Offset: 0x00012E00
		internal static Dictionary<NetworkHash128, GameObject> guidToPrefab
		{
			get
			{
				return NetworkScene.s_GuidToPrefab;
			}
		}

		// Token: 0x1700009C RID: 156
		// (get) Token: 0x060003A0 RID: 928 RVA: 0x00014C1C File Offset: 0x00012E1C
		internal static Dictionary<NetworkHash128, SpawnDelegate> spawnHandlers
		{
			get
			{
				return NetworkScene.s_SpawnHandlers;
			}
		}

		// Token: 0x1700009D RID: 157
		// (get) Token: 0x060003A1 RID: 929 RVA: 0x00014C38 File Offset: 0x00012E38
		internal static Dictionary<NetworkHash128, UnSpawnDelegate> unspawnHandlers
		{
			get
			{
				return NetworkScene.s_UnspawnHandlers;
			}
		}

		// Token: 0x060003A2 RID: 930 RVA: 0x00014C52 File Offset: 0x00012E52
		internal void Shutdown()
		{
			this.ClearLocalObjects();
			NetworkScene.ClearSpawners();
		}

		// Token: 0x060003A3 RID: 931 RVA: 0x00014C60 File Offset: 0x00012E60
		internal void SetLocalObject(NetworkInstanceId netId, GameObject obj, bool isClient, bool isServer)
		{
			if (LogFilter.logDev)
			{
				Debug.Log(string.Concat(new object[] { "SetLocalObject ", netId, " ", obj }));
			}
			if (obj == null)
			{
				this.m_LocalObjects[netId] = null;
			}
			else
			{
				NetworkIdentity networkIdentity = null;
				if (this.m_LocalObjects.ContainsKey(netId))
				{
					networkIdentity = this.m_LocalObjects[netId];
				}
				if (networkIdentity == null)
				{
					networkIdentity = obj.GetComponent<NetworkIdentity>();
					this.m_LocalObjects[netId] = networkIdentity;
				}
				networkIdentity.UpdateClientServer(isClient, isServer);
			}
		}

		// Token: 0x060003A4 RID: 932 RVA: 0x00014D14 File Offset: 0x00012F14
		internal GameObject FindLocalObject(NetworkInstanceId netId)
		{
			if (this.m_LocalObjects.ContainsKey(netId))
			{
				NetworkIdentity networkIdentity = this.m_LocalObjects[netId];
				if (networkIdentity != null)
				{
					return networkIdentity.gameObject;
				}
			}
			return null;
		}

		// Token: 0x060003A5 RID: 933 RVA: 0x00014D64 File Offset: 0x00012F64
		internal bool GetNetworkIdentity(NetworkInstanceId netId, out NetworkIdentity uv)
		{
			bool flag;
			if (this.m_LocalObjects.ContainsKey(netId) && this.m_LocalObjects[netId] != null)
			{
				uv = this.m_LocalObjects[netId];
				flag = true;
			}
			else
			{
				uv = null;
				flag = false;
			}
			return flag;
		}

		// Token: 0x060003A6 RID: 934 RVA: 0x00014DBC File Offset: 0x00012FBC
		internal bool RemoveLocalObject(NetworkInstanceId netId)
		{
			return this.m_LocalObjects.Remove(netId);
		}

		// Token: 0x060003A7 RID: 935 RVA: 0x00014DE0 File Offset: 0x00012FE0
		internal bool RemoveLocalObjectAndDestroy(NetworkInstanceId netId)
		{
			bool flag;
			if (this.m_LocalObjects.ContainsKey(netId))
			{
				NetworkIdentity networkIdentity = this.m_LocalObjects[netId];
				Object.Destroy(networkIdentity.gameObject);
				flag = this.m_LocalObjects.Remove(netId);
			}
			else
			{
				flag = false;
			}
			return flag;
		}

		// Token: 0x060003A8 RID: 936 RVA: 0x00014E32 File Offset: 0x00013032
		internal void ClearLocalObjects()
		{
			this.m_LocalObjects.Clear();
		}

		// Token: 0x060003A9 RID: 937 RVA: 0x00014E40 File Offset: 0x00013040
		internal static void RegisterPrefab(GameObject prefab, NetworkHash128 newAssetId)
		{
			NetworkIdentity component = prefab.GetComponent<NetworkIdentity>();
			if (component)
			{
				component.SetDynamicAssetId(newAssetId);
				if (LogFilter.logDebug)
				{
					Debug.Log(string.Concat(new object[] { "Registering prefab '", prefab.name, "' as asset:", component.assetId }));
				}
				NetworkScene.s_GuidToPrefab[component.assetId] = prefab;
			}
			else if (LogFilter.logError)
			{
				Debug.LogError("Could not register '" + prefab.name + "' since it contains no NetworkIdentity component");
			}
		}

		// Token: 0x060003AA RID: 938 RVA: 0x00014EEC File Offset: 0x000130EC
		internal static void RegisterPrefab(GameObject prefab)
		{
			NetworkIdentity component = prefab.GetComponent<NetworkIdentity>();
			if (component)
			{
				if (LogFilter.logDebug)
				{
					Debug.Log(string.Concat(new object[] { "Registering prefab '", prefab.name, "' as asset:", component.assetId }));
				}
				NetworkScene.s_GuidToPrefab[component.assetId] = prefab;
				NetworkIdentity[] componentsInChildren = prefab.GetComponentsInChildren<NetworkIdentity>();
				if (componentsInChildren.Length > 1)
				{
					if (LogFilter.logWarn)
					{
						Debug.LogWarning("The prefab '" + prefab.name + "' has multiple NetworkIdentity components. There can only be one NetworkIdentity on a prefab, and it must be on the root object.");
					}
				}
			}
			else if (LogFilter.logError)
			{
				Debug.LogError("Could not register '" + prefab.name + "' since it contains no NetworkIdentity component");
			}
		}

		// Token: 0x060003AB RID: 939 RVA: 0x00014FC8 File Offset: 0x000131C8
		internal static bool GetPrefab(NetworkHash128 assetId, out GameObject prefab)
		{
			bool flag;
			if (!assetId.IsValid())
			{
				prefab = null;
				flag = false;
			}
			else if (NetworkScene.s_GuidToPrefab.ContainsKey(assetId) && NetworkScene.s_GuidToPrefab[assetId] != null)
			{
				prefab = NetworkScene.s_GuidToPrefab[assetId];
				flag = true;
			}
			else
			{
				prefab = null;
				flag = false;
			}
			return flag;
		}

		// Token: 0x060003AC RID: 940 RVA: 0x00015033 File Offset: 0x00013233
		internal static void ClearSpawners()
		{
			NetworkScene.s_GuidToPrefab.Clear();
			NetworkScene.s_SpawnHandlers.Clear();
			NetworkScene.s_UnspawnHandlers.Clear();
		}

		// Token: 0x060003AD RID: 941 RVA: 0x00015054 File Offset: 0x00013254
		public static void UnregisterSpawnHandler(NetworkHash128 assetId)
		{
			NetworkScene.s_SpawnHandlers.Remove(assetId);
			NetworkScene.s_UnspawnHandlers.Remove(assetId);
		}

		// Token: 0x060003AE RID: 942 RVA: 0x00015070 File Offset: 0x00013270
		internal static void RegisterSpawnHandler(NetworkHash128 assetId, SpawnDelegate spawnHandler, UnSpawnDelegate unspawnHandler)
		{
			if (spawnHandler == null || unspawnHandler == null)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("RegisterSpawnHandler custom spawn function null for " + assetId);
				}
			}
			else
			{
				if (LogFilter.logDebug)
				{
					Debug.Log(string.Concat(new object[]
					{
						"RegisterSpawnHandler asset '",
						assetId,
						"' ",
						spawnHandler.GetMethodName(),
						"/",
						unspawnHandler.GetMethodName()
					}));
				}
				NetworkScene.s_SpawnHandlers[assetId] = spawnHandler;
				NetworkScene.s_UnspawnHandlers[assetId] = unspawnHandler;
			}
		}

		// Token: 0x060003AF RID: 943 RVA: 0x00015118 File Offset: 0x00013318
		internal static void UnregisterPrefab(GameObject prefab)
		{
			NetworkIdentity component = prefab.GetComponent<NetworkIdentity>();
			if (component == null)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("Could not unregister '" + prefab.name + "' since it contains no NetworkIdentity component");
				}
			}
			else
			{
				NetworkScene.s_SpawnHandlers.Remove(component.assetId);
				NetworkScene.s_UnspawnHandlers.Remove(component.assetId);
			}
		}

		// Token: 0x060003B0 RID: 944 RVA: 0x00015188 File Offset: 0x00013388
		internal static void RegisterPrefab(GameObject prefab, SpawnDelegate spawnHandler, UnSpawnDelegate unspawnHandler)
		{
			NetworkIdentity component = prefab.GetComponent<NetworkIdentity>();
			if (component == null)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("Could not register '" + prefab.name + "' since it contains no NetworkIdentity component");
				}
			}
			else if (spawnHandler == null || unspawnHandler == null)
			{
				if (LogFilter.logError)
				{
					Debug.LogError("RegisterPrefab custom spawn function null for " + component.assetId);
				}
			}
			else if (!component.assetId.IsValid())
			{
				if (LogFilter.logError)
				{
					Debug.LogError("RegisterPrefab game object " + prefab.name + " has no prefab. Use RegisterSpawnHandler() instead?");
				}
			}
			else
			{
				if (LogFilter.logDebug)
				{
					Debug.Log(string.Concat(new object[]
					{
						"Registering custom prefab '",
						prefab.name,
						"' as asset:",
						component.assetId,
						" ",
						spawnHandler.GetMethodName(),
						"/",
						unspawnHandler.GetMethodName()
					}));
				}
				NetworkScene.s_SpawnHandlers[component.assetId] = spawnHandler;
				NetworkScene.s_UnspawnHandlers[component.assetId] = unspawnHandler;
			}
		}

		// Token: 0x060003B1 RID: 945 RVA: 0x000152D4 File Offset: 0x000134D4
		internal static bool GetSpawnHandler(NetworkHash128 assetId, out SpawnDelegate handler)
		{
			bool flag;
			if (NetworkScene.s_SpawnHandlers.ContainsKey(assetId))
			{
				handler = NetworkScene.s_SpawnHandlers[assetId];
				flag = true;
			}
			else
			{
				handler = null;
				flag = false;
			}
			return flag;
		}

		// Token: 0x060003B2 RID: 946 RVA: 0x00015314 File Offset: 0x00013514
		internal static bool InvokeUnSpawnHandler(NetworkHash128 assetId, GameObject obj)
		{
			bool flag;
			if (NetworkScene.s_UnspawnHandlers.ContainsKey(assetId) && NetworkScene.s_UnspawnHandlers[assetId] != null)
			{
				UnSpawnDelegate unSpawnDelegate = NetworkScene.s_UnspawnHandlers[assetId];
				unSpawnDelegate(obj);
				flag = true;
			}
			else
			{
				flag = false;
			}
			return flag;
		}

		// Token: 0x060003B3 RID: 947 RVA: 0x00015368 File Offset: 0x00013568
		internal void DestroyAllClientObjects()
		{
			foreach (NetworkInstanceId networkInstanceId in this.m_LocalObjects.Keys)
			{
				NetworkIdentity networkIdentity = this.m_LocalObjects[networkInstanceId];
				if (networkIdentity != null && networkIdentity.gameObject != null)
				{
					if (!NetworkScene.InvokeUnSpawnHandler(networkIdentity.assetId, networkIdentity.gameObject))
					{
						if (networkIdentity.sceneId.IsEmpty())
						{
							Object.Destroy(networkIdentity.gameObject);
						}
						else
						{
							networkIdentity.MarkForReset();
							networkIdentity.gameObject.SetActive(false);
						}
					}
				}
			}
			this.ClearLocalObjects();
		}

		// Token: 0x060003B4 RID: 948 RVA: 0x0001544C File Offset: 0x0001364C
		internal void DumpAllClientObjects()
		{
			foreach (NetworkInstanceId networkInstanceId in this.m_LocalObjects.Keys)
			{
				NetworkIdentity networkIdentity = this.m_LocalObjects[networkInstanceId];
				if (networkIdentity != null)
				{
					Debug.Log(string.Concat(new object[] { "ID:", networkInstanceId, " OBJ:", networkIdentity.gameObject, " AS:", networkIdentity.assetId }));
				}
				else
				{
					Debug.Log("ID:" + networkInstanceId + " OBJ: null");
				}
			}
		}

		// Token: 0x040001B3 RID: 435
		private Dictionary<NetworkInstanceId, NetworkIdentity> m_LocalObjects = new Dictionary<NetworkInstanceId, NetworkIdentity>();

		// Token: 0x040001B4 RID: 436
		private static Dictionary<NetworkHash128, GameObject> s_GuidToPrefab = new Dictionary<NetworkHash128, GameObject>();

		// Token: 0x040001B5 RID: 437
		private static Dictionary<NetworkHash128, SpawnDelegate> s_SpawnHandlers = new Dictionary<NetworkHash128, SpawnDelegate>();

		// Token: 0x040001B6 RID: 438
		private static Dictionary<NetworkHash128, UnSpawnDelegate> s_UnspawnHandlers = new Dictionary<NetworkHash128, UnSpawnDelegate>();
	}
}