using Ghost.Editor.AppStates;
using Ghost.Editor.Helpers;
using Ghost.Editor.Services;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.UI.Xaml;
using System;

// To learn more about WinUI, the WinUI project structure,
// and more about our project templates, see: http://aka.ms/winui-project-info.

namespace Ghost.Editor
{
    /// <summary>
    /// Provides application-specific behavior to supplement the default Application class.
    /// </summary>
    public partial class App : Application
    {
        private Window? _window;

        internal static Window? Window
        {
            get => (Current as App)?._window;
            set
            {
                if (Current is App app)
                {
                    app._window = value;
                }
            }
        }

        internal IHost Host
        {
            get;
        }

        /// <summary>
        /// Initializes the singleton application object.  This is the first line of authored code
        /// executed, and as such is the logical equivalent of main() or WinMain().
        /// </summary>
        internal App()
        {
            InitializeComponent();

            Host = Microsoft.Extensions.Hosting.Host.
                CreateDefaultBuilder().
                UseContentRoot(AppContext.BaseDirectory).
                ConfigureServices((context, services) =>
                {
                    services.AddSingleton(sp =>
                    {
                        return new AppStateService(
                            new LandingState(),
                            new EditorState());
                    });

                    HostHelper.AddLandingScope(context, services);
                    HostHelper.AddEngineScope(context, services);

                    services.AddSingleton<StackedNotificationService>();
                })
                .Build();

            UnhandledException += App_UnhandledException;
        }

        internal static IServiceScope CreateScope()
        {
            return (Current as App)!.Host.Services.CreateScope();
        }

        public static T GetService<T>() where T : class
        {
            if ((Current as App)!.Host.Services.GetService(typeof(T)) is not T service)
            {
                throw new ArgumentException($"{typeof(T)} needs to be registered in ConfigureServices within App.xaml.cs.");
            }

            return service;
        }

        /// <summary>
        /// Invoked when the application is launched.
        /// </summary>
        /// <param name="args">Details about the launch request and process.</param>
        protected override async void OnLaunched(LaunchActivatedEventArgs args)
        {
            base.OnLaunched(args);

            ActivationHandler.Handle(args);

            Host.Start();

            await GetService<AppStateService>().TransitionToAsync(StateKey.Landing);
        }

        private void App_UnhandledException(object sender, Microsoft.UI.Xaml.UnhandledExceptionEventArgs e)
        {
            // TODO: Log and handle exceptions as appropriate.
            // https://docs.microsoft.com/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.application.unhandledexception.
        }
    }
}