using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using RhythmBullet.Zer01HD.Utilities.Camera;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace RhythmBullet.Zer01HD.Utilities.ScreenSystem
{
    public delegate void RequireNextScreen(Screen screen);

    public class ScreenManager : IDisposable
    {
        public event RequireNextScreen RequireNextScreenEvent;
        private GraphicsDeviceManager graphics;
        private Screen previousScreen;
        private RenderTarget2D previousScreenRenderTarget;
        private Screen currentScreen;
        private Camera2D camera;
        public Screen Screen
        {
            get
            {
                return currentScreen;
            }
            set
            {
                previousScreen = currentScreen;
                currentScreen = value;
                if (!Screen.Initiated)
                {
                    Screen.Initiate(graphics.GraphicsDevice, new Rectangle(0, 0, graphics.PreferredBackBufferWidth, graphics.PreferredBackBufferHeight), camera);
                }
                if (previousScreen != null && previousScreenRenderTarget == null && previousScreen.UseRenderTargetForExitTransition)
                {
                    previousScreenRenderTarget = new RenderTarget2D(graphics.GraphicsDevice, graphics.PreferredBackBufferWidth, graphics.PreferredBackBufferHeight);
                }
                graphics.GraphicsDevice.SetRenderTarget(previousScreenRenderTarget);
                graphics.GraphicsDevice.Clear(Color.Black);

                Debug.WriteLine("Showing " + value.GetType().Name);
                Debug.WriteLine("Previous screen is " + previousScreen?.GetType().Name);
                Screen.Show();
            }
        }

        public ScreenManager(GraphicsDeviceManager graphicsDeviceManager, Camera2D camera)
        {
            this.graphics = graphicsDeviceManager;
            this.camera = camera;
        }

        public void Update(GameTime gameTime, bool assetsDone)
        {
            switch (Screen.State)
            {
                case ScreenState.EnterTransition:
                    if (previousScreen != null && previousScreen.UseRenderTargetForExitTransition)
                    {
                        previousScreen.UpdateTransition(gameTime.ElapsedGameTime.TotalSeconds, assetsDone);
                    }
                    Screen.UpdateTransition(gameTime.ElapsedGameTime.TotalSeconds, assetsDone);
                    break;
                case ScreenState.ExitTransition:
                    if (Screen.UseRenderTargetForExitTransition || Screen.UpdateTransition(gameTime.ElapsedGameTime.TotalSeconds, assetsDone))
                    {
                        OnRequireNextScreen(Screen);
                        if (Screen.NextScreen != null)
                        {
                            Debug.WriteLine("Changing to the next given screen.");
                            Screen = Screen.NextScreen;
                        }
                        else if (previousScreen != null)
                        {
                            Debug.WriteLine("Changing to previous screen.");
                            Screen = previousScreen;
                        } else
                        {
                            throw new InvalidOperationException("No next screen provided and no previous screen to return to.");
                        }
                    }
                    break;
                case ScreenState.Normal:
                    Screen.Update(gameTime);
                    break;
            }
        }

        public void Draw(SpriteBatch spriteBatch)
        {
            graphics.GraphicsDevice.Clear(Screen.BackgroundColor);
            if (Screen.State == ScreenState.EnterTransition && previousScreen != null && previousScreen.UseRenderTargetForExitTransition)
            {
                graphics.GraphicsDevice.SetRenderTarget(previousScreenRenderTarget);
                graphics.GraphicsDevice.Clear(previousScreen.BackgroundColor);
                spriteBatch.Begin(SpriteSortMode.Deferred, null, null, null, null, null, camera.TransformMatrix);
                previousScreen.Draw(spriteBatch);
                spriteBatch.End();
                graphics.GraphicsDevice.SetRenderTarget(null);
                Screen.UpdatePreviousScreenFrame(previousScreenRenderTarget);
            }
            spriteBatch.Begin(SpriteSortMode.Deferred, null, null, null, null, null, camera.TransformMatrix);
            Screen.Draw(spriteBatch);
            spriteBatch.End();
        }

        public void Resize(Texture2D loadingScreenSymbol)
        {
            Screen.AssetLoadStateChange(true);
            Screen = new LoadingScreen(loadingScreenSymbol, 0.3f, true);
            previousScreenRenderTarget.Dispose();
            previousScreenRenderTarget = null;
        }

        public void PostResize()
        {
            Screen.AssetLoadStateChange(false);
        }

        public void OnRequireNextScreen(Screen screen)
        {
            RequireNextScreenEvent?.Invoke(screen);
        }

        public void Dispose()
        {
            previousScreenRenderTarget?.Dispose();
        }
    }
}