using Godot;

namespace GameFramework.Core.Pooling
{
    /// <summary>
    /// 可池化对象接口
    /// 实现此接口的类可以被对象池管理
    /// </summary>
    public interface IPoolable
    {
        /// <summary>
        /// 当对象从池中取出时调用
        /// 用于初始化对象状态
        /// </summary>
        void OnSpawn();

        /// <summary>
        /// 当对象返回池中或销毁时调用
        /// 用于清理对象状态
        /// </summary>
        void OnDespawn();

        /// <summary>
        /// 对象是否可用
        /// </summary>
        bool IsAvailable { get; set; }
    }
}

using System;
using System.Collections.Generic;
using Godot;

namespace GameFramework.Core.Pooling
{
    /// <summary>
    /// 泛型对象池
    /// 用于高效管理可复用对象的创建和回收
    /// </summary>
    /// <typeparam name="T">对象类型，必须实现 IPoolable 和 new()</typeparam>
    public class ObjectPool<T> where T : class, IPoolable, new()
    {
        // 可用对象队列
        private readonly Queue<T> _availableObjects;

        // 所有对象的集合（用于追踪）
        private readonly List<T> _allObjects;

        // 池配置
        private readonly int _initialCapacity;
        private readonly int _maxCapacity;
        private readonly bool _allowExpansion;

        // 统计信息
        public int TotalCount => _allObjects.Count;
        public int AvailableCount => _availableObjects.Count;
        public int InUseCount => _allObjects.Count - _availableObjects.Count;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="initialCapacity">初始容量</param>
        /// <param name="maxCapacity">最大容量，0表示无限制</param>
        /// <param name="prewarm">是否预创建对象</param>
        public ObjectPool(int initialCapacity = 10, int maxCapacity = 100, bool prewarm = false)
        {
            _initialCapacity = initialCapacity;
            _maxCapacity = maxCapacity;
            _allowExpansion = maxCapacity <= 0;

            _availableObjects = new Queue<T>(initialCapacity);
            _allObjects = new List<T>(initialCapacity);

            if (prewarm)
            {
                Prewarm(initialCapacity);
            }
        }

        /// <summary>
        /// 预创建指定数量的对象
        /// </summary>
        public void Prewarm(int count)
        {
            int targetCount = Math.Min(count, _maxCapacity > 0 ? _maxCapacity : int.MaxValue);

            for (int i = _allObjects.Count; i < targetCount; i++)
            {
                T obj = CreateNewObject();
                obj.IsAvailable = true;
                _availableObjects.Enqueue(obj);
            }
        }

        /// <summary>
        /// 从池中获取对象
        /// </summary>
        public T Get()
        {
            T obj;

            if (_availableObjects.Count > 0)
            {
                // 从队列中取出可用对象
                obj = _availableObjects.Dequeue();
            }
            else if (_allowExpansion || _allObjects.Count < _maxCapacity)
            {
                // 创建新对象
                obj = CreateNewObject();
            }
            else
            {
                // 池已满，返回null或抛出异常
                GD.PushWarning($"对象池已达到最大容量: {_maxCapacity}");
                return null;
            }

            obj.IsAvailable = false;
            obj.OnSpawn();

            return obj;
        }

        /// <summary>
        /// 将对象返回池中
        /// </summary>
        public void Return(T obj)
        {
            if (obj == null)
            {
                GD.PushWarning("尝试将null对象返回池中");
                return;
            }

            if (obj.IsAvailable)
            {
                // 对象已经在池中
                return;
            }

            obj.OnDespawn();
            obj.IsAvailable = true;
            _availableObjects.Enqueue(obj);
        }

        /// <summary>
        /// 创建新对象
        /// </summary>
        private T CreateNewObject()
        {
            T obj = new T();
            _allObjects.Add(obj);
            return obj;
        }

        /// <summary>
        /// 清空对象池
        /// </summary>
        /// <param name="disposeObjects">是否调用对象的清理方法</param>
        public void Clear(bool disposeObjects = true)
        {
            if (disposeObjects)
            {
                foreach (var obj in _allObjects)
                {
                    if (!obj.IsAvailable)
                    {
                        obj.OnDespawn();
                    }
                }
            }

            _availableObjects.Clear();
            _allObjects.Clear();
        }

        /// <summary>
        /// 调整池容量
        /// </summary>
        public void Trim(int targetCapacity)
        {
            while (_availableObjects.Count > targetCapacity)
            {
                T obj = _availableObjects.Dequeue();
                _allObjects.Remove(obj);
            }
        }
    }
}

using System.Collections.Generic;
using Godot;

namespace GameFramework.Core.Pooling
{
    /// <summary>
    /// Godot 节点对象池
    /// 专门用于管理 Godot 节点的创建和回收
    /// </summary>
    public class NodeObjectPool<T> where T : Node, IPoolable
    {
        private readonly PackedScene _prefab;
        private readonly Node _parent;
        private readonly Queue<T> _availableObjects;
        private readonly List<T> _allObjects;

        private readonly int _maxCapacity;
        private readonly bool _allowExpansion;

        public int TotalCount => _allObjects.Count;
        public int AvailableCount => _availableObjects.Count;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="prefab">节点预制体</param>
        /// <param name="parent">父节点（用于存放未激活的池对象）</param>
        /// <param name="maxCapacity">最大容量</param>
        public NodeObjectPool(PackedScene prefab, Node parent, int maxCapacity = 100)
        {
            _prefab = prefab;
            _parent = parent;
            _maxCapacity = maxCapacity;
            _allowExpansion = maxCapacity <= 0;

            _availableObjects = new Queue<T>();
            _allObjects = new List<T>();
        }

        /// <summary>
        /// 从池中获取节点
        /// </summary>
        public T Get(Node newParent = null)
        {
            T node;

            if (_availableObjects.Count > 0)
            {
                node = _availableObjects.Dequeue();
            }
            else if (_allowExpansion || _allObjects.Count < _maxCapacity)
            {
                node = _prefab.Instantiate<T>();
                _allObjects.Add(node);
            }
            else
            {
                GD.PushWarning($"节点对象池已满: {_maxCapacity}");
                return null;
            }

            // 设置父节点
            if (newParent != null)
            {
                newParent.AddChild(node);
            }
            else
            {
                _parent.AddChild(node);
            }

            node.IsAvailable = false;
            node.OnSpawn();

            return node;
        }

        /// <summary>
        /// 将节点返回池中
        /// </summary>
        public void Return(T node)
        {
            if (node == null || node.IsAvailable)
            {
                return;
            }

            node.OnDespawn();
            node.IsAvailable = true;

            // 从当前父节点移除
            Node currentParent = node.GetParent();
            if (currentParent != null)
            {
                currentParent.RemoveChild(node);
            }

            // 放回池父节点下（隐藏）
            _parent.AddChild(node);

            _availableObjects.Enqueue(node);
        }

        /// <summary>
        /// 清空对象池
        /// </summary>
        public void Clear()
        {
            foreach (var node in _allObjects)
            {
                if (node.IsInsideTree())
                {
                    node.GetParent()?.RemoveChild(node);
                }
                node.QueueFree();
            }

            _availableObjects.Clear();
            _allObjects.Clear();
        }
    }
}

// 错误示例
public void OnSpawn()
{
    // 忘记重置速度和生命值！
    Show();
}

// 正确示例
public void OnSpawn()
{
    // 重置所有状态
    _velocity = Vector2.Zero;
    _health = MaxHealth;
    _lifetime = MaxLifetime;
    Show();
    SetProcess(true);
}

// 添加监控字段
public float UsageRate => TotalCount > 0 ? (float)InUseCount / TotalCount : 0;
public bool IsStarved => AvailableCount == 0;

// 定期输出统计
public void LogStats()
{
    GD.Print($"[ObjectPool] 总数: {TotalCount}, 可用: {AvailableCount}, " +
             $"使用中: {InUseCount}, 使用率: {UsageRate:P1}");
}

using Godot;
using GameFramework.Core.Pooling;

namespace GameFramework.Examples
{
    /// <summary>
    /// 子弹类 - 可池化对象示例
    /// </summary>
    public partial class Bullet : Node2D, IPoolable
    {
        [Export] public float Speed = 500f;
        [Export] public float Damage = 10f;
        [Export] public float LifeTime = 3f;

        private Vector2 _velocity;
        private float _lifeTimer;

        public bool IsAvailable { get; set; } = true;

        public void OnSpawn()
        {
            // 重置状态
            _lifeTimer = LifeTime;
            Show();
            SetProcess(true);
        }

        public void OnDespawn()
        {
            // 清理状态
            Hide();
            SetProcess(false);
            _velocity = Vector2.Zero;
        }

        public void Fire(Vector2 position, Vector2 direction)
        {
            GlobalPosition = position;
            _velocity = direction.Normalized() * Speed;
            Rotation = direction.Angle();
        }

        public override void _Process(double delta)
        {
            _lifeTimer -= (float)delta;
            if (_lifeTimer <= 0)
            {
                // 生命周期结束，返回池中
                BulletPool.Instance.Return(this);
                return;
            }

            Position += _velocity * (float)delta;
        }
    }

    /// <summary>
    /// 子弹池管理器（单例）
    /// </summary>
    public class BulletPool
    {
        private static BulletPool _instance;
        public static BulletPool Instance => _instance ??= new BulletPool();

        private NodeObjectPool<Bullet> _pool;

        public void Initialize(PackedScene bulletPrefab, Node parent, int initialCapacity = 50)
        {
            _pool = new NodeObjectPool<Bullet>(bulletPrefab, parent, 200);
            // 预创建一些子弹
            for (int i = 0; i < initialCapacity; i++)
            {
                var bullet = _pool.Get();
                _pool.Return(bullet);
            }
        }

        public Bullet Get() => _pool.Get();
        public void Return(Bullet bullet) => _pool.Return(bullet);
    }
}

using Godot;

namespace GameFramework.Core.Factory
{
    /// <summary>
    /// 工厂接口
    /// </summary>
    /// <typeparam name="T">创建的对象类型</typeparam>
    public interface IFactory<T> where T : class
    {
        /// <summary>
        /// 创建对象
        /// </summary>
        /// <returns>创建的对象实例</returns>
        T Create();

        /// <summary>
        /// 使用参数创建对象
        /// </summary>
        T Create(params object[] args);
    }
}

using System;
using Godot;

namespace GameFramework.Core.Factory
{
    /// <summary>
    /// 泛型工厂基类
    /// </summary>
    public abstract class Factory<T> : IFactory<T> where T : class
    {
        /// <summary>
        /// 创建对象前的验证
        /// </summary>
        protected virtual bool ValidateCreation()
        {
            return true;
        }

        /// <summary>
        /// 实际的创建逻辑（子类实现）
        /// </summary>
        protected abstract T CreateInstance();

        /// <summary>
        /// 带参数的实际创建逻辑（子类实现）
        /// </summary>
        protected abstract T CreateInstance(params object[] args);

        /// <summary>
        /// 创建后的处理
        /// </summary>
        protected virtual void PostCreate(T instance)
        {
            // 子类可重写进行初始化
        }

        public T Create()
        {
            if (!ValidateCreation())
            {
                GD.PushError("工厂创建验证失败");
                return null;
            }

            T instance = CreateInstance();
            PostCreate(instance);
            return instance;
        }

        public T Create(params object[] args)
        {
            if (!ValidateCreation())
            {
                GD.PushError("工厂创建验证失败");
                return null;
            }

            T instance = CreateInstance(args);
            PostCreate(instance);
            return instance;
        }
    }

    /// <summary>
    /// 简单工厂 - 使用委托创建对象
    /// </summary>
    public class SimpleFactory<T> : Factory<T> where T : class
    {
        private readonly Func<T> _creationFunc;
        private readonly Func<object[], T> _creationFuncWithArgs;

        public SimpleFactory(Func<T> creationFunc)
        {
            _creationFunc = creationFunc;
        }

        public SimpleFactory(Func<object[], T> creationFuncWithArgs)
        {
            _creationFuncWithArgs = creationFuncWithArgs;
        }

        protected override T CreateInstance()
        {
            return _creationFunc?.Invoke() ?? throw new InvalidOperationException("创建函数未设置");
        }

        protected override T CreateInstance(params object[] args)
        {
            return _creationFuncWithArgs?.Invoke(args) ?? throw new InvalidOperationException("带参数创建函数未设置");
        }
    }
}

using Godot;

namespace GameFramework.Core.Factory
{
    /// <summary>
    /// Godot 预制体工厂
    /// 用于从 PackedScene 创建节点实例
    /// </summary>
    public class PrefabFactory<T> : Factory<T> where T : Node
    {
        private readonly PackedScene _prefab;
        private readonly Node _defaultParent;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="prefabPath">预制体资源路径</param>
        /// <param name="defaultParent">默认父节点</param>
        public PrefabFactory(string prefabPath, Node defaultParent = null)
        {
            _prefab = GD.Load<PackedScene>(prefabPath);
            _defaultParent = defaultParent;

            if (_prefab == null)
            {
                GD.PushError($"无法加载预制体: {prefabPath}");
            }
        }

        /// <summary>
        /// 使用已加载的预制体
        /// </summary>
        public PrefabFactory(PackedScene prefab, Node defaultParent = null)
        {
            _prefab = prefab;
            _defaultParent = defaultParent;
        }

        protected override bool ValidateCreation()
        {
            return _prefab != null;
        }

        protected override T CreateInstance()
        {
            T instance = _prefab.Instantiate<T>();

            if (_defaultParent != null && instance != null)
            {
                _defaultParent.AddChild(instance);
            }

            return instance;
        }

        protected override T CreateInstance(params object[] args)
        {
            T instance = _prefab.Instantiate<T>();

            if (args.Length > 0 && args[0] is Node parent)
            {
                parent.AddChild(instance);
            }
            else if (_defaultParent != null)
            {
                _defaultParent.AddChild(instance);
            }

            // 应用额外参数
            if (args.Length > 1 && instance is IFactoryInitializable initializable)
            {
                initializable.Initialize(args[1..]);
            }

            return instance;
        }
    }

    /// <summary>
    /// 可工厂初始化接口
    /// </summary>
    public interface IFactoryInitializable
    {
        void Initialize(object[] args);
    }
}

using System;
using System.Collections.Generic;
using Godot;

namespace GameFramework.Core.Factory
{
    /// <summary>
    /// 工厂注册表
    /// 集中管理所有工厂实例
    /// </summary>
    public class FactoryRegistry
    {
        private static FactoryRegistry _instance;
        public static FactoryRegistry Instance => _instance ??= new FactoryRegistry();

        private readonly Dictionary<Type, object> _factories = new();

        /// <summary>
        /// 注册工厂
        /// </summary>
        public void Register<T>(IFactory<T> factory) where T : class
        {
            _factories[typeof(T)] = factory;
        }

        /// <summary>
        /// 获取工厂
        /// </summary>
        public IFactory<T> GetFactory<T>() where T : class
        {
            if (_factories.TryGetValue(typeof(T), out var factory))
            {
                return factory as IFactory<T>;
            }

            GD.PushError($"未找到类型 {typeof(T).Name} 的工厂");
            return null;
        }

        /// <summary>
        /// 创建对象（便捷方法）
        /// </summary>
        public T Create<T>() where T : class
        {
            var factory = GetFactory<T>();
            return factory?.Create();
        }

        /// <summary>
        /// 创建对象（带参数）
        /// </summary>
        public T Create<T>(params object[] args) where T : class
        {
            var factory = GetFactory<T>();
            return factory?.Create(args);
        }

        /// <summary>
        /// 注销工厂
        /// </summary>
        public void Unregister<T>() where T : class
        {
            _factories.Remove(typeof(T));
        }

        /// <summary>
        /// 清空所有工厂
        /// </summary>
        public void Clear()
        {
            _factories.Clear();
        }
    }
}

using System;
using System.Collections.Generic;
using Godot;

namespace GameFramework.Core.ServiceLocator
{
    /// <summary>
    /// 服务定位器
    /// 管理应用程序中的全局服务
    /// </summary>
    public static class ServiceLocator
    {
        // 已注册的服务实例
        private static readonly Dictionary<Type, object> _services = new();

        // 延迟加载的服务工厂
        private static readonly Dictionary<Type, Func<object>> _serviceFactories = new();

        // 服务初始化状态
        private static readonly Dictionary<Type, bool> _initialized = new();

        /// <summary>
        /// 注册服务实例
        /// </summary>
        public static void Register<T>(T service) where T : class
        {
            Type type = typeof(T);

            if (_services.ContainsKey(type))
            {
                GD.PushWarning($"服务 {type.Name} 已注册，将被覆盖");
            }

            _services[type] = service;
            _initialized[type] = true;
        }

        /// <summary>
        /// 注册延迟加载服务
        /// </summary>
        public static void RegisterLazy<T>(Func<T> factory) where T : class
        {
            Type type = typeof(T);
            _serviceFactories[type] = factory;
            _initialized[type] = false;
        }

        /// <summary>
        /// 获取服务
        /// </summary>
        public static T Get<T>() where T : class
        {
            Type type = typeof(T);

            // 直接返回已实例化的服务
            if (_services.TryGetValue(type, out var service))
            {
                return service as T;
            }

            // 延迟加载
            if (_serviceFactories.TryGetValue(type, out var factory))
            {
                T instance = factory() as T;
                _services[type] = instance;
                _initialized[type] = true;
                return instance;
            }

            GD.PushError($"服务 {type.Name} 未注册");
            return null;
        }

        /// <summary>
        /// 尝试获取服务
        /// </summary>
        public static bool TryGet<T>(out T service) where T : class
        {
            service = Get<T>();
            return service != null;
        }

        /// <summary>
        /// 检查服务是否已注册
        /// </summary>
        public static bool IsRegistered<T>() where T : class
        {
            Type type = typeof(T);
            return _services.ContainsKey(type) || _serviceFactories.ContainsKey(type);
        }

        /// <summary>
        /// 检查服务是否已初始化
        /// </summary>
        public static bool IsInitialized<T>() where T : class
        {
            return _initialized.TryGetValue(typeof(T), out bool init) && init;
        }

        /// <summary>
        /// 注销服务
        /// </summary>
        public static void Unregister<T>() where T : class
        {
            Type type = typeof(T);

            if (_services.ContainsKey(type))
            {
                // 如果服务实现了 IDisposable，调用 Dispose
                if (_services[type] is IDisposable disposable)
                {
                    disposable.Dispose();
                }

                _services.Remove(type);
            }

            _serviceFactories.Remove(type);
            _initialized.Remove(type);
        }

        /// <summary>
        /// 清空所有服务
        /// </summary>
        public static void Clear()
        {
            // 清理所有可释放的服务
            foreach (var service in _services.Values)
            {
                if (service is IDisposable disposable)
                {
                    disposable.Dispose();
                }
            }

            _services.Clear();
            _serviceFactories.Clear();
            _initialized.Clear();
        }

        /// <summary>
        /// 获取所有已注册的服务类型
        /// </summary>
        public static IEnumerable<Type> GetRegisteredTypes()
        {
            var types = new HashSet<Type>(_services.Keys);
            types.UnionWith(_serviceFactories.Keys);
            return types;
        }
    }
}

namespace GameFramework.Core.ServiceLocator
{
    /// <summary>
    /// 服务接口标记
    /// 所有服务应实现此接口
    /// </summary>
    public interface IService
    {
        /// <summary>
        /// 服务是否已初始化
        /// </summary>
        bool IsInitialized { get; }

        /// <summary>
        /// 初始化服务
        /// </summary>
        void Initialize();

        /// <summary>
        /// 关闭服务
        /// </summary>
        void Shutdown();
    }

    /// <summary>
    /// 可更新服务接口
    /// </summary>
    public interface IUpdatableService : IService
    {
        /// <summary>
        /// 每帧更新
        /// </summary>
        void Update(double deltaTime);
    }

    /// <summary>
    /// 优先级服务接口
    /// 用于确定服务初始化顺序
    /// </summary>
    public interface IPrioritizedService : IService
    {
        /// <summary>
        /// 优先级（越小越优先）
        /// </summary>
        int Priority { get; }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using Godot;

namespace GameFramework.Core.ServiceLocator
{
    /// <summary>
    /// 服务管理器
    /// 管理服务的生命周期和更新
    /// </summary>
    public partial class ServiceManager : Node
    {
        // 服务更新节点
        private class ServiceUpdater : Node
        {
            private readonly List<IUpdatableService> _updatableServices = new();

            public void AddService(IUpdatableService service)
            {
                _updatableServices.Add(service);
            }

            public void RemoveService(IUpdatableService service)
            {
                _updatableServices.Remove(service);
            }

            public override void _Process(double delta)
            {
                foreach (var service in _updatableServices)
                {
                    if (service.IsInitialized)
                    {
                        service.Update(delta);
                    }
                }
            }
        }

        private ServiceUpdater _updater;

        public override void _Ready()
        {
            _updater = new ServiceUpdater();
            AddChild(_updater);
        }

        /// <summary>
        /// 初始化所有已注册服务
        /// </summary>
        public void InitializeAllServices()
        {
            var services = ServiceLocator.GetRegisteredTypes()
                .Select(t => ServiceLocator.Get<object>())
                .OfType<IService>()
                .OrderBy(s => s is IPrioritizedService p ? p.Priority : int.MaxValue)
                .ToList();

            foreach (var service in services)
            {
                if (!service.IsInitialized)
                {
                    service.Initialize();

                    if (service is IUpdatableService updatable)
                    {
                        _updater.AddService(updatable);
                    }
                }
            }
        }

        /// <summary>
        /// 关闭所有服务
        /// </summary>
        public void ShutdownAllServices()
        {
            var services = ServiceLocator.GetRegisteredTypes()
                .Select(t => ServiceLocator.Get<object>())
                .OfType<IService>()
                .ToList();

            foreach (var service in services)
            {
                if (service.IsInitialized)
                {
                    if (service is IUpdatableService updatable)
                    {
                        _updater.RemoveService(updatable);
                    }

                    service.Shutdown();
                }
            }
        }

        public override void _ExitTree()
        {
            ShutdownAllServices();
            ServiceLocator.Clear();
        }
    }
}

using Godot;
using GameFramework.Core.ServiceLocator;

namespace GameFramework.Examples
{
    /// <summary>
    /// 游戏服务示例
    /// </summary>
    public class GameSettingsService : IService, IPrioritizedService, IUpdatableService
    {
        public bool IsInitialized { get; private set; }
        public int Priority => 0; // 最高优先级

        public float MasterVolume { get; set; } = 1.0f;
        public float MusicVolume { get; set; } = 0.8f;
        public float SfxVolume { get; set; } = 0.8f;

        public void Initialize()
        {
            // 加载设置
            LoadSettings();
            IsInitialized = true;
            GD.Print("游戏设置服务已初始化");
        }

        public void Shutdown()
        {
            // 保存设置
            SaveSettings();
            IsInitialized = false;
        }

        public void Update(double deltaTime)
        {
            // 可以在这里处理自动保存等
        }

        private void LoadSettings()
        {
            // 从文件加载设置
        }

        private void SaveSettings()
        {
            // 保存到文件
        }
    }

    /// <summary>
    /// 音频服务示例
    /// </summary>
    public class AudioService : IService, IPrioritizedService
    {
        public bool IsInitialized { get; private set; }
        public int Priority => 1;

        public void Initialize()
        {
            // 初始化音频系统
            IsInitialized = true;
            GD.Print("音频服务已初始化");
        }

        public void Shutdown()
        {
            IsInitialized = false;
        }

        public void PlayMusic(string musicPath)
        {
            // 播放音乐
        }

        public void PlaySfx(string sfxPath)
        {
            // 播放音效
        }
    }

    /// <summary>
    /// 游戏入口 - 服务注册和初始化
    /// </summary>
    public partial class GameEntry : Node
    {
        [Export] public ServiceManager ServiceManager;

        public override void _Ready()
        {
            // 注册服务
            RegisterServices();

            // 初始化所有服务
            ServiceManager.InitializeAllServices();

            // 使用服务
            UseServices();
        }

        private void RegisterServices()
        {
            // 注册设置服务
            ServiceLocator.Register(new GameSettingsService());

            // 注册音频服务（依赖设置服务）
            ServiceLocator.Register(new AudioService());

            // 延迟加载示例
            ServiceLocator.RegisterLazy<IDataService>(() => new DataService());
        }

        private void UseServices()
        {
            // 获取并使用服务
            if (ServiceLocator.TryGet<GameSettingsService>(out var settings))
            {
                settings.MasterVolume = 0.5f;
            }

            if (ServiceLocator.TryGet<AudioService>(out var audio))
            {
                audio.PlayMusic("res://assets/music/main.ogg");
            }
        }
    }

    public interface IDataService : IService { }
    public class DataService : IDataService
    {
        public bool IsInitialized { get; private set; }
        public void Initialize() { IsInitialized = true; }
        public void Shutdown() { IsInitialized = false; }
    }
}