using Noesis;
using System;
using System.Collections.Generic;
using UnityEngine;
using Grid = Noesis.Grid;
using GUI = Noesis.GUI;
using NoesisEventArgs = Noesis.EventArgs;

namespace StellarConquest.Presentation.Unity.UI
{
    public partial class UIStateMachine : UserControl
    {
        public static UIStateMachine Instance;
        public GameScreen GameScreen { get; private set; }
        public Grid BaseLayer { get; private set; }
        public OverlayLayer OverlayLayer { get; private set; }
        public TransitionControl TransitionLayer { get; private set; }
        public IGameScreenInputProvider CurrentScreen { get; private set; }
        public NoesisView NoesisView { get; private set; }
        public Camera Camera { get; private set; }

        private FrameworkElement _Root;
        private Rectangle _ConnectionRectangle;
        private Grid _SplashScreen;
        private bool _SplashShown = false;

        private List<IGameScreenInputProvider> _InputProviders = new List<IGameScreenInputProvider>();
       
        public UIStateMachine()
        {
            if (!Application.isPlaying)
                return;

            Initialized += OnInitialized;
            InitializeComponent();
        }

        private void InitializeComponent()
        {
            Instance = this;

            GUI.LoadComponent(this, "Assets/User Interface/UIStateMachine.xaml");
            _Root = Content as FrameworkElement;
            BaseLayer = _Root.FindName("_BaseLayer") as Grid;
            _ConnectionRectangle = _Root.FindName("_ConnectionRectangle") as Rectangle;
            _SplashScreen = _Root.FindName("_SplashScreen") as Grid;

            TransitionLayer = _Root.FindName("_TransitionLayer") as TransitionControl;
            OverlayLayer = _Root.FindName("_OverlayLayer") as OverlayLayer;
            NoesisView = GameState.Instance.UserInterfaceGameObject.GetComponentInChildren<NoesisView>();
            Camera = GameState.Instance.UserInterfaceGameObject.GetComponentInChildren<Camera>();
        }

        private void OnInitialized(object sender, NoesisEventArgs args)
        {
        }

        public void ShowTitleScreen(bool fadePrevious = false)
        {
            _InputProviders.Clear();

            SetConnectionIssue(false);
            TransitionLayer.CutToTransparent();

            if (BaseLayer.Children.Count > 0 && BaseLayer.Children[0] is LoginScreen)
                return;

            if (!fadePrevious)
                BaseLayer.Children.Clear();

            if (!_SplashShown)
            {
                _SplashShown = true;

                LoginScreen loginScreen = new LoginScreen();
                loginScreen.Opacity = 0;

                CurrentScreen = loginScreen;
                BaseLayer.Children.Add(loginScreen);

                float splashScreenDuration = 1.5f;
                if (RuntimeSettings.Instance.IsDemoMode)
                    splashScreenDuration = 5.0f;

                UnityDispatcher.Instance.Invoke(TimeSpan.FromSeconds(splashScreenDuration), () =>
                {
                    Soundtrack.Instance.Play(ScoreType.Login, true);
                    _SplashScreen.FadeOut(this, TimeSpan.FromSeconds(3), () =>
                    {
                        _SplashScreen.Children.Clear(); // clear memory
                        loginScreen.Opacity = 1;
                        loginScreen.FadeIn(this, TimeSpan.FromMilliseconds(700));
                    });
                });
            }
            else
            {
                ScreenTransition(() =>
                {
                    Soundtrack.Instance.Play(ScoreType.Login, true);

                    LoginScreen loginScreen = new LoginScreen();
                    loginScreen.Opacity = 1;

                    CurrentScreen = loginScreen;
                    BaseLayer.Children.Add(loginScreen);

                    loginScreen.FadeIn(this, TimeSpan.FromMilliseconds(700));
                });
            }
        }

        public void ShowCharacterSelectionScreen()
        {
            TransitionLayer.CutToTransparent();

            if (BaseLayer.Children.Count > 0 && BaseLayer.Children[0] is CharacterSelectionScreen)
                return;

            ScreenTransition(() =>
            {
                CharacterSelectionScreen characterSelectionScreen = new CharacterSelectionScreen();
                CurrentScreen = characterSelectionScreen;
                characterSelectionScreen.SetPlayers(SessionState.Instance.AuthenticatedPlayers);
                BaseLayer.Children.Add(characterSelectionScreen);
            });

        }

        public void ShowCharacterCreationScreen()
        {
            TransitionLayer.CutToTransparent();

            if (BaseLayer.Children.Count > 0 && BaseLayer.Children[0] is CharacterCreationScreen)
                return;

            ScreenTransition(() =>
            {
                CharacterCreationScreen characterCreationScreen = new CharacterCreationScreen();
                CurrentScreen = characterCreationScreen;
                BaseLayer.Children.Add(characterCreationScreen);
            });
        }

        public void LoadGameScreen()
        {
            if (BaseLayer.Children.Count > 0 && BaseLayer.Children[0] is CharacterCreationScreen)
                return;

            GameScreen = new GameScreen();
            CurrentScreen = GameScreen;
            GameScreen.Visibility = Visibility.Collapsed;
            BaseLayer.Children.Add(GameScreen);
        }

        public void ShowGameScreen()
        {
            TransitionLayer.FadeFromBlack();
            GameScreen.Visibility = Visibility.Visible;
            GameScreen.FadeIn(this, FrameworkElementExtensionMethods.ScreenSlowFadeTime);
            Soundtrack.Instance.StaticAudioListener.enabled = false;
            Soundtrack.Instance.PlayContextual(SessionState.Instance.Player, SessionState.Instance.StarSystem);
        }

        /// <summary>
        /// Fades out the previous screen, if one exists.
        /// </summary>
        /// <param name="createScreenAction"></param>
        public void ScreenTransition(Action createScreenAction, Action completed = null)
        {
            ScreenTransition(FrameworkElementExtensionMethods.ScreenSlowFadeTime, FrameworkElementExtensionMethods.ScreenFastFadeTime, createScreenAction, completed);
        }

        public void ScreenTransition(TimeSpan fadeInDuration, TimeSpan fadeOutDuration, Action createScreenAction, Action completed = null)
        {
            FrameworkElement screen;

            if (BaseLayer.Children.Count == 0) // no existing screen
            {
                if (createScreenAction != null)
                    createScreenAction.Invoke(); // create screen
                screen = BaseLayer.Children[0] as FrameworkElement;
                screen.FadeIn(this, fadeInDuration, completed);
            }
            else // screen exists
            {
                screen = BaseLayer.Children[0] as FrameworkElement;
                screen.FadeOut(this, fadeOutDuration, new Action(() =>
                {
                    BaseLayer.Children.Clear();
                    if (createScreenAction != null)
                        createScreenAction.Invoke(); // create screen
                    if (BaseLayer.Children.Count > 0)
                    {
                        screen = BaseLayer.Children[0] as FrameworkElement;
                        screen.FadeIn(this, fadeInDuration, completed);
                    }
                }));
            }
        }

        public bool CursorVisible
        {
            get
            {
                return UnityEngine.Cursor.visible && UnityEngine.Cursor.lockState == CursorLockMode.None;
            }
            set
            {
                if (!Input.mousePresent)
                    return;

                if (value)
                {
                    if (!UnityEngine.Cursor.visible)
                        UpdateCursor(CursorType.Arrow);
                    UnityEngine.Cursor.visible = true;
                    UnityEngine.Cursor.lockState = CursorLockMode.None;  
                }
                else
                {
                    UnityEngine.Cursor.lockState = CursorLockMode.Locked;
                    UnityEngine.Cursor.visible = false;
                }
            }
        }

        public void SetConnectionIssue(bool value)
        {
            if (value)
            {
                _ConnectionRectangle.Visibility = Visibility.Visible;
                _ConnectionRectangle.FadeIn(this, TimeSpan.FromSeconds(1));
            }
            else
                _ConnectionRectangle.FadeOutScreen(this, () => _ConnectionRectangle.Visibility = Visibility.Collapsed);
        }

        public void AddInputProvider(IGameScreenInputProvider inputProvider)
        {
            if (!_InputProviders.Contains(inputProvider))
                _InputProviders.Add(inputProvider);
        }

        public void RemoveInputProvider(IGameScreenInputProvider inputProvider)
        {
            _InputProviders.Remove(inputProvider);
        }

        public void UpdateInput()
        {
            // show logo transition screen
            if (RuntimeSettings.Instance.DeveloperMode)
                if (Input.GetKeyDown(KeyCode.ScrollLock))
                {
                    if (!TransitionLayer.Opaque)
                    {
                        TransitionLayer.LogoImageEnabled = true;
                        TransitionLayer.LoadingImageEnabled = false;
                        TransitionLayer.FadeToBlack(TimeSpan.FromSeconds(1.5f));
                    }
                    else
                    {
                        TransitionLayer.LogoImageEnabled = true;
                        TransitionLayer.LoadingImageEnabled = false;
                        TransitionLayer.FadeFromBlack(TimeSpan.FromSeconds(0.5f));
                    }
                }

            // update screeen UI
            if (CurrentScreen != null && !OverlayLayer.IsOverlayActive)
                CurrentScreen.UpdateInput();

            // update overlay UI
            for (int i = 0; i < _InputProviders.Count; i++)
                _InputProviders[i].UpdateInput();
        }

        public void SetBlur(bool? isUIBlurEnabled, bool? isCameraBlurEnabled)
        {
            if (isUIBlurEnabled.HasValue)
            {
                if (isUIBlurEnabled.Value)
                    BaseLayer.Blur(this, 25, TimeSpan.FromMilliseconds(200));
                else
                    BaseLayer.Unblur(this, TimeSpan.FromMilliseconds(200));
            }

            if (isCameraBlurEnabled.HasValue)
                PostProcessingManager.Instance.SetBlur(isCameraBlurEnabled.Value, TimeSpan.FromMilliseconds(200));
        }

        public static void UpdateCursor(CursorType cursor)
        {
            NoesisSettings settings = NoesisSettings.Get();

            switch (cursor)
            {
                case CursorType.AppStarting:
                    UnityEngine.Cursor.SetCursor(settings.AppStarting.Texture, settings.AppStarting.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.Arrow:
                    UnityEngine.Cursor.SetCursor(settings.Arrow.Texture, settings.Arrow.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.ArrowCD:
                    UnityEngine.Cursor.SetCursor(settings.ArrowCD.Texture, settings.ArrowCD.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.Cross:
                    UnityEngine.Cursor.SetCursor(settings.Cross.Texture, settings.Cross.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.Hand:
                    UnityEngine.Cursor.SetCursor(settings.Hand.Texture, settings.Hand.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.Help:
                    UnityEngine.Cursor.SetCursor(settings.Help.Texture, settings.Help.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.IBeam:
                    UnityEngine.Cursor.SetCursor(settings.IBeam.Texture, settings.IBeam.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.No:
                    UnityEngine.Cursor.SetCursor(settings.No.Texture, settings.No.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.None:
                    UnityEngine.Cursor.SetCursor(settings.None.Texture, settings.None.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.Pen:
                    UnityEngine.Cursor.SetCursor(settings.Pen.Texture, settings.Pen.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.ScrollAll:
                    UnityEngine.Cursor.SetCursor(settings.ScrollAll.Texture, settings.ScrollAll.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.ScrollE:
                    UnityEngine.Cursor.SetCursor(settings.ScrollE.Texture, settings.ScrollE.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.ScrollN:
                    UnityEngine.Cursor.SetCursor(settings.ScrollN.Texture, settings.ScrollN.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.ScrollNE:
                    UnityEngine.Cursor.SetCursor(settings.ScrollNE.Texture, settings.ScrollNE.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.ScrollNS:
                    UnityEngine.Cursor.SetCursor(settings.ScrollNS.Texture, settings.ScrollNS.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.ScrollNW:
                    UnityEngine.Cursor.SetCursor(settings.ScrollNW.Texture, settings.ScrollNW.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.ScrollS:
                    UnityEngine.Cursor.SetCursor(settings.ScrollS.Texture, settings.ScrollS.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.ScrollSE:
                    UnityEngine.Cursor.SetCursor(settings.ScrollSE.Texture, settings.ScrollSE.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.ScrollSW:
                    UnityEngine.Cursor.SetCursor(settings.ScrollSW.Texture, settings.ScrollSW.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.ScrollW:
                    UnityEngine.Cursor.SetCursor(settings.ScrollW.Texture, settings.ScrollW.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.ScrollWE:
                    UnityEngine.Cursor.SetCursor(settings.ScrollWE.Texture, settings.ScrollWE.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.SizeAll:
                    UnityEngine.Cursor.SetCursor(settings.SizeAll.Texture, settings.SizeAll.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.SizeNESW:
                    UnityEngine.Cursor.SetCursor(settings.SizeNESW.Texture, settings.SizeNESW.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.SizeNS:
                    UnityEngine.Cursor.SetCursor(settings.SizeNS.Texture, settings.SizeNS.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.SizeNWSE:
                    UnityEngine.Cursor.SetCursor(settings.SizeNWSE.Texture, settings.SizeNWSE.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.SizeWE:
                    UnityEngine.Cursor.SetCursor(settings.SizeWE.Texture, settings.SizeWE.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.UpArrow:
                    UnityEngine.Cursor.SetCursor(settings.UpArrow.Texture, settings.UpArrow.HotSpot, CursorMode.Auto);
                    break;
                case CursorType.Wait:
                    UnityEngine.Cursor.SetCursor(settings.Wait.Texture, settings.Wait.HotSpot, CursorMode.Auto);
                    break;
            }
        }
    }
}