namespace Oculus.Platform.Samples.VrHoops
{
	using UnityEngine;
	using UnityEngine.Assertions;
	using UnityEngine.UI;
	using System.Collections.Generic;
	using Oculus.Platform.Models;

	// This class coordinates playing matches.  It mediates being idle
	// and entering a practice or online game match.
	public class MatchController : MonoBehaviour
	{
		// Text to display when the match will start or finish
		[SerializeField] private Text m_timerText = null;

		// the camera is moved between the idle position and the assigned court position
		[SerializeField] private Camera m_camera = null;

		// where the camera will be when not in a match
		[SerializeField] private Transform m_idleCameraTransform = null;

		// button that toggles between matchmaking and cancel
		[SerializeField] private Text m_matchmakeButtonText = null;

		// this should equal the maximum number of players configured on the Oculus Dashboard
		[SerializeField] private PlayerArea[] m_playerAreas = new PlayerArea[3];

		// the time to wait between selecting Practice and starting
		[SerializeField] private uint PRACTICE_WARMUP_TIME = 5;

		// seconds to wait to coordinate P2P setup with other match players before starting
		[SerializeField] private uint MATCH_WARMUP_TIME = 30;

		// seconds for the match
		[SerializeField] private uint MATCH_TIME = 20;

		// how long to remain in position after the match to view results
		[SerializeField] private uint MATCH_COOLDOWN_TIME = 10;

		// panel to add most-wins leaderboard entries to
		[SerializeField] private GameObject m_mostWinsLeaderboard = null;

		// panel to add high-score leaderboard entries to
		[SerializeField] private GameObject m_highestScoresLeaderboard = null;

		// leaderboard entry Text prefab
		[SerializeField] private GameObject m_leaderboardEntryPrefab = null;

		// Text prefab to use for achievements fly-text
		[SerializeField] private GameObject m_flytext = null;

		// the current state of the match controller
		private State m_currentState;

		// transition time for states that automatically transition to the next state,
		// for example ending the match when the timer expires
		private float m_nextStateTransitionTime;

		// the court the local player was assigned to
		private int m_localSlot;

		void Start()
		{
			PlatformManager.Matchmaking.EnqueueResultCallback = OnMatchFoundCallback;
			PlatformManager.Matchmaking.MatchPlayerAddedCallback = MatchPlayerAddedCallback;
			PlatformManager.P2P.StartTimeOfferCallback = StartTimeOfferCallback;
			PlatformManager.Leaderboards.MostWinsLeaderboardUpdatedCallback = MostWinsLeaderboardCallback;
			PlatformManager.Leaderboards.HighScoreLeaderboardUpdatedCallback = HighestScoreLeaderboardCallback;

			TransitionToState(State.NONE);
		}

		void Update()
		{
			UpdateCheckForNextTimedTransition();
			UpdateMatchTimer();
		}

		public float MatchStartTime
		{
			get
			{
				switch(m_currentState)
				{
					case State.WAITING_TO_START_PRACTICE:
					case State.WAITING_TO_SETUP_MATCH:
						return m_nextStateTransitionTime;

					default: return 0;
				}
			}
			private set { m_nextStateTransitionTime = value; }
		}

		#region State Management

		private enum State
		{
			UNKNOWN,

			// no current match, waiting for the local user to select something
			NONE,

			// user selected a practice match, waiting for the match timer to start
			WAITING_TO_START_PRACTICE,

			// playing a Practice match against AI players
			PRACTICING,

			// post practice match, time to view the scores
			VIEWING_RESULTS_PRACTICE,

			// selecting Player Online and waiting for the Matchmaking service to find and create a
			// match and join the assigned match room
			WAITING_FOR_MATCH,

			// match room is joined, waiting to coordinate with the other players
			WAITING_TO_SETUP_MATCH,

			// playing a competative match against other players
			PLAYING_MATCH,

			// match is complete, viewing the match scores
			VIEWING_MATCH_RESULTS,
		}

		void TransitionToState(State newState)
		{
			Debug.LogFormat("MatchController State {0} -> {1}", m_currentState, newState);

			if (m_currentState != newState)
			{
				var oldState = m_currentState;
				m_currentState = newState;

				// state transition logic
				switch (newState)
				{
					case State.NONE:
						SetupForIdle();
						MoveCameraToIdlePosition();
						PlatformManager.TransitionToState(PlatformManager.State.WAITING_TO_PRACTICE_OR_MATCHMAKE);
						m_matchmakeButtonText.text = "Play Online";
						break;

					case State.WAITING_TO_START_PRACTICE:
						Assert.AreEqual(oldState, State.NONE);
						SetupForPractice();
						MoveCameraToMatchPosition();
						PlatformManager.TransitionToState(PlatformManager.State.MATCH_TRANSITION);
						m_nextStateTransitionTime = Time.time + PRACTICE_WARMUP_TIME;
						break;

					case State.PRACTICING:
						Assert.AreEqual(oldState, State.WAITING_TO_START_PRACTICE);
						PlatformManager.TransitionToState(PlatformManager.State.PLAYING_A_LOCAL_MATCH);
						m_nextStateTransitionTime = Time.time + MATCH_TIME;
						break;

					case State.VIEWING_RESULTS_PRACTICE:
						Assert.AreEqual(oldState, State.PRACTICING);
						PlatformManager.TransitionToState(PlatformManager.State.MATCH_TRANSITION);
						m_nextStateTransitionTime = Time.time + MATCH_COOLDOWN_TIME;
						m_timerText.text = "0:00.00";
						break;

					case State.WAITING_FOR_MATCH:
						Assert.AreEqual(oldState, State.NONE);
						PlatformManager.TransitionToState(PlatformManager.State.MATCH_TRANSITION);
						m_matchmakeButtonText.text = "Cancel";
						break;

					case State.WAITING_TO_SETUP_MATCH:
						Assert.AreEqual(oldState, State.WAITING_FOR_MATCH);
						m_nextStateTransitionTime = Time.time + MATCH_WARMUP_TIME;
						break;

					case State.PLAYING_MATCH:
						Assert.AreEqual(oldState, State.WAITING_TO_SETUP_MATCH);
						PlatformManager.TransitionToState(PlatformManager.State.PLAYING_A_NETWORKED_MATCH);
						m_nextStateTransitionTime = Time.time + MATCH_TIME;
						break;

					case State.VIEWING_MATCH_RESULTS:
						Assert.AreEqual(oldState, State.PLAYING_MATCH);
						PlatformManager.TransitionToState(PlatformManager.State.MATCH_TRANSITION);
						m_nextStateTransitionTime = Time.time + MATCH_COOLDOWN_TIME;
						m_timerText.text = "0:00.00";
						CalculateMatchResults();
						break;
				}
			}
		}

		void UpdateCheckForNextTimedTransition()
		{
			if (m_currentState != State.NONE && Time.time >= m_nextStateTransitionTime)
			{
				switch (m_currentState)
				{
					case State.WAITING_TO_START_PRACTICE:
						TransitionToState(State.PRACTICING);
						break;

					case State.PRACTICING:
						TransitionToState(State.VIEWING_RESULTS_PRACTICE);
						break;

					case State.VIEWING_RESULTS_PRACTICE:
						TransitionToState(State.NONE);
						break;

					case State.WAITING_TO_SETUP_MATCH:
						TransitionToState(State.PLAYING_MATCH);
						break;

					case State.PLAYING_MATCH:
						TransitionToState(State.VIEWING_MATCH_RESULTS);
						break;

					case State.VIEWING_MATCH_RESULTS:
						PlatformManager.Matchmaking.EndMatch();
						TransitionToState(State.NONE);
						break;
				}
			}
		}

		void UpdateMatchTimer()
		{
			if (Time.time <= m_nextStateTransitionTime)
			{
				switch (m_currentState)
				{
					case State.WAITING_TO_START_PRACTICE:
					case State.WAITING_TO_SETUP_MATCH:
						m_timerText.text = string.Format("{0:0}", Mathf.Ceil(Time.time - MatchStartTime));
						break;

					case State.PRACTICING:
					case State.PLAYING_MATCH:
						var delta = m_nextStateTransitionTime - Time.time;
						m_timerText.text = string.Format("{0:#0}:{1:#00}.{2:00}",
							Mathf.Floor(delta / 60),
							Mathf.Floor(delta) % 60,
							Mathf.Floor(delta * 100) % 100);
						break;
				}
			}
		}

		#endregion

		#region Player Setup/Teardown

		void SetupForIdle()
		{
			for (int i = 0; i < m_playerAreas.Length; i++)
			{
				m_playerAreas[i].SetupForPlayer<AIPlayer>("* AI *");
			}
		}

		void SetupForPractice()
		{
			// randomly select a position for the local player
			m_localSlot = Random.Range(0,m_playerAreas.Length-1);

			for (int i=0; i < m_playerAreas.Length; i++)
			{
				if (i == m_localSlot)
				{
					m_playerAreas[i].SetupForPlayer<LocalPlayer>(PlatformManager.MyOculusID);
				}
				else
				{
					m_playerAreas[i].SetupForPlayer<AIPlayer>("* AI *");
				}
			}
		}

		Player MatchPlayerAddedCallback(int slot, User user)
		{
			Player player = null;

			if (m_currentState == State.WAITING_TO_SETUP_MATCH && slot < m_playerAreas.Length)
			{
				if (user.ID == PlatformManager.MyID)
				{
					var localPlayer = m_playerAreas[slot].SetupForPlayer<LocalPlayer>(user.OculusID);
					MoveCameraToMatchPosition();
					player = localPlayer;
					m_localSlot = slot;
				}
				else
				{
					var remotePlayer = m_playerAreas[slot].SetupForPlayer<RemotePlayer>(user.OculusID);
					remotePlayer.User = user;
					player = remotePlayer;
				}
			}

			return player;
		}

		#endregion

		#region Main Camera Movement

		void MoveCameraToIdlePosition()
		{
			var ejector = m_camera.gameObject.GetComponentInChildren<BallEjector>();
			if (ejector)
			{
				ejector.transform.SetParent(m_camera.transform.parent, false);
				m_camera.transform.SetParent(m_idleCameraTransform, false);
			}
		}

		void MoveCameraToMatchPosition()
		{
			foreach (var playerArea in m_playerAreas)
			{
				var player = playerArea.GetComponentInChildren<LocalPlayer>();
				if (player)
				{
					var ejector = player.GetComponentInChildren<BallEjector>();
					m_camera.transform.SetParent(player.transform, false);
					ejector.transform.SetParent(m_camera.transform, false);
					break;
				}
			}
			DisplayAchievementFlytext();
		}

		#endregion

		#region Match Initiation

		public void StartPracticeMatch()
		{
			if (m_currentState == State.NONE)
			{
				TransitionToState(State.WAITING_TO_START_PRACTICE);
			}
		}

		public void PlayOnlineOrCancel()
		{
			Debug.Log ("Play online or Cancel");

			if (m_currentState == State.NONE)
			{
				PlatformManager.Matchmaking.QueueForMatch();
				TransitionToState (State.WAITING_FOR_MATCH);
			}
			else if (m_currentState == State.WAITING_FOR_MATCH)
			{
				PlatformManager.Matchmaking.LeaveQueue();
				TransitionToState (State.NONE);
			}
		}

		// notification from the Matchmaking service if we succeeded in finding an online match
		void OnMatchFoundCallback(bool success)
		{
			if (success)
			{
				TransitionToState(State.WAITING_TO_SETUP_MATCH);
			}
			else
			{
				TransitionToState(State.NONE);
			}
		}

		// handle an offer from a remote player for a new match start time
		float StartTimeOfferCallback(float remoteTime)
		{
			if (m_currentState == State.WAITING_TO_SETUP_MATCH)
			{
				// if the remote start time is later use that, as long as it's not horribly wrong
				if (remoteTime > MatchStartTime && (remoteTime - 60) < MatchStartTime)
				{
					Debug.Log("Moving Start time by " + (remoteTime - MatchStartTime));
					MatchStartTime = remoteTime;
				}
			}
			return MatchStartTime;
		}

		#endregion

		#region Leaderboards and Achievements

		void MostWinsLeaderboardCallback(SortedDictionary<int, LeaderboardEntry> entries)
		{
			foreach (Transform entry in m_mostWinsLeaderboard.transform)
			{
				Destroy(entry.gameObject);
			}
			foreach (var entry in entries.Values)
			{
				GameObject label = Instantiate(m_leaderboardEntryPrefab);
				label.transform.SetParent(m_mostWinsLeaderboard.transform, false);
				label.GetComponent<Text>().text =
					string.Format("{0} - {1} - {2}", entry.Rank, entry.User.OculusID, entry.Score);
			}
		}

		void HighestScoreLeaderboardCallback(SortedDictionary<int, LeaderboardEntry> entries)
		{
			foreach (Transform entry in m_highestScoresLeaderboard.transform)
			{
				Destroy(entry.gameObject);
			}
			foreach (var entry in entries.Values)
			{
				GameObject label = Instantiate(m_leaderboardEntryPrefab);
				label.transform.SetParent(m_highestScoresLeaderboard.transform, false);
				label.GetComponent<Text>().text =
					string.Format("{0} - {1} - {2}", entry.Rank, entry.User.OculusID, entry.Score);
			}
		}

		void CalculateMatchResults()
		{
			LocalPlayer localPlayer = null;
			RemotePlayer remotePlayer = null;

			foreach (var court in m_playerAreas)
			{
				if (court.Player is LocalPlayer)
				{
					localPlayer = court.Player as LocalPlayer;
				}
				else if (court.Player is RemotePlayer &&
					(remotePlayer == null || court.Player.Score > remotePlayer.Score))
				{
					remotePlayer = court.Player as RemotePlayer;
				}
			}

			// ignore the match results if the player got into a session without an opponent
			if (!localPlayer || !remotePlayer)
			{
				return;
			}

			bool wonMatch = localPlayer.Score > remotePlayer.Score;
			PlatformManager.Leaderboards.SubmitMatchScores(wonMatch, localPlayer.Score);

			if (wonMatch)
			{
				PlatformManager.Achievements.RecordWinForLocalUser();
			}
		}

		void DisplayAchievementFlytext()
		{
			if (PlatformManager.Achievements.LikesToWin)
			{
				GameObject go = Instantiate(m_flytext);
				go.GetComponent<Text>().text = "Likes to Win!";
				go.transform.position = Vector3.up * 40;
				go.transform.SetParent(m_playerAreas[m_localSlot].NameText.transform, false);
			}
		}

		#endregion
	}
}