using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using AppleHills.Core.Settings;
using Core;
using UnityEngine;

namespace Bootstrap
{
    /// <summary>
    /// Service that provides notification and management of boot completion status.
    /// Allows systems to subscribe to boot completion events, register initialization actions with priorities,
    /// or await boot completion asynchronously.
    /// </summary>
    public static class BootCompletionService
    {
        /// <summary>
        /// Indicates if the boot process has completed
        /// </summary>
        public static bool IsBootComplete { get; private set; } = false;
        
        /// <summary>
        /// Event triggered when boot completes
        /// </summary>
        public static event Action OnBootComplete;
        
        /// <summary>
        /// Represents an initialization action with priority
        /// </summary>
        private class InitializationAction
        {
            public Action Action { get; }
            public int Priority { get; }
            public string Name { get; }
            
            public InitializationAction(Action action, int priority, string name)
            {
                Action = action;
                Priority = priority;
                Name = name;
            }
        }
        
        // List of initialization actions to be executed once boot completes
        private static List<InitializationAction> _initializationActions = new List<InitializationAction>();
        
        // TaskCompletionSource for async await pattern
        private static TaskCompletionSource<bool> _bootCompletionTask = new TaskCompletionSource<bool>();
        
        /// <summary>
        /// Called by CustomBoot when the boot process is complete
        /// </summary>
        internal static void HandleBootCompleted()
        {
            if (IsBootComplete)
                return;
            
            IsBootComplete = true;
            
            LogDebugMessage("Boot process completed, executing initialization actions");
            
            // Execute initialization actions in priority order (lower number = higher priority)
            ExecuteInitializationActions();
            
            // Trigger the event
            OnBootComplete?.Invoke();
            
            // Complete the task for async waiters
            _bootCompletionTask.TrySetResult(true);
            
            LogDebugMessage("All boot completion handlers executed");
        }
        
        /// <summary>
        /// Register an action to be executed when boot completes.
        /// Lower priority numbers run first.
        /// </summary>
        /// <param name="action">The action to execute</param>
        /// <param name="priority">Priority (lower numbers run first)</param>
        /// <param name="name">Name for debugging</param>
        public static void RegisterInitAction(Action action, int priority = 100, string name = null)
        {
            if (action == null)
                return;
            
            if (string.IsNullOrEmpty(name))
                name = $"Action_{_initializationActions.Count}";
                
            var initAction = new InitializationAction(action, priority, name);
            
            if (IsBootComplete)
            {
                // If boot is already complete, execute immediately
                LogDebugMessage($"Executing late registration: {name} (Priority: {priority})");
                try
                {
                    action();
                }
                catch (Exception ex)
                {
                    LogDebugMessage($"Error executing init action '{name}': {ex}");
                }
            }
            else
            {
                // Otherwise add to the queue
                _initializationActions.Add(initAction);
                LogDebugMessage($"Registered init action: {name} (Priority: {priority})");
            }
        }
        
        /// <summary>
        /// Wait asynchronously for boot completion
        /// </summary>
        /// <returns>Task that completes when boot is complete</returns>
        public static Task WaitForBootCompletionAsync()
        {
            if (IsBootComplete)
                return Task.CompletedTask;
                
            return _bootCompletionTask.Task;
        }
        
        /// <summary>
        /// Execute all registered initialization actions in priority order
        /// </summary>
        private static void ExecuteInitializationActions()
        {
            // Sort by priority (lowest first)
            var sortedActions = _initializationActions
                .OrderBy(a => a.Priority)
                .ToList();
                
            foreach (var action in sortedActions)
            {
                try
                {
                    LogDebugMessage($"Executing: {action.Name} (Priority: {action.Priority})");
                    action.Action();
                }
                catch (Exception ex)
                {
                    LogDebugMessage($"Error executing init action '{action.Name}': {ex}");
                }
            }
            
            // Clear the list after execution
            _initializationActions.Clear();
        }
        
        private static void LogDebugMessage(string message)
        {
            if (DeveloperSettingsProvider.Instance.GetSettings<DebugSettings>().bootstrapLogVerbosity <=
                LogVerbosity.Debug)
            {
                Logging.Debug($"[BootCompletionService] {message}");
            }
        }
    }
}