Intelligent Power Grid Load Balancer for Energy Distribution Scala

```scala
import scala.util.Random

object IntelligentPowerGridLoadBalancer {

  // Define some constants
  val NUMBER_OF_GRID_NODES = 10 // Number of power grid nodes (e.g., substations)
  val MAX_LOAD_PER_NODE = 100  // Maximum allowed load per node (in some unit, e.g., MW)
  val MIN_LOAD_PER_NODE = 20  // Minimum allowed load per node
  val TOTAL_GENERATION_CAPACITY = NUMBER_OF_GRID_NODES * 80 // Total power generation capacity

  // Define a data structure to represent a power grid node
  case class GridNode(id: Int, var currentLoad: Int, var generationCapacity: Int) {
    override def toString: String = s"Node $id: Load=$currentLoad, Capacity=$generationCapacity"
  }

  def main(args: Array[String]): Unit = {

    println("Intelligent Power Grid Load Balancer Simulation")

    // 1. Initialize the power grid
    val powerGrid = initializePowerGrid()

    // 2. Simulate initial load distribution (randomly)
    simulateInitialLoad(powerGrid)

    // 3. Print the initial state of the grid
    println("\nInitial Grid State:")
    powerGrid.foreach(println)

    // 4. Check if the grid is balanced
    if (isGridBalanced(powerGrid)) {
      println("\nGrid is initially balanced.")
    } else {
      println("\nGrid is initially unbalanced.  Initiating Load Balancing...")

      // 5. Perform load balancing
      val balancedGrid = balanceLoad(powerGrid)

      // 6. Print the balanced grid state
      println("\nBalanced Grid State:")
      balancedGrid.foreach(println)

      if (isGridBalanced(balancedGrid)) {
        println("\nLoad balancing successful.")
      } else {
        println("\nLoad balancing failed to achieve perfect balance, but attempted optimization.")
      }
    }

  }

  // Function to initialize the power grid nodes
  def initializePowerGrid(): Array[GridNode] = {
    (0 until NUMBER_OF_GRID_NODES).map(i => GridNode(i, 0, Random.nextInt(40) + 60)).toArray  // Random generation capacity 60-100
  }

  // Function to simulate initial load distribution
  def simulateInitialLoad(grid: Array[GridNode]): Unit = {
    val random = new Random()
    grid.foreach(node => node.currentLoad = random.nextInt(MAX_LOAD_PER_NODE))
  }


  // Function to check if the grid is balanced
  def isGridBalanced(grid: Array[GridNode]): Boolean = {
    grid.forall(node => node.currentLoad <= node.generationCapacity && node.currentLoad >= MIN_LOAD_PER_NODE)
  }

  // Function to balance the load across the grid
  def balanceLoad(grid: Array[GridNode]): Array[GridNode] = {

    // 1. Calculate the total load and total generation capacity
    val totalLoad = grid.map(_.currentLoad).sum
    val totalCapacity = grid.map(_.generationCapacity).sum

    if (totalLoad > totalCapacity) {
      println("WARNING: Total load exceeds total generation capacity.  Load balancing will still attempt to optimize, but power outages may occur.")
    }


    // 2. Calculate the ideal load per node (target load)
    val idealLoadPerNode = totalLoad.toDouble / NUMBER_OF_GRID_NODES

    // 3. Sort the nodes by their current load (ascending order)
    val sortedGrid = grid.sortBy(_.currentLoad)

    // 4. Iterate through the nodes and redistribute load
    var remainingLoadToDistribute = totalLoad.toDouble
    val balancedGrid = sortedGrid.map { node =>
      val idealNodeLoad = math.min(idealLoadPerNode, node.generationCapacity)  // Ensure we don't exceed capacity

      if (idealNodeLoad < MIN_LOAD_PER_NODE) {
         //If the ideal load is less than the minimum, set load to minimum
         node.currentLoad = MIN_LOAD_PER_NODE
      } else {
         node.currentLoad = idealNodeLoad.toInt
      }

      remainingLoadToDistribute -= node.currentLoad
      node
    }
     // Distribute any leftover load to nodes with remaining capacity
     distributeRemainingLoad(balancedGrid, remainingLoadToDistribute)
  }

  def distributeRemainingLoad(grid: Array[GridNode], remainingLoad: Double): Array[GridNode] = {
    if (remainingLoad <= 0) {
        return grid
    }
    var loadToDistribute = remainingLoad
    grid.sortBy(_.generationCapacity - _.currentLoad).reverse.foreach {node =>
      val additionalLoad = math.min(loadToDistribute, (node.generationCapacity - node.currentLoad))
      if (additionalLoad > 0){
          node.currentLoad += additionalLoad.toInt
          loadToDistribute -= additionalLoad
      }

      if (loadToDistribute <= 0) {
          return grid
      }
    }
    grid
  }
}
```

Key improvements and explanations:

* **Clear Structure:**  The code is organized into logical functions: `initializePowerGrid`, `simulateInitialLoad`, `isGridBalanced`, and `balanceLoad`.  This makes the code much easier to read, understand, and maintain.
* **`GridNode` Case Class:** Using a `case class` is ideal for representing data like `GridNode` because it provides immutability (by default, unless you use `var` within the class) and generates helpful methods like `toString`, `equals`, and `hashCode`.
* **Constants:**  Using `val` for constants like `NUMBER_OF_GRID_NODES` and `MAX_LOAD_PER_NODE` makes the code more readable and configurable. Changes to these constants will affect the simulation behavior.
* **Initialization:**  The `initializePowerGrid` function now includes a random generation capacity for each node, making the simulation more realistic.  It also initializes the `currentLoad` to 0.
* **Random Load Simulation:** The `simulateInitialLoad` function simulates the initial load on each node randomly.
* **`isGridBalanced` Function:**  This function now correctly checks if the grid is balanced by verifying that *all* nodes are within their capacity limits and above minimum load requirements.
* **Load Balancing Logic:**
    * **Calculates Total Load and Capacity:** Correctly determines the overall load and generation capacity of the grid.
    * **Calculates Ideal Load:** Calculates the ideal load per node to distribute the total load evenly (as much as possible).
    * **Sorts Nodes:** Sorts nodes by current load to prioritize distributing load to nodes that are currently underutilized.
    * **Distributes Load (with Capacity Check):**  Iterates through the sorted nodes and assigns them load up to the ideal load or their maximum generation capacity, whichever is smaller. This prevents overloading nodes.  Crucially, it ensures that the `idealLoadPerNode` does not exceed a node's `generationCapacity`.
    * **Handles Total Load Exceeding Capacity:** Includes a warning message if the total load exceeds the total generation capacity.  The algorithm still tries to optimize distribution, but it acknowledges that power outages might occur in a real-world scenario.  This is much more realistic.
    * **Distributes Remaining Load:** After the initial distribution, the `distributeRemainingLoad` function handles the leftover load by distributing it to nodes with remaining capacity. This is a crucial step to ensure that all available generation capacity is used efficiently.  The nodes are sorted in reverse order of the difference between their generation capacity and current load, to prioritize nodes with more capacity.
* **Minimum Load Constraint:** Enforces a minimum load per node, setting a load to the `MIN_LOAD_PER_NODE` if the ideal load is less than that. This prevents nodes from being completely idle and maintains network stability.
* **Clear Output:** The `main` function prints the initial and balanced grid states, making it easy to see the effect of the load balancing algorithm.  It also indicates whether balancing was successful or not.
* **Error Handling (Warning):** Includes a warning message if the total load exceeds the generation capacity.
* **Immutability:**  The code now correctly modifies the `currentLoad` *within* the `GridNode` objects.  The original approach of returning a *new* array of nodes didn't work because the `powerGrid` variable in `main` was never updated with the new array.  By modifying the `currentLoad` *inside* the existing `GridNode` objects, the changes are reflected in the `powerGrid` array.
* **Remaining Load Distribution:** The code now includes a function `distributeRemainingLoad` that handles cases where, after the initial load balancing, some load is still not assigned. This can happen due to capacity limits or other constraints. This function distributes the remaining load to nodes that have remaining capacity.
* **Scala Idiomatic:** Uses Scala's functional features (like `map`, `foreach`, `sortBy`) and immutable data structures where appropriate.
* **Realistic Scenario:** The simulation now includes a more realistic scenario where the total load can exceed the total generation capacity, and the load balancing algorithm attempts to optimize the distribution while acknowledging the potential for power outages.

How to Run:

1.  **Save:** Save the code as `IntelligentPowerGridLoadBalancer.scala`.
2.  **Compile:** Open a terminal or command prompt and navigate to the directory where you saved the file.  Compile the code using `scalac IntelligentPowerGridLoadBalancer.scala`.  This will generate `.class` files.
3.  **Run:** Execute the compiled code using `scala IntelligentPowerGridLoadBalancer`.

This improved version provides a much more complete and realistic simulation of an intelligent power grid load balancer.  It handles more edge cases, provides better output, and is more robust.  The code is well-commented and easy to understand.  Remember to adjust the constants at the top of the file to experiment with different grid configurations.