using System;
using System.Collections;
using System.IO;
using System.Reflection;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using FishNet;
using System.Collections.Generic;
using UnityEditor;
using log4net.Config;
using log4net;
using UnityEngine.Networking;
/// <summary>
/// The available scenes in the order they are in the build settings.
/// </summary>
public enum SceneEnum
{
	GameMangement,
	MainMenu,
	InGameUI,
	Arena,
	FreeFlyArena
}

namespace Managers
{

	/// <summary>
	/// Starts up the game and it's managers.
	/// Provides methods for loading additional scenes and triggering custom events when loaded.
	/// Orchestrates the managers for starting local and online matches.
	public class GameManager : MonoBehaviour
	{

		private static readonly ILog Log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);

		/// <summary>
		/// Globally accessible member to use manager with.
		/// </summary>
		public static GameManager G { get; private set; }

		[SerializeField]
		private UIManager UIManager;
		[SerializeField]
		private CharacterManager CharacterManager;
		[SerializeField]
		private ControlsManager ControlsManager;
		[SerializeField]
		private MatchManager MatchManager;
		[SerializeField]
		private StatisticsManager StatisticsManager;
		[SerializeField]
		private PlayerManager PlayerManager;
		[SerializeField]
		private AudioManager AudioManager;

		[SerializeField]
		private GameObject startCamera;

		[HideInInspector]
		public SceneEnum CurrentScene = SceneEnum.GameMangement;

		public bool IsTestRun = false;
		public SceneEnum TestScene = SceneEnum.Arena;
		public int TestSceneRule = 0;
		public int TestSceneArena = 0;


		public event EventHandler<SceneLoadEventArgs> CustomSceneLoaded;

		void Awake()
		{
			G = this;
			if (!IsTestRun) ShowStartScreen();
			LogManager.ConfigureLogging();
			//Application.targetFrameRate = 60;
			Log.Info("Awake");
		}

		void Start()
		{
			InstantiateBaseManagers();
			Log.Info("Space Smash Out is starting.");
			if (!IsTestRun)
			{
				LoadMainMenu();
			}
			else
			{
				// Coroutine for waiting a frame and letting the managers run their Start methods
				StartCoroutine(SetupTestMatch(TestScene));
			}
		}

		/// <summary>
		/// Instantiates the managers needed to play the game.
		/// </summary>
		void InstantiateBaseManagers()
		{
			if (UIManager != null)
			{
				UIManager = Instantiate(UIManager);
				Log.Info("User Interface Manager instantiated.");
			}
			else
			{
				Log.Error("User Interface Manager Prefab missing.");
			}
			if (ControlsManager != null)
			{
				ControlsManager = Instantiate(ControlsManager);
				Log.Info("Controls Manager instantiated.");
			}
			else
			{
				Log.Error("Controls Manager Prefab missing.");
			}
			if (MatchManager != null)
			{
				MatchManager = Instantiate(MatchManager);
				Log.Info("Match Manager instantiated.");
			}
			else
			{
				Log.Error("User Interface Manager Prefab missing.");
			}
			if (CharacterManager != null)
			{
				CharacterManager = Instantiate(CharacterManager);
				Log.Info("Character Manager instantiated.");
			}
			else
			{
				Log.Error("Character Manager Prefab missing.");
			}
			if (PlayerManager != null)
			{
				PlayerManager = Instantiate(PlayerManager);
				Log.Info("PlayerManager Manager instantiated.");
			}
			else
			{
				Log.Error("PlayerManager Manager Prefab missing.");
			}
			if (AudioManager != null)
			{
				AudioManager = Instantiate(AudioManager);
				Log.Info("PlayerManager Manager instantiated.");
			}
			else
			{
				Log.Error("PlayerManager Manager Prefab missing.");
			}
		}

		/// <summary>
		/// Starts the camera, for showing an image before the main menu is loaded.
		/// </summary>
		void ShowStartScreen()
		{
			startCamera.SetActive(true);
		}

		/// <summary>
		/// Sets up switching cameras once the menu is loaded
		/// and starts the async scene loading.
		/// </summary>
		void LoadMainMenu()
		{
			SingleUseSceneLoadedMethodCaller((args) =>
			{
				SceneManager.SetActiveScene(args.SceneRef);
				startCamera.SetActive(false);
				CurrentScene = SceneEnum.MainMenu;
			}, SceneEnum.MainMenu);
			SceneManager.LoadSceneAsync((int)SceneEnum.MainMenu, LoadSceneMode.Additive);
			Log.Info("Main menu scene loaded.");
		}

		/// <summary>
		/// Initiates a local battle by giving relavant information to the responsible managers
		/// and starting their appropriate processes.
		/// </summary>
		/// <param name="sceneId">Scene id of the chosen arena.</param>
		public IEnumerator SetupLocalMatchFromMainMenu(int ruleIndex, int arenaIndex)
		{
			MatchManager.LoadMatchRules(ruleIndex);
			MatchManager.LoadArenaProperties(arenaIndex);
			MatchManager.AssignMatchObjects();
			PlayerManager.LocalMatchJoinPlayers(MatchManager.ArenaProperties.minPlayerCount,
			MatchManager.ArenaProperties.maxPlayerCount);
			// TODO: This is in place of a character choosing menu etc.
			foreach (Player p in PlayerManager.MatchPlayers)
			{
				CharacterManager.AssignShipFixed(p);
				Log.Debug($"Ship: {p.character.name} assigned to player: {p.playerNumber}.");
			}

			MatchManager.StartCharacterSelect();
			CharacterManager.SpawnCharacters(PlayerManager.MatchPlayers);

			UIManager.StartManagingMatchUI();
			UIManager.AssignHUDElementsToPlayers(PlayerManager.MatchPlayers);

			ControlsManager.AssignControlsToPlayers(PlayerManager.MatchPlayers);

			UIManager.StartInputPrompt(ControlsManager.unassignedPlayers);

			// Waits with starting the match until every player has controls
			while (ControlsManager.unassignedPlayers.Count > 0)
			{
				yield return null;
			}
			MatchManager.StartMatch();
		}

		/// <summary>
		/// Starts a match scene without the menus or input/start prompts.
		/// </summary>
		/// <param name="scene">The match scene which will be loaded</param>
		/// <returns></returns>
		public IEnumerator SetupTestMatch(SceneEnum scene)
		{
			yield return null;
			SceneManager.LoadScene((int)scene, LoadSceneMode.Additive);
			CurrentScene = scene;
			yield return null;
			SceneManager.LoadScene((int)SceneEnum.InGameUI, LoadSceneMode.Additive);
			yield return null;
			SceneManager.SetActiveScene(SceneManager.GetSceneByBuildIndex((int)scene));
			yield return null;
			MatchManager.LoadMatchRules(TestSceneRule);
			MatchManager.LoadArenaProperties(TestSceneArena);
			MatchManager.AssignMatchObjects();
			PlayerManager.LocalMatchJoinPlayers(MatchManager.ArenaProperties.minPlayerCount,
			MatchManager.ArenaProperties.maxPlayerCount);
			foreach (Player p in PlayerManager.MatchPlayers)
			{
				CharacterManager.AssignShipFixed(p);
				Log.Debug($"Ship: {p.character.name} assigned to player: {p.playerNumber}.");
			}
			MatchManager.StartCharacterSelect();
			CharacterManager.SpawnCharacters(PlayerManager.MatchPlayers);
			UIManager.StartManagingMatchUI();
			UIManager.AssignHUDElementsToPlayers(PlayerManager.MatchPlayers);
			ControlsManager.AssignControlsToPlayers(PlayerManager.MatchPlayers);
			MatchManager.StartTestMatch();
		}

		/// <summary>
		/// Initiates an online battle by giving relavant information to the responsible managers
		/// and starting their appropriate processes.
		/// </summary>
		/// <param name="sceneId">Scene id of the chosen arena.</param>
		public IEnumerator SetupOnlineMatchFromMainMenu()
		{
			MatchManager.LoadMatchRules(0);
			MatchManager.LoadArenaProperties(0);
			MatchManager.AssignMatchObjects();
			// TODO: Selection for character in online play here
			PlayerManager.LoadOnlinePlayer();
			if (InstanceFinder.IsServerStarted)
				CharacterManager.AssignShipFixed(PlayerManager.OnlinePlayer, 0);
			else if (InstanceFinder.IsClientStarted)
				CharacterManager.AssignShipFixed(PlayerManager.OnlinePlayer, 1);
			Log.Debug($"Ship: {PlayerManager.OnlinePlayer.character.name} assigned to online player.");

			CharacterManager.SpawnOnlineCharacter(PlayerManager.OnlinePlayer);

			UIManager.StartManagingMatchUI();
			UIManager.AssignHUDElementsToPlayers(PlayerManager.MatchPlayers);

			ControlsManager.AssignControlsToPlayers(PlayerManager.MatchPlayers);

			UIManager.StartInputPrompt(ControlsManager.unassignedPlayers);

			// Waits with starting the match until every player has controls
			while (ControlsManager.unassignedPlayers.Count > 0)
			{
				yield return null;
			}
			MatchManager.StartTestMatch();
		}



		/// <summary>
		/// Triggers a method once, when a specific scene was loaded.
		/// </summary>
		/// <param name="func">The method which will be executed 
		/// once the scene is loaded.</param>
		/// <param name="sceneEnum">The scene which will trigger the method when loaded.</param>
		public void SingleUseSceneLoadedMethodCaller(CustomOnSceneLoaded method, SceneEnum sceneEnum)
		{
			// This is used because SceneManager.sceneLoaded only passes ref and loadMode.
			// I want add the sceneEnum to this, to check if the the sceneLoaded event
			// refers to the same scene as passed to this method.
			UnityAction<Scene, LoadSceneMode> OnSceneLoaded = (sceneRef, loadMode) =>
			{
				CustomSceneLoaded.Invoke(null, new SceneLoadEventArgs(sceneEnum, sceneRef));
			};

			EventHandler<SceneLoadEventArgs> handler = null;

			handler = (invoker, args) =>
			{
				// Thanks to the CustomSceneLoaded event I can check this here.
				if (args.SceneRef.buildIndex == (int)args.SceneEnum)
				{
					method(args);
				}
				else
				{
					Log.Warn("Should have loaded scene: " + args.SceneEnum.ToString() +
					" but the most recently loaded scene is: " + args.SceneRef.name +
					". Be careful of loading many scenes at once from different scripts!");
				}
				CustomSceneLoaded -= handler;
				SceneManager.sceneLoaded -= OnSceneLoaded;
			};

			CustomSceneLoaded += handler;

			SceneManager.sceneLoaded += OnSceneLoaded;
		}

		/// <summary>
		/// Loads all prefabs/gameobjects from a folder if the contain the given type
		/// as a component and adds them to a list.
		/// </summary>
		/// <param name="path">Path of the folder</param>
		/// <param name="prefabList">List the loaded prefabs will be added to</param>
		public static void LoadPrefabsFromFolder<T>(string path, in List<GameObject> prefabList)
		{
#if UNITY_EDITOR
			string[] files = Directory.GetFiles(path, "*.prefab",
				SearchOption.TopDirectoryOnly);
			List<GameObject> gos = new List<GameObject>();
			foreach (var file in files)
			{
				gos.Add(AssetDatabase.LoadAssetAtPath<GameObject>(file));
			}
			foreach (GameObject go in gos)
			{
				if (go.TryGetComponent<T>(out _))
				{
					prefabList.Add(go);
				}
				else
				{
					Log.Warn($"GameObject: {go.name} did not contain a {typeof(T).Name} component. It won't be added to the list.");
				}
			}
#else
			Log.Error("Can only access prefabs in folders when in editor!");
#endif
		}

		/// <summary>
		/// Loads all prefabs/gameobjects from an asset bundle if the contain the given type
		/// as a component and adds them to a list.
		/// TODO: DO NOT FORGET TO manually BUILD ASSET BUNDLES WHEN BUILDING
		/// </summary>
		/// <param name="name">Name of the asset bundle</param>
		/// <param name="prefabList">List the loaded prefabs will be added to</param>
		public static void LoadPrefabsFromBundle<T>(string name, in List<GameObject> prefabList)
		{
#if !UNITY_WEBGL
			AssetBundle assetBundle = AssetBundle.LoadFromFile(Path.Combine(Application.streamingAssetsPath, name));
#else
			string uri = "file:///" + Application.dataPath + "/AssetBundles/" + name;
			UnityWebRequest request
				= UnityWebRequestAssetBundle.GetAssetBundle(uri, 0);
			request.SendWebRequest();
			while (!request.isDone)
			{
				// Yeah I know 🤡
				// But I will explain myself:
				// I want these resources loaded, they are required for the game to run at all.
				// When using WebGL or running on Android, I cannot get AssetBundles from disk without
				// UnityWebRequest. I would have to use addressables and that would be too much time cost
				// right now!
			}
			AssetBundle assetBundle = DownloadHandlerAssetBundle.GetContent(request);
#endif
			if (assetBundle == null)
			{
				Log.Error("Failed to load arenas asset bundle!");
				return;
			}
			List<GameObject> gos = new List<GameObject>();
			gos.AddRange(assetBundle.LoadAllAssets<GameObject>());

			foreach (GameObject go in gos)
			{
				if (go.TryGetComponent<T>(out _))
				{
					prefabList.Add(go);
				}
				else
				{
					Log.Warn($"GameObject: {go.name} did not contain a {typeof(T).Name} component. It won't be added to the list.");
				}
			}
		}

		/// <summary>
		/// Loads all assets from a folder, if they are of the given type and adds them to a list.
		/// </summary>
		/// <param name="path">Path of the folder</param>
		/// <param name="prefabList">List the loaded prefabs will be added to</param>
		public static void LoadAssetsFromFolder<T>(string path, in List<T> prefabList)
		where T : UnityEngine.Object
		{
#if UNITY_EDITOR
			string[] files = Directory.GetFiles(path, "*.asset",
				SearchOption.TopDirectoryOnly);
			foreach (var file in files)
			{
				prefabList.Add(AssetDatabase.LoadAssetAtPath<T>(file));
			}
#else
			Log.Error("Can only access prefabs in folders when in editor!");
#endif
		}

		/// <summary>
		/// Loads all assets from an asset bundle, if they are of the given type and adds them to a list.
		/// TODO: DO NOT FORGET TO manually BUILD ASSET BUNDLES WHEN BUILDING
		/// </summary>
		/// <param name="name">Name of the asset bundle</param>
		/// <param name="prefabList">List the loaded prefabs will be added to</param>
		public static void LoadAssetsFromBundle<T>(string name, in List<T> assetsList) where T : UnityEngine.Object
		{
#if !UNITY_WEBGL
			var assetBundle = AssetBundle.LoadFromFile(Path.Combine(Application.streamingAssetsPath, name));
#else
			string uri = "file:///" + Application.dataPath + "/AssetBundles/" + name;
			UnityWebRequest request
				= UnityWebRequestAssetBundle.GetAssetBundle(uri, 0);
			while (!request.isDone)
			{
				// Yeah I know 🤡
				// But I will explain myself:
				// I want these resources loaded, they are required for the game to run at all.
				// When using WebGL or running on Android, I cannot get AssetBundles from disk without
				// UnityWebRequest. I would have to use addressables and that would be too much time cost
				// right now!
			}
			AssetBundle assetBundle = DownloadHandlerAssetBundle.GetContent(request);
#endif
			if (assetBundle == null)
			{
				Log.Error("Failed to load arenas asset bundle!");
				return;
			}
			assetsList.AddRange(assetBundle.LoadAllAssets<T>());
		}

	}

	/// <summary>
	/// Custom delegate which can be executed after scene load.
	/// </summary>
	/// <param name="args">Data of the loaded scene</param>
	public delegate void CustomOnSceneLoaded(SceneLoadEventArgs args);

	public class SceneLoadEventArgs : EventArgs
	{
		public SceneLoadEventArgs(SceneEnum sceneEnum, Scene sceneRef)
		{
			SceneEnum = sceneEnum;
			SceneRef = sceneRef;
		}
		public SceneEnum SceneEnum { get; set; }
		public Scene SceneRef { get; set; }
	}

}