pingerino/Infrastructure/ServiceContainer.cs

using System;
using System.Collections.Generic;
using Pingerino.Services;
using Pingerino.Services.Interfaces;

namespace Pingerino.Infrastructure
{
    public class ServiceContainer : IDisposable
    {
        private readonly Dictionary<Type, object> _services = new Dictionary<Type, object>();
        private readonly List<IDisposable> _disposables = new List<IDisposable>();
        private bool _disposed;

        public static ServiceContainer Instance { get; private set; }

        public static void Initialize()
        {
            Instance?.Dispose();
            Instance = new ServiceContainer();
            Instance.RegisterServices();
        }

        private void RegisterServices()
        {
            // Register logging service first
            var loggingService = new LoggingService();
            RegisterSingleton<ILoggingService>(loggingService);

            // Register other services
            RegisterSingleton<IConfigurationService>(new ConfigurationService(loggingService));
            RegisterSingleton<IPingService>(new PingService(loggingService));
            RegisterSingleton<INetworkService>(new NetworkService(loggingService));
            RegisterSingleton<ISystemService>(new SystemService(loggingService));
        }

        public void RegisterSingleton<T>(T instance) where T : class
        {
            _services[typeof(T)] = instance;
            
            if (instance is IDisposable disposable)
            {
                _disposables.Add(disposable);
            }
        }

        public T GetService<T>() where T : class
        {
            if (_services.TryGetValue(typeof(T), out var service))
            {
                return service as T;
            }

            throw new InvalidOperationException($"Service of type {typeof(T).Name} is not registered.");
        }

        public bool TryGetService<T>(out T service) where T : class
        {
            service = null;
            if (_services.TryGetValue(typeof(T), out var serviceObj))
            {
                service = serviceObj as T;
                return service != null;
            }
            return false;
        }

        public void Dispose()
        {
            if (_disposed) return;

            foreach (var disposable in _disposables)
            {
                try
                {
                    disposable?.Dispose();
                }
                catch
                {
                    // Ignore disposal errors
                }
            }

            _services.Clear();
            _disposables.Clear();
            _disposed = true;
        }
    }
}