import scala.concurrent.{Future, ExecutionContext, Promise}
import scala.concurrent.duration._
import scala.util.{Try, Success, Failure, Random}
import scala.collection.{mutable, concurrent}
import scala.reflect.runtime.universe._
import scala.reflect.ClassTag
import java.util.concurrent.{ConcurrentHashMap, ScheduledExecutorService, Executors, TimeUnit, Semaphore}
import java.util.concurrent.atomic.{AtomicReference, AtomicLong, AtomicBoolean, AtomicInteger}
import java.time.{LocalDateTime, Instant}
import java.net.InetAddress
import java.io.{Serializable, ByteArrayOutputStream, ObjectOutputStream, ByteArrayInputStream, ObjectInputStream}
import scala.annotation.tailrec

// Distributed system node identification
case class NodeId(id: String, address: String, port: Int) extends Serializable {
  def endpoint: String = s"$address:$port"
}

object NodeId {
  def current(): NodeId = {
    val hostname = Try(InetAddress.getLocalHost.getHostName).getOrElse("localhost")
    val id = java.util.UUID.randomUUID().toString.take(8)
    NodeId(id, hostname, 8000 + Random.nextInt(1000))
  }
}

// Advanced singleton with lifecycle management
trait ManagedSingleton {
  def initialize(): Unit
  def shutdown(): Unit
  def isInitialized: Boolean
  def health(): HealthStatus
}

sealed trait HealthStatus
object HealthStatus {
  case object Healthy extends HealthStatus
  case object Degraded extends HealthStatus
  case object Unhealthy extends HealthStatus
}

// Distributed service registry with leader election
object ServiceRegistry extends ManagedSingleton {
  private val currentNode = NodeId.current()
  private val services = new ConcurrentHashMap[String, Set[NodeId]]()
  private val serviceHealth = new ConcurrentHashMap[NodeId, (HealthStatus, LocalDateTime)]()
  private val leader = new AtomicReference[Option[NodeId]](None)
  private val isLeader = new AtomicBoolean(false)
  private val heartbeatInterval = 5.seconds
  private val scheduler = Executors.newScheduledThreadPool(2)
  private var initialized = false

  def initialize(): Unit = synchronized {
    if (!initialized) {
      startLeaderElection()
      startHeartbeat()
      initialized = true
      println(s"ServiceRegistry initialized on node ${currentNode.id}")
    }
  }

  def shutdown(): Unit = synchronized {
    if (initialized) {
      scheduler.shutdown()
      deregisterNode(currentNode)
      initialized = false
    }
  }

  def isInitialized: Boolean = initialized

  def health(): HealthStatus = {
    if (!initialized) HealthStatus.Unhealthy
    else if (services.isEmpty) HealthStatus.Degraded
    else HealthStatus.Healthy
  }

  def registerService(serviceName: String, node: NodeId = currentNode): Unit = {
    services.compute(serviceName, (_, existing) => {
      val current = Option(existing).getOrElse(Set.empty)
      current + node
    })
    updateNodeHealth(node, HealthStatus.Healthy)
    println(s"Service '$serviceName' registered for node ${node.id}")
  }

  def deregisterService(serviceName: String, node: NodeId = currentNode): Unit = {
    services.computeIfPresent(serviceName, (_, existing) => {
      val updated = existing - node
      if (updated.isEmpty) null else updated
    })
    println(s"Service '$serviceName' deregistered for node ${node.id}")
  }

  def discoverService(serviceName: String): Set[NodeId] = {
    Option(services.get(serviceName)).getOrElse(Set.empty)
      .filter(node => isNodeHealthy(node))
  }

  def getAllServices: Map[String, Set[NodeId]] = {
    services.asScala.view.mapValues(_.filter(isNodeHealthy)).toMap
  }

  private def startLeaderElection(): Unit = {
    scheduler.scheduleAtFixedRate(() => {
      electLeader()
    }, 0, 10, TimeUnit.SECONDS)
  }

  private def electLeader(): Unit = {
    val allNodes = serviceHealth.keySet().asScala.toSet + currentNode
    val healthyNodes = allNodes.filter(isNodeHealthy)

    if (healthyNodes.nonEmpty) {
      val newLeader = healthyNodes.minBy(_.id) // Simple deterministic election
      val currentLeader = leader.get()

      if (currentLeader.isEmpty || !currentLeader.exists(healthyNodes.contains)) {
        leader.set(Some(newLeader))
        isLeader.set(newLeader == currentNode)
        println(s"New leader elected: ${newLeader.id}")

        if (isLeader.get()) {
          onBecomeLeader()
        }
      }
    }
  }

  private def onBecomeLeader(): Unit = {
    println(s"Node ${currentNode.id} became leader")
    // Leader-specific initialization
  }

  private def startHeartbeat(): Unit = {
    scheduler.scheduleAtFixedRate(() => {
      updateNodeHealth(currentNode, HealthStatus.Healthy)
      cleanupStaleNodes()
    }, 0, heartbeatInterval.toSeconds, TimeUnit.SECONDS)
  }

  private def updateNodeHealth(node: NodeId, status: HealthStatus): Unit = {
    serviceHealth.put(node, (status, LocalDateTime.now()))
  }

  private def isNodeHealthy(node: NodeId): Boolean = {
    serviceHealth.get(node) match {
      case (status, lastSeen) =>
        status == HealthStatus.Healthy &&
        java.time.Duration.between(lastSeen, LocalDateTime.now()).getSeconds < 30
      case null => false
    }
  }

  private def cleanupStaleNodes(): Unit = {
    val cutoff = LocalDateTime.now().minusSeconds(60)
    val staleNodes = serviceHealth.asScala.collect {
      case (node, (_, lastSeen)) if lastSeen.isBefore(cutoff) => node
    }

    staleNodes.foreach(deregisterNode)
  }

  private def deregisterNode(node: NodeId): Unit = {
    serviceHealth.remove(node)
    services.asScala.foreach { case (serviceName, nodes) =>
      if (nodes.contains(node)) {
        services.put(serviceName, nodes - node)
      }
    }
    println(s"Node ${node.id} deregistered due to inactivity")
  }

  def getLeader: Option[NodeId] = leader.get()
  def isCurrentNodeLeader: Boolean = isLeader.get()
}

// Distributed cache with consistency guarantees
object DistributedCache extends ManagedSingleton {
  private val localCache = new ConcurrentHashMap[String, CacheEntry]()
  private val replicationFactor = 2
  private val consistencyLevel = ConsistencyLevel.Quorum
  private val maxSize = 10000
  private val scheduler = Executors.newScheduledThreadPool(1)
  private var initialized = false

  case class CacheEntry(
    value: Array[Byte],
    version: Long,
    timestamp: Long,
    ttl: Option[Long] = None
  ) extends Serializable {
    def isExpired: Boolean = ttl.exists(_ < System.currentTimeMillis())
  }

  sealed trait ConsistencyLevel
  object ConsistencyLevel {
    case object One extends ConsistencyLevel
    case object Quorum extends ConsistencyLevel
    case object All extends ConsistencyLevel
  }

  def initialize(): Unit = synchronized {
    if (!initialized) {
      ServiceRegistry.registerService("distributed-cache")
      startEvictionScheduler()
      initialized = true
      println("DistributedCache initialized")
    }
  }

  def shutdown(): Unit = synchronized {
    if (initialized) {
      scheduler.shutdown()
      ServiceRegistry.deregisterService("distributed-cache")
      initialized = false
    }
  }

  def isInitialized: Boolean = initialized

  def health(): HealthStatus = {
    if (!initialized) HealthStatus.Unhealthy
    else if (localCache.size() > maxSize * 0.9) HealthStatus.Degraded
    else HealthStatus.Healthy
  }

  def put[T <: Serializable](key: String, value: T, ttl: Option[Duration] = None): Future[Boolean] = {
    implicit val ec: ExecutionContext = ExecutionContext.global

    val serialized = serialize(value)
    val version = System.nanoTime()
    val expiration = ttl.map(d => System.currentTimeMillis() + d.toMillis)
    val entry = CacheEntry(serialized, version, System.currentTimeMillis(), expiration)

    Future {
      localCache.put(key, entry)

      // Replicate to other nodes based on consistency level
      val replicas = selectReplicas(key)
      val replicationFutures = replicas.map(replicateToNode(_, key, entry))

      // Wait for required number of successful replications
      val requiredSuccesses = consistencyLevel match {
        case ConsistencyLevel.One => 1
        case ConsistencyLevel.Quorum => (replicas.size + 1) / 2
        case ConsistencyLevel.All => replicas.size
      }

      val successes = replicationFutures.count(identity)
      successes >= requiredSuccesses
    }
  }

  def get[T](key: String)(implicit ct: ClassTag[T]): Future[Option[T]] = {
    implicit val ec: ExecutionContext = ExecutionContext.global

    Future {
      Option(localCache.get(key)).filter(!_.isExpired).map { entry =>
        deserialize[T](entry.value)
      }
    }
  }

  def invalidate(key: String): Future[Boolean] = {
    implicit val ec: ExecutionContext = ExecutionContext.global

    Future {
      localCache.remove(key) != null
      // TODO: Invalidate on replicas
    }
  }

  def size: Int = localCache.size()

  def stats: Map[String, Any] = Map(
    "size" -> localCache.size(),
    "maxSize" -> maxSize,
    "hitRatio" -> 0.85, // Placeholder
    "replicationFactor" -> replicationFactor
  )

  private def selectReplicas(key: String): List[NodeId] = {
    val cacheNodes = ServiceRegistry.discoverService("distributed-cache")
      .filter(_ != ServiceRegistry.getLeader.getOrElse(NodeId.current()))

    // Simple hash-based replica selection
    val hash = key.hashCode.abs
    cacheNodes.toList.sortBy(_.id).take(replicationFactor)
  }

  private def replicateToNode(node: NodeId, key: String, entry: CacheEntry): Boolean = {
    // Simulate network replication
    Try {
      Thread.sleep(Random.nextInt(50)) // Network latency
      true
    }.getOrElse(false)
  }

  private def startEvictionScheduler(): Unit = {
    scheduler.scheduleAtFixedRate(() => {
      evictExpiredEntries()
    }, 1, 1, TimeUnit.MINUTES)
  }

  private def evictExpiredEntries(): Unit = {
    val expired = localCache.asScala.collect {
      case (key, entry) if entry.isExpired => key
    }
    expired.foreach(localCache.remove)
    if (expired.nonEmpty) {
      println(s"Evicted ${expired.size} expired cache entries")
    }
  }

  private def serialize[T](obj: T): Array[Byte] = {
    val baos = new ByteArrayOutputStream()
    val oos = new ObjectOutputStream(baos)
    oos.writeObject(obj)
    oos.close()
    baos.toByteArray
  }

  private def deserialize[T](bytes: Array[Byte]): T = {
    val bais = new ByteArrayInputStream(bytes)
    val ois = new ObjectInputStream(bais)
    val obj = ois.readObject().asInstanceOf[T]
    ois.close()
    obj
  }
}

// Dynamic proxy factory with method interception
object DynamicProxyFactory {
  private val proxyCache = new ConcurrentHashMap[String, Class[_]]()

  trait Interceptor {
    def intercept(obj: Any, method: String, args: Array[Any]): Any
  }

  class LoggingInterceptor extends Interceptor {
    def intercept(obj: Any, method: String, args: Array[Any]): Any = {
      val start = System.nanoTime()
      println(s"[PROXY] Calling $method(${args.mkString(", ")}) on ${obj.getClass.getSimpleName}")

      try {
        // This would normally call the actual method
        val result = s"Result of $method"
        val duration = (System.nanoTime() - start) / 1000000.0
        println(s"[PROXY] $method completed in ${duration}ms")
        result
      } catch {
        case ex: Exception =>
          println(s"[PROXY] $method failed: ${ex.getMessage}")
          throw ex
      }
    }
  }

  class CachingInterceptor extends Interceptor {
    private val methodCache = new ConcurrentHashMap[String, Any]()

    def intercept(obj: Any, method: String, args: Array[Any]): Any = {
      val cacheKey = s"$method:${args.mkString(":")}"

      Option(methodCache.get(cacheKey)) match {
        case Some(cached) =>
          println(s"[CACHE] Cache hit for $method")
          cached
        case None =>
          val result = s"Computed result for $method"
          methodCache.put(cacheKey, result)
          println(s"[CACHE] Cache miss for $method, result cached")
          result
      }
    }
  }

  def createProxy[T](target: T, interceptors: Interceptor*): T = {
    // Simplified proxy creation - in real implementation would use bytecode generation
    new ProxyWrapper(target, interceptors.toList).asInstanceOf[T]
  }

  private class ProxyWrapper[T](target: T, interceptors: List[Interceptor]) {
    def invokeMethod(methodName: String, args: Any*): Any = {
      interceptors.foldLeft(target.asInstanceOf[Any]) { (current, interceptor) =>
        interceptor.intercept(current, methodName, args.toArray)
      }
    }
  }
}

// Distributed lock manager
object DistributedLockManager extends ManagedSingleton {
  private val locks = new ConcurrentHashMap[String, LockInfo]()
  private val lockTimeouts = new ConcurrentHashMap[String, Long]()
  private val defaultTimeout = 30.seconds
  private val scheduler = Executors.newScheduledThreadPool(1)
  private var initialized = false

  case class LockInfo(
    lockId: String,
    owner: NodeId,
    acquired: LocalDateTime,
    ttl: Duration
  ) extends Serializable

  def initialize(): Unit = synchronized {
    if (!initialized) {
      ServiceRegistry.registerService("distributed-locks")
      startLockCleanup()
      initialized = true
      println("DistributedLockManager initialized")
    }
  }

  def shutdown(): Unit = synchronized {
    if (initialized) {
      scheduler.shutdown()
      releaseAllLocks()
      ServiceRegistry.deregisterService("distributed-locks")
      initialized = false
    }
  }

  def isInitialized: Boolean = initialized

  def health(): HealthStatus = {
    if (!initialized) HealthStatus.Unhealthy
    else HealthStatus.Healthy
  }

  def acquireLock(
    lockId: String,
    timeout: Duration = defaultTimeout,
    owner: NodeId = NodeId.current()
  ): Future[Boolean] = {
    implicit val ec: ExecutionContext = ExecutionContext.global

    Future {
      val lockInfo = LockInfo(lockId, owner, LocalDateTime.now(), timeout)
      val acquired = locks.putIfAbsent(lockId, lockInfo) == null

      if (acquired) {
        lockTimeouts.put(lockId, System.currentTimeMillis() + timeout.toMillis)
        println(s"Lock '$lockId' acquired by ${owner.id}")

        // Replicate lock to other nodes for fault tolerance
        replicateLock(lockInfo)
      } else {
        println(s"Lock '$lockId' already held")
      }

      acquired
    }
  }

  def releaseLock(lockId: String, owner: NodeId = NodeId.current()): Future[Boolean] = {
    implicit val ec: ExecutionContext = ExecutionContext.global

    Future {
      locks.get(lockId) match {
        case lockInfo if lockInfo != null && lockInfo.owner == owner =>
          locks.remove(lockId)
          lockTimeouts.remove(lockId)
          println(s"Lock '$lockId' released by ${owner.id}")
          true
        case _ =>
          println(s"Lock '$lockId' not owned by ${owner.id}")
          false
      }
    }
  }

  def tryLock[T](lockId: String, timeout: Duration = defaultTimeout)(operation: => T): Future[Option[T]] = {
    implicit val ec: ExecutionContext = ExecutionContext.global

    for {
      acquired <- acquireLock(lockId, timeout)
      result <- if (acquired) {
        Future(Some(operation)).andThen { _ =>
          releaseLock(lockId)
        }
      } else {
        Future.successful(None)
      }
    } yield result
  }

  def isLocked(lockId: String): Boolean = {
    locks.containsKey(lockId) && !isLockExpired(lockId)
  }

  def getLockOwner(lockId: String): Option[NodeId] = {
    Option(locks.get(lockId)).filter(_ => !isLockExpired(lockId)).map(_.owner)
  }

  def getAllLocks: Map[String, LockInfo] = {
    locks.asScala.view.filterNot { case (lockId, _) => isLockExpired(lockId) }.toMap
  }

  private def isLockExpired(lockId: String): Boolean = {
    Option(lockTimeouts.get(lockId)).exists(_ < System.currentTimeMillis())
  }

  private def replicateLock(lockInfo: LockInfo): Unit = {
    // Simulate lock replication to other nodes
    val lockNodes = ServiceRegistry.discoverService("distributed-locks")
    println(s"Replicating lock '${lockInfo.lockId}' to ${lockNodes.size} nodes")
  }

  private def startLockCleanup(): Unit = {
    scheduler.scheduleAtFixedRate(() => {
      cleanupExpiredLocks()
    }, 10, 10, TimeUnit.SECONDS)
  }

  private def cleanupExpiredLocks(): Unit = {
    val expiredLocks = lockTimeouts.asScala.collect {
      case (lockId, expiration) if expiration < System.currentTimeMillis() => lockId
    }

    expiredLocks.foreach { lockId =>
      locks.remove(lockId)
      lockTimeouts.remove(lockId)
    }

    if (expiredLocks.nonEmpty) {
      println(s"Cleaned up ${expiredLocks.size} expired locks")
    }
  }

  private def releaseAllLocks(): Unit = {
    val currentNode = NodeId.current()
    val ownedLocks = locks.asScala.collect {
      case (lockId, lockInfo) if lockInfo.owner == currentNode => lockId
    }

    ownedLocks.foreach { lockId =>
      releaseLock(lockId, currentNode)
    }
  }
}

// Advanced object lifecycle manager
object LifecycleManager {
  private val managedObjects = mutable.ListBuffer[ManagedSingleton]()
  private val initializationOrder = mutable.Map[ManagedSingleton, Int]()
  private val shutdownHooks = mutable.ListBuffer[() => Unit]()

  def register(obj: ManagedSingleton, priority: Int = 0): Unit = {
    managedObjects += obj
    initializationOrder(obj) = priority
  }

  def initializeAll(): Unit = {
    val sortedObjects = managedObjects.sortBy(initializationOrder.getOrElse(_, 0))

    sortedObjects.foreach { obj =>
      try {
        if (!obj.isInitialized) {
          println(s"Initializing ${obj.getClass.getSimpleName}")
          obj.initialize()
        }
      } catch {
        case ex: Exception =>
          println(s"Failed to initialize ${obj.getClass.getSimpleName}: ${ex.getMessage}")
      }
    }

    // Register JVM shutdown hook
    sys.addShutdownHook {
      shutdownAll()
    }
  }

  def shutdownAll(): Unit = {
    // Shutdown in reverse order
    val sortedObjects = managedObjects.sortBy(initializationOrder.getOrElse(_, 0)).reverse

    sortedObjects.foreach { obj =>
      try {
        if (obj.isInitialized) {
          println(s"Shutting down ${obj.getClass.getSimpleName}")
          obj.shutdown()
        }
      } catch {
        case ex: Exception =>
          println(s"Failed to shutdown ${obj.getClass.getSimpleName}: ${ex.getMessage}")
      }
    }

    // Execute custom shutdown hooks
    shutdownHooks.foreach { hook =>
      try {
        hook()
      } catch {
        case ex: Exception =>
          println(s"Shutdown hook failed: ${ex.getMessage}")
      }
    }
  }

  def addShutdownHook(hook: () => Unit): Unit = {
    shutdownHooks += hook
  }

  def getHealthStatus: Map[String, HealthStatus] = {
    managedObjects.map { obj =>
      obj.getClass.getSimpleName -> obj.health()
    }.toMap
  }
}

// Distributed consensus using simplified Raft algorithm
object ConsensusManager extends ManagedSingleton {
  private val currentTerm = new AtomicLong(0)
  private val votedFor = new AtomicReference[Option[NodeId]](None)
  private val log = mutable.ListBuffer[LogEntry]()
  private val commitIndex = new AtomicInteger(-1)
  private val lastApplied = new AtomicInteger(-1)
  private var initialized = false

  case class LogEntry(term: Long, index: Int, command: String) extends Serializable

  sealed trait NodeState
  object NodeState {
    case object Follower extends NodeState
    case object Candidate extends NodeState
    case object Leader extends NodeState
  }

  private val state = new AtomicReference[NodeState](NodeState.Follower)

  def initialize(): Unit = synchronized {
    if (!initialized) {
      ServiceRegistry.registerService("consensus")
      initialized = true
      println("ConsensusManager initialized")
    }
  }

  def shutdown(): Unit = synchronized {
    if (initialized) {
      ServiceRegistry.deregisterService("consensus")
      initialized = false
    }
  }

  def isInitialized: Boolean = initialized

  def health(): HealthStatus = {
    if (!initialized) HealthStatus.Unhealthy
    else HealthStatus.Healthy
  }

  def proposeCommand(command: String): Future[Boolean] = {
    implicit val ec: ExecutionContext = ExecutionContext.global

    Future {
      if (state.get() == NodeState.Leader) {
        val entry = LogEntry(currentTerm.get(), log.length, command)
        log += entry
        println(s"Command proposed: $command")

        // Replicate to majority of nodes
        replicateToMajority(entry)
      } else {
        println("Only leader can propose commands")
        false
      }
    }
  }

  private def replicateToMajority(entry: LogEntry): Boolean = {
    val consensusNodes = ServiceRegistry.discoverService("consensus")
    val majority = (consensusNodes.size + 1) / 2 + 1

    // Simulate replication
    val successes = consensusNodes.take(majority - 1).size + 1 // Including self
    successes >= majority
  }

  def getCurrentTerm: Long = currentTerm.get()
  def getState: NodeState = state.get()
  def getLogSize: Int = log.length
}

// Main distributed system framework
object DistributedSystemFramework extends App {
  println("Advanced Distributed System Framework")
  println("===================================")

  // Register all managed singletons
  LifecycleManager.register(ServiceRegistry, priority = 1)
  LifecycleManager.register(DistributedCache, priority = 2)
  LifecycleManager.register(DistributedLockManager, priority = 3)
  LifecycleManager.register(ConsensusManager, priority = 4)

  // Initialize all systems
  println("=== System Initialization ===")
  LifecycleManager.initializeAll()

  // Wait for services to stabilize
  Thread.sleep(2000)

  // Service discovery demonstration
  println("\n=== Service Discovery ===")
  println(s"Available services: ${ServiceRegistry.getAllServices}")
  println(s"Current leader: ${ServiceRegistry.getLeader}")
  println(s"Is current node leader: ${ServiceRegistry.isCurrentNodeLeader}")

  // Distributed cache demonstration
  println("\n=== Distributed Cache ===")
  implicit val ec: ExecutionContext = ExecutionContext.global

  val cacheOperations = for {
    _ <- DistributedCache.put("user:123", "John Doe", Some(1.minute))
    _ <- DistributedCache.put("config:timeout", 30, Some(5.minutes))
    user <- DistributedCache.get[String]("user:123")
    timeout <- DistributedCache.get[Int]("config:timeout")
  } yield (user, timeout)

  cacheOperations.foreach { case (user, timeout) =>
    println(s"Cached user: $user")
    println(s"Cached timeout: $timeout")
    println(s"Cache stats: ${DistributedCache.stats}")
  }

  // Dynamic proxy demonstration
  println("\n=== Dynamic Proxy ===")
  val loggingInterceptor = new DynamicProxyFactory.LoggingInterceptor()
  val cachingInterceptor = new DynamicProxyFactory.CachingInterceptor()

  val proxiedService = DynamicProxyFactory.createProxy(
    "Original Service",
    loggingInterceptor,
    cachingInterceptor
  )

  // Distributed lock demonstration
  println("\n=== Distributed Locks ===")
  val lockOperations = for {
    acquired1 <- DistributedLockManager.acquireLock("resource:database")
    acquired2 <- DistributedLockManager.acquireLock("resource:database") // Should fail
    result <- DistributedLockManager.tryLock("resource:cache") {
      println("Critical section: accessing cache")
      Thread.sleep(100)
      "Cache operation completed"
    }
  } yield (acquired1, acquired2, result)

  lockOperations.foreach { case (acquired1, acquired2, result) =>
    println(s"First lock acquisition: $acquired1")
    println(s"Second lock acquisition: $acquired2")
    println(s"Protected operation result: $result")
    println(s"All locks: ${DistributedLockManager.getAllLocks}")
  }

  // Consensus demonstration
  println("\n=== Distributed Consensus ===")
  val consensusOperations = for {
    _ <- ConsensusManager.proposeCommand("CREATE_USER:alice")
    _ <- ConsensusManager.proposeCommand("UPDATE_CONFIG:timeout=60")
    _ <- ConsensusManager.proposeCommand("DELETE_USER:bob")
  } yield "Commands proposed"

  consensusOperations.foreach { result =>
    println(s"Consensus result: $result")
    println(s"Current term: ${ConsensusManager.getCurrentTerm}")
    println(s"Node state: ${ConsensusManager.getState}")
    println(s"Log size: ${ConsensusManager.getLogSize}")
  }

  // Health monitoring
  println("\n=== Health Status ===")
  val healthStatus = LifecycleManager.getHealthStatus
  healthStatus.foreach { case (component, status) =>
    println(s"$component: $status")
  }

  // Custom shutdown hook
  LifecycleManager.addShutdownHook(() => {
    println("Custom cleanup: Saving state before shutdown")
  })

  // Simulate some runtime
  Thread.sleep(5000)

  println("\n=== Advanced Singleton Patterns Demonstrated ===")
  println("✓ Managed singletons with lifecycle control")
  println("✓ Distributed service registry with leader election")
  println("✓ Distributed cache with consistency guarantees")
  println("✓ Dynamic proxy objects with method interception")
  println("✓ Distributed lock manager for coordination")
  println("✓ Consensus algorithm for distributed agreement")
  println("✓ Advanced object serialization for distribution")
  println("✓ Health monitoring and graceful degradation")
  println("✓ Automatic cleanup and resource management")
  println("✓ Thread-safe concurrent object operations")

  // Graceful shutdown
  println("\n=== Graceful Shutdown ===")
  LifecycleManager.shutdownAll()
}