test: Reduce traffic light coordination test monitoring duration from 60s to 10s

testing

.github/workflows/maven.yml

@@ -0,0 +1,104 @@
+name: Java CI with Maven
+
+on:
+  workflow_dispatch:
+  push:
+    branches: [ "dev", "cleanup" ]
+    tags:
+      - 'v*.*.*'
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up JDK 17
+      uses: actions/setup-java@v4
+      with:
+        java-version: '17'
+        distribution: 'temurin'
+        cache: maven
+    - name: Build with Maven
+      run: mvn -B package
+      working-directory: main
+    - name: Upload built JAR
+      uses: actions/upload-artifact@v4
+      with:
+        name: package
+        path: main/target/*.jar
+    - name: Generate dependency graph
+      run: mvn -B -f main/pom.xml com.github.ferstl:depgraph-maven-plugin:4.0.1:graph
+    - name: Upload dependency graph artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: dependency-graph
+        path: main/target/**
+
+  build-windows:
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up JDK 17
+      uses: actions/setup-java@v4
+      with:
+        java-version: '17'
+        distribution: 'temurin'
+        cache: maven
+    - name: Build with Maven (Skip Tests)
+      run: mvn -B package -DskipTests
+      working-directory: main
+    - name: Create JPackage App Image
+      shell: pwsh
+      run: |
+        New-Item -ItemType Directory -Force -Path "dist"
+        jpackage --name "DTSS" `
+          --input main/target `
+          --main-jar main-1.0-SNAPSHOT.jar `
+          --dest dist `
+          --type app-image `
+          --win-console
+    - name: Inject java.exe
+      shell: pwsh
+      run: |
+        $javaPath = (Get-Command java).Source
+        Copy-Item -Path $javaPath -Destination "dist/DTSS/runtime/bin/"
+    - name: Zip Windows Release
+      shell: pwsh
+      run: |
+        Compress-Archive -Path "dist/DTSS" -DestinationPath "dist/DTSS-Windows.zip"
+    - name: Upload Windows Artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: windows-package
+        path: dist/DTSS-Windows.zip
+
+  publish-release:
+    runs-on: ubuntu-latest
+    needs: [build, build-windows]
+    if: startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch'
+    permissions:
+      contents: write
+    steps:
+    - name: Download Linux JAR
+      uses: actions/download-artifact@v4
+      with:
+        name: package
+        path: main/target/
+    - name: Download Windows Zip
+      uses: actions/download-artifact@v4
+      with:
+        name: windows-package
+        path: windows-dist/
+    - name: Create GitHub Release
+      uses: softprops/action-gh-release@v2
+      with:
+        tag_name: ${{ startsWith(github.ref, 'refs/tags/') && github.ref_name || 'snapshot-build' }}
+        name: ${{ startsWith(github.ref, 'refs/tags/') && github.ref_name || 'Manual Snapshot Build' }}
+        draft: false
+        prerelease: true
+        make_latest: false
+        files: |
+          main/target/*.jar
+          windows-dist/*.zip

.gitignore

@@ -48,3 +48,6 @@ build/
 # Other
 *.swp
 *.pdf
+
+# JAR built pom file
+dependency-reduced-pom.xml

STEP2_SUMMARY.md

@@ -0,0 +1,134 @@
+# 🏁 Single-Process Prototype — Implementation Summary
+
+**Status:** ✅ Complete
+**Date:** October 22, 2025
+**Branch:** `8-single-process-prototype`
+
+---
+
+## Overview
+
+The single-process prototype implements a **discrete event simulation (DES)** of a 3×3 urban grid with five intersections, realistic vehicle behavior, and fully synchronized traffic lights. Everything runs under one process, laying the groundwork for the distributed architecture in Phase 3.
+
+---
+
+## Core Architecture
+
+### **SimulationEngine**
+
+Drives the DES loop with a priority queue of timestamped events — vehicles, lights, crossings, and periodic stats updates. Handles five intersections (Cr1–Cr5) and six event types.
+
+**Main loop:**
+
+```
+while (events && time < duration):
+    event = nextEvent()
+    time = event.timestamp
+    handle(event)
+```
+
+### **VehicleGenerator**
+
+Spawns vehicles via:
+
+* **Poisson arrivals** (λ = 0.5 veh/s) or fixed intervals
+* **Probabilistic routes** from E1–E3
+* **Type distribution**: 20% BIKE, 60% LIGHT, 20% HEAVY
+
+### **StatisticsCollector**
+
+Tracks system-wide and per-type metrics: throughput, avg. wait, queue sizes, light cycles — updated every 10 s and at simulation end.
+
+---
+
+## Model Highlights
+
+* **Vehicle** – type, route, timings, lifecycle.
+* **Intersection** – routing tables, traffic lights, queues.
+* **TrafficLight** – red/green cycles with FIFO queues.
+* **Event** – timestamped, comparable; 6 types for all DES actions.
+
+---
+
+## Configuration (`simulation.properties`)
+
+```properties
+simulation.duration=60.0
+simulation.arrival.model=POISSON
+simulation.arrival.rate=0.5
+
+vehicle.bike.crossingTime=1.5
+vehicle.light.crossingTime=2.0
+vehicle.heavy.crossingTime=4.0
+
+statistics.update.interval=10.0
+```
+
+**Speed logic:**
+`t_bike = 0.5×t_car`, `t_heavy = 2×t_car`.
+
+---
+
+## Topology
+
+```
+E1→Cr1→Cr4→Cr5→S
+E2→Cr2→Cr5→S
+E3→Cr3→S
+Bi-dir: Cr1↔Cr2, Cr2↔Cr3
+```
+
+---
+
+## Results
+
+**Unit Tests:** 7/7 ✅
+**60-Second Simulation:**
+
+* Generated: 22 vehicles
+* Completed: 5 (22.7%)
+* Avg system time: 15.47 s
+* Throughput: 0.08 veh/s
+* All lights & intersections operational
+
+**Performance:**
+~0.03 s real-time run (≈2000× speed-up), < 50 MB RAM.
+
+---
+
+## Code Structure
+
+```
+sd/
+├── engine/SimulationEngine.java
+├── model/{Vehicle,Intersection,TrafficLight,Event}.java
+├── util/{VehicleGenerator,StatisticsCollector}.java
+└── config/SimulationConfig.java
+```
+
+---
+
+## Key Flow
+
+1. Initialize intersections, lights, first events.
+2. Process events chronologically.
+3. Vehicles follow routes → queue → cross → exit.
+4. Lights toggle, queues drain, stats update.
+5. Print summary and performance metrics.
+
+---
+
+## Next Steps — Phase 3
+
+* Split intersections into independent **processes**.
+* Add **socket-based communication**.
+* Run **traffic lights as threads**.
+* Enable **distributed synchronization** and fault handling.
+
+---
+
+## TL;DR
+
+Solid single-process DES ✅
+Everything’s working — traffic lights, routing, vehicles, stats.
+Ready to go distributed next.

TODO.md

@@ -1,3 +1,26 @@
+## ✅ SINGLE-PROCESS PROTOTYPE - COMPLETED
+
+### Phase 2 Status: DONE ✅
+
+All components for the single-process prototype have been successfully implemented and tested:
+
+- ✅ **SimulationEngine** - Priority queue-based discrete event simulation
+- ✅ **VehicleGenerator** - Poisson and Fixed arrival models
+- ✅ **StatisticsCollector** - Comprehensive metrics tracking
+- ✅ **Entry point** - Main simulation runner
+- ✅ **60s test simulation** - Successfully validated event processing and routing
+
+### Test Results:
+- All 7 unit tests passing
+- 60-second simulation completed successfully
+- Generated 22 vehicles with 5 completing their routes
+- Traffic light state changes working correctly
+- Vehicle routing through intersections validated
+
+---
+
+## NEXT: Distributed Architecture Implementation
+
 ### Compreender os Conceitos Fundamentais
 
 Primeiro, as tecnologias e paradigmas chave necessários para este projeto devem ser totalmente compreendidos.
@@ -16,7 +39,7 @@ Primeiro, as tecnologias e paradigmas chave necessários para este projeto devem
         
     - Uma **lista de eventos** central, frequentemente uma fila de prioridades, será necessária para armazenar eventos futuros, ordenados pelo seu timestamp. O ciclo principal da simulação retira o próximo evento da lista, processa-o e adiciona quaisquer novos eventos que resultem dele.
         
-- **Processo de Poisson:** Para o modelo "mais realista" de chegadas de veículos, é especificado um processo de Poisson. A principal conclusão é que o tempo _entre_ chegadas consecutivas de veículos segue uma **distribuição exponencial**. Em Java, este intervalo pode ser gerado usando `Math.log(1 - Math.random()) / -lambda`, onde `lambda` (λi​) é a taxa de chegada especificada.
+- **Processo de Poisson:** Para o modelo 'mais realista' de chegadas de veículos, é especificado um processo de Poisson. A principal conclusão é que o tempo _entre_ chegadas consecutivas de veículos segue uma **distribuição exponencial**. Em Java, este intervalo pode ser gerado usando `Math.log(1 - Math.random()) / -lambda`, onde `lambda` (λi​) é a taxa de chegada especificada.
     
 
 ---

main/pom.xml

@@ -29,6 +29,18 @@
             <artifactId>gson</artifactId>
             <version>2.10.1</version>
         </dependency>
+
+        <!-- JavaFX for UI -->
+        <dependency>
+            <groupId>org.openjfx</groupId>
+            <artifactId>javafx-controls</artifactId>
+            <version>17.0.2</version>
+        </dependency>
+        <dependency>
+            <groupId>org.openjfx</groupId>
+            <artifactId>javafx-fxml</artifactId>
+            <version>17.0.2</version>
+        </dependency>
     </dependencies>
 
     <build>
@@ -39,9 +51,38 @@
                 <artifactId>exec-maven-plugin</artifactId>
                 <version>3.1.0</version>
                 <configuration>
-                    <mainClass>sd.Entry</mainClass>
+                    <mainClass>sd.dashboard.Launcher</mainClass>
                 </configuration>
             </plugin>
+            <!-- JavaFX Maven Plugin -->
+            <plugin>
+                <groupId>org.openjfx</groupId>
+                <artifactId>javafx-maven-plugin</artifactId>
+                <version>0.0.8</version>
+                <configuration>
+                    <mainClass>sd.dashboard.Launcher</mainClass>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>3.5.2</version>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                        <configuration>
+                            <transformers>
+                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+                                    <mainClass>sd.dashboard.Launcher</mainClass>
+                                </transformer>
+                            </transformers>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
         </plugins>
     </build>
 

main/src/main/java/sd/Entry.java

@@ -1,94 +0,0 @@
-package sd;
-
-import java.io.IOException;
-
-import sd.config.SimulationConfig;
-import sd.engine.SimulationEngine;
-
-/**
- * Main entry point for the traffic simulation.
- * * This class is responsible for loading the simulation configuration,
- * initializing the {@link SimulationEngine}, and starting the simulation run.
- * It also prints initial configuration details and final execution time.
- */
-public class Entry {
-    
-    /**
-     * The default path to the simulation configuration file.
-     * This is used if no command-line arguments are provided.
-     */
-    private static final String DEFAULT_CONFIG_FILE = "src/main/resources/simulation.properties";
-    
-    /**
-     * The main method to start the simulation.
-     * * @param args Command-line arguments. If provided, args[0] is expected
-     * to be the path to a custom configuration file.
-     */
-    public static void main(String[] args) {
-        System.out.println("=".repeat(60));
-        System.out.println("TRAFFIC SIMULATION - DISCRETE EVENT SIMULATOR");
-        System.out.println("=".repeat(60));
-        
-        try {
-            // 1. Load configuration
-            String configFile = args.length > 0 ? args[0] : DEFAULT_CONFIG_FILE;
-            System.out.println("Loading configuration from: " + configFile);
-            
-            SimulationConfig config = new SimulationConfig(configFile);
-            
-            // 2. Display configuration
-            displayConfiguration(config);
-            
-            // 3. Create and initialize simulation engine
-            SimulationEngine engine = new SimulationEngine(config);
-            engine.initialize();
-            
-            System.out.println("\n" + "=".repeat(60));
-            
-            // 4. Run simulation
-            long startTime = System.currentTimeMillis();
-            engine.run();
-            long endTime = System.currentTimeMillis();
-            
-            // 5. Display execution time
-            double executionTime = (endTime - startTime) / 1000.0;
-            System.out.println("\nExecution time: " + String.format("%.2f", executionTime) + " seconds");
-            System.out.println("=".repeat(60));
-            
-        } catch (IOException e) {
-            System.err.println("Error loading configuration: " + e.getMessage());
-            e.printStackTrace();
-        } catch (Exception e) {
-            System.err.println("Error during simulation: " + e.getMessage());
-            e.printStackTrace();
-        }
-    }
-    
-    /**
-     * Displays the main configuration parameters to the console.
-     * This provides a summary of the simulation settings before it starts.
-     *
-     * @param config The {@link SimulationConfig} object containing the loaded settings.
-     */
-    private static void displayConfiguration(SimulationConfig config) {
-        System.out.println("\nSIMULATION CONFIGURATION:");
-        System.out.println("  Duration: " + config.getSimulationDuration() + " seconds");
-        System.out.println("  Arrival Model: " + config.getArrivalModel());
-        
-        if ("POISSON".equalsIgnoreCase(config.getArrivalModel())) {
-            System.out.println("  Arrival Rate (λ): " + config.getArrivalRate() + " vehicles/second");
-        } else {
-            System.out.println("  Fixed Interval: " + config.getFixedArrivalInterval() + " seconds");
-        }
-        
-        System.out.println("  Statistics Update Interval: " + config.getStatisticsUpdateInterval() + " seconds");
-        
-        System.out.println("\nVEHICLE TYPES:");
-        System.out.println("  Bike: " + (config.getBikeVehicleProbability() * 100) + "% " +
-                         "(crossing time: " + config.getBikeVehicleCrossingTime() + "s)");
-        System.out.println("  Light: " + (config.getLightVehicleProbability() * 100) + "% " +
-                         "(crossing time: " + config.getLightVehicleCrossingTime() + "s)");
-        System.out.println("  Heavy: " + (config.getHeavyVehicleProbability() * 100) + "% " +
-                         "(crossing time: " + config.getHeavyVehicleCrossingTime() + "s)");
-    }
-}

main/src/main/java/sd/ExitNodeProcess.java

@@ -0,0 +1,426 @@
+package sd;
+
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+import sd.config.SimulationConfig;
+import sd.coordinator.SocketClient;
+import sd.dashboard.StatsUpdatePayload;
+import sd.model.Message;
+import sd.model.MessageType;
+import sd.model.Vehicle;
+import sd.model.VehicleType;
+import sd.protocol.MessageProtocol;
+import sd.protocol.SocketConnection;
+
+/**
+ * Processo responsável pelo nó de saída do sistema de simulação de tráfego
+ * distribuído.
+ * 
+ * Este processo representa o ponto final ("S") onde os veículos completam as
+ * suas rotas.
+ * As suas principais responsabilidades são:
+ * - Receber veículos que terminam a sua rota vindos das interseções
+ * - Calcular e agregar estatísticas finais dos veículos
+ * - Enviar estatísticas periódicas para o dashboard
+ * - Gerar relatórios finais ao terminar a simulação
+ */
+public class ExitNodeProcess {
+
+    private final SimulationConfig config;
+    private ServerSocket serverSocket;
+    private final ExecutorService connectionHandlerPool;
+
+    /**
+     * Flag para controlar a execução do processo (volatile para visibilidade entre
+     * threads)
+     */
+    private volatile boolean running;
+
+    /** Simulation start time (milliseconds) to calculate relative times */
+    private long simulationStartMillis;
+
+    /** Counter de veículos que completaram a rota */
+    private int totalVehiclesReceived;
+
+    /** Soma dos tempos no sistema de todos os veículos */
+    private double totalSystemTime;
+
+    /** Soma dos tempos de espera de todos os veículos */
+    private double totalWaitingTime;
+
+    /** Soma dos tempos de travessia de todos os veículos */
+    private double totalCrossingTime;
+
+    /** Contagem de veículos por tipo */
+    private final Map<VehicleType, Integer> vehicleTypeCount;
+
+    /** Tempo total de espera acumulado por tipo de veículo */
+    private final Map<VehicleType, Double> vehicleTypeWaitTime;
+
+    /** Socket para comunicação com o dashboard */
+    private SocketClient dashboardClient;
+
+    /**
+     * Método para iniciar o processo
+     * 
+     * @param args Argumentos da linha de comandos. Se fornecido, args[0] deve ser
+     *             o caminho para um ficheiro de configuração personalizado.
+     */
+    public static void main(String[] args) {
+        System.out.println("=".repeat(60));
+        System.out.println("EXIT NODE PROCESS");
+        System.out.println("=".repeat(60));
+
+        try {
+            String configFile = args.length > 0 ? args[0] : "src/main/resources/simulation.properties";
+            System.out.println("Loading configuration from: " + configFile);
+
+            SimulationConfig config = new SimulationConfig(configFile);
+            ExitNodeProcess exitNode = new ExitNodeProcess(config);
+
+            System.out.println("\n" + "=".repeat(60));
+            exitNode.initialize();
+
+            System.out.println("\n" + "=".repeat(60));
+            exitNode.start();
+
+        } catch (IOException e) {
+            System.err.println("Failed to start exit node: " + e.getMessage());
+            System.exit(1);
+        } catch (Exception e) {
+            System.err.println("Exit node error: " + e.getMessage());
+            System.exit(1);
+        }
+    }
+
+    /**
+     * Constrói um novo processo de nó de saída.
+     * 
+     * Inicializa todas as estruturas de dados necessárias para recolher
+     * estatísticas
+     * e configura o pool de threads para processar as ligações concorrentes.
+     * 
+     * @param config Configuração da simulação contendo portas e endereços dos
+     *               serviços
+     */
+    public ExitNodeProcess(SimulationConfig config) {
+        this.config = config;
+        this.connectionHandlerPool = Executors.newCachedThreadPool();
+        this.running = false;
+
+        this.totalVehiclesReceived = 0;
+        this.totalSystemTime = 0.0;
+        this.totalWaitingTime = 0.0;
+        this.totalCrossingTime = 0.0;
+        this.vehicleTypeCount = new HashMap<>();
+        this.vehicleTypeWaitTime = new HashMap<>();
+
+        // Inicializa os counters para cada tipo de veículo
+        for (VehicleType type : VehicleType.values()) {
+            vehicleTypeCount.put(type, 0);
+            vehicleTypeWaitTime.put(type, 0.0);
+        }
+
+        System.out.println("Exit node initialized");
+        System.out.println("  - Exit port: " + config.getExitPort());
+        System.out.println("  - Dashboard: " + config.getDashboardHost() + ":" + config.getDashboardPort());
+    }
+
+    /**
+     * Inicializa o processo de ligação ao dashboard.
+     * 
+     * Tenta conectar-se ao dashboard. Se a ligação falhar, o processo
+     * continua a funcionar normalmente, mas sem enviar estatísticas.
+     * 
+     */
+    public void initialize() {
+        System.out.println("Connecting to dashboard...");
+
+        try {
+            String host = config.getDashboardHost();
+            int port = config.getDashboardPort();
+
+            dashboardClient = new SocketClient("Dashboard", host, port);
+            dashboardClient.connect();
+
+            System.out.println("Successfully connected to dashboard");
+        } catch (IOException e) {
+            System.err.println("WARNING: Failed to connect to dashboard: " + e.getMessage());
+            System.err.println("Exit node will continue without dashboard connection");
+        }
+    }
+
+    /**
+     * Inicia o socket e começa a aceitar ligações.
+     * 
+     * Este é o loop principal do processo que:
+     * 1. Cria um socket na porta definida
+     * 2. Aguarda pelas ligações das interseções
+     * 3. Delega cada ligação a uma thread da pool para processamento assíncrono
+     * 
+     * @throws IOException Se o socket não puder ser criado ou houver erro na
+     *                     aceitação
+     */
+    public void start() throws IOException {
+        int port = config.getExitPort();
+        serverSocket = new ServerSocket(port);
+        running = true;
+        simulationStartMillis = System.currentTimeMillis();
+
+        System.out.println("Exit node started on port " + port);
+        System.out.println("Waiting for vehicles...\\n");
+
+        while (running) {
+            try {
+                Socket clientSocket = serverSocket.accept();
+                connectionHandlerPool.submit(() -> handleIncomingConnection(clientSocket));
+            } catch (IOException e) {
+                if (running) {
+                    System.err.println("Error accepting connection: " + e.getMessage());
+                }
+            }
+        }
+    }
+
+    /**
+     * Processa uma ligação recebida de uma interseção.
+     * 
+     * Mantém a ligação aberta e processa continuamente mensagens do tipo
+     * VEHICLE_TRANSFER. Cada mensagem representa um veículo que chegou ao nó de
+     * saída.
+     * 
+     * @param clientSocket Socket da ligação estabelecida com a interseção
+     */
+    private void handleIncomingConnection(Socket clientSocket) {
+        String clientAddress = clientSocket.getInetAddress().getHostAddress();
+        System.out.println("New connection accepted from " + clientAddress);
+
+        try (SocketConnection connection = new SocketConnection(clientSocket)) {
+
+            while (running && connection.isConnected()) {
+                try {
+                    System.out.println("[Exit] Waiting for message from " + clientAddress);
+                    MessageProtocol message = connection.receiveMessage();
+                    System.out.println("[Exit] Received message type: " + message.getType() +
+                            " from " + message.getSourceNode());
+
+                    if (message.getType() == MessageType.SIMULATION_START) {
+                        // Coordinator sends start time - use it instead of our local start
+                        simulationStartMillis = ((Number) message.getPayload()).longValue();
+                        System.out.println("[Exit] Simulation start time synchronized");
+                    } else if (message.getType() == MessageType.VEHICLE_TRANSFER) {
+                        Object payload = message.getPayload();
+                        System.out.println("[Exit] Payload type: " + payload.getClass().getName());
+
+                        // Handle Gson LinkedHashMap
+                        Vehicle vehicle;
+                        if (payload instanceof com.google.gson.internal.LinkedTreeMap ||
+                                payload instanceof java.util.LinkedHashMap) {
+                            String json = new com.google.gson.Gson().toJson(payload);
+                            vehicle = new com.google.gson.Gson().fromJson(json, Vehicle.class);
+                        } else {
+                            vehicle = (Vehicle) payload;
+                        }
+
+                        processExitingVehicle(vehicle);
+                    }
+
+                } catch (ClassNotFoundException e) {
+                    System.err.println("[Exit] Unknown message type: " + e.getMessage());
+                    e.printStackTrace();
+                } catch (Exception e) {
+                    System.err.println("[Exit] Error processing message: " + e.getMessage());
+                    e.printStackTrace();
+                }
+            }
+
+            System.out.println("[Exit] Connection closed from " + clientAddress);
+
+        } catch (IOException e) {
+            if (running) {
+                System.err.println("[Exit] Connection error from " + clientAddress + ": " + e.getMessage());
+                e.printStackTrace();
+            }
+        }
+    }
+
+    /**
+     * Processa um veículo que chegou ao nó de saída.
+     * 
+     * Método sincronizado para garantir thread-safety ao atualizar as estatísticas.
+     * Calcula as métricas finais do veículo e atualiza:
+     * - Counters globais;
+     * - Estatísticas por tipo de veículo;
+     * - Faz update ao dashboard a cada 10 veículos.
+     * 
+     * @param vehicle Veículo que completou a sua rota
+     */
+    private synchronized void processExitingVehicle(Vehicle vehicle) {
+        totalVehiclesReceived++;
+
+        // Calculate relative simulation time (seconds since simulation start)
+        double currentSimTime = (System.currentTimeMillis() - simulationStartMillis) / 1000.0;
+        // System time = time vehicle spent in system (current time - entry time)
+        double systemTime = currentSimTime - vehicle.getEntryTime();
+        double waitTime = vehicle.getTotalWaitingTime();
+        double crossingTime = vehicle.getTotalCrossingTime();
+
+        // Store times in seconds, will be converted to ms when sending to dashboard
+        totalSystemTime += systemTime;
+        totalWaitingTime += waitTime;
+        totalCrossingTime += crossingTime;
+
+        VehicleType type = vehicle.getType();
+        vehicleTypeCount.put(type, vehicleTypeCount.get(type) + 1);
+        vehicleTypeWaitTime.put(type, vehicleTypeWaitTime.get(type) + waitTime);
+
+        System.out.printf("[Exit] Vehicle %s completed (type=%s, system_time=%.2fs, wait=%.2fs, crossing=%.2fs)%n",
+                vehicle.getId(), vehicle.getType(), systemTime, waitTime, crossingTime);
+
+        // Send stats after every vehicle to ensure dashboard updates quickly
+        sendStatsToDashboard();
+    }
+
+    /**
+     * Envia as estatísticas para o dashboard.
+     * 
+     * Prepara e envia uma mensagem STATS_UPDATE com:
+     * - O total de veículos processados;
+     * - A média dos tempos (sistema, espera, travessia);
+     * - As contagens e médias por cada tipo de veículo.
+     * 
+     */
+    private void sendStatsToDashboard() {
+        if (dashboardClient == null || !dashboardClient.isConnected()) {
+            return;
+        }
+
+        try {
+            // Create stats payload
+            StatsUpdatePayload payload = new StatsUpdatePayload();
+
+            // Set global stats - convert seconds to milliseconds
+            payload.setTotalVehiclesCompleted(totalVehiclesReceived);
+            payload.setTotalSystemTime((long) (totalSystemTime * 1000.0)); // s -> ms
+            payload.setTotalWaitingTime((long) (totalWaitingTime * 1000.0)); // s -> ms
+
+            // Set intersection-like stats so it shows up correctly in the dashboard table
+            payload.setIntersectionArrivals(totalVehiclesReceived);
+            payload.setIntersectionDepartures(totalVehiclesReceived);
+            payload.setIntersectionQueueSize(0);
+
+            // Set vehicle type stats
+            Map<VehicleType, Integer> typeCounts = new HashMap<>();
+            Map<VehicleType, Long> typeWaitTimes = new HashMap<>();
+
+            for (VehicleType type : VehicleType.values()) {
+                typeCounts.put(type, vehicleTypeCount.get(type));
+                typeWaitTimes.put(type, (long) (vehicleTypeWaitTime.get(type) * 1000.0)); // s -> ms
+            }
+
+            payload.setVehicleTypeCounts(typeCounts);
+            payload.setVehicleTypeWaitTimes(typeWaitTimes);
+
+            // Send message
+            Message message = new Message(
+                    MessageType.STATS_UPDATE,
+                    "ExitNode",
+                    "Dashboard",
+                    payload);
+
+            dashboardClient.send(message);
+
+            double avgWait = totalVehiclesReceived > 0 ? totalWaitingTime / totalVehiclesReceived : 0.0;
+            System.out.printf("[Exit] Sent stats to dashboard (total=%d, avg_wait=%.2fs)%n",
+                    totalVehiclesReceived, avgWait);
+
+        } catch (Exception e) {
+            System.err.println("[Exit] Failed to send stats to dashboard: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Termina o processo
+     * 
+     * Executa a seguinte sequência:
+     * Imprime as estatísticas finais no terminal;
+     * Envia a última atualização de estatísticas ao dashboard;
+     * Fecha o socket;
+     * Aguarda pela finalização das threads;
+     * Fecha a ligação com o dashboard;
+     */
+    public void shutdown() {
+        System.out.println("\n[Exit] Shutting down...");
+        running = false;
+
+        printFinalStatistics();
+
+        sendStatsToDashboard();
+
+        try {
+            if (serverSocket != null && !serverSocket.isClosed()) {
+                serverSocket.close();
+            }
+        } catch (IOException e) {
+            System.err.println("Error closing server socket: " + e.getMessage());
+        }
+
+        connectionHandlerPool.shutdown();
+        try {
+            if (!connectionHandlerPool.awaitTermination(5, TimeUnit.SECONDS)) {
+                connectionHandlerPool.shutdownNow();
+            }
+        } catch (InterruptedException e) {
+            connectionHandlerPool.shutdownNow();
+        }
+
+        if (dashboardClient != null) {
+            dashboardClient.close();
+        }
+
+        System.out.println("[Exit] Shutdown complete.");
+        System.out.println("=".repeat(60));
+    }
+
+    /**
+     * Imprime as estatísticas finais detalhadas no terminal
+     * 
+     * Gera um relatório com:
+     * Total de veículos que completaram a rota;
+     * Médias de tempo no sistema, espera e travessia;
+     * Distribuição e médias pelo tipo de veículo (BIKE, LIGHT, HEAVY);
+     * 
+     * Este método é chamado durante o shutdown para fornecer um resumo
+     * da simulação antes de terminar o processo.
+     */
+    private void printFinalStatistics() {
+        System.out.println("\n=== EXIT NODE STATISTICS ===");
+        System.out.printf("Total Vehicles Completed: %d%n", totalVehiclesReceived);
+
+        if (totalVehiclesReceived > 0) {
+            System.out.printf("%nAVERAGE METRICS:%n");
+            System.out.printf("  System Time: %.2f seconds%n", totalSystemTime / totalVehiclesReceived);
+            System.out.printf("  Waiting Time: %.2f seconds%n", totalWaitingTime / totalVehiclesReceived);
+            System.out.printf("  Crossing Time: %.2f seconds%n", totalCrossingTime / totalVehiclesReceived);
+        }
+
+        System.out.println("\nVEHICLE TYPE DISTRIBUTION:");
+        for (VehicleType type : VehicleType.values()) {
+            int count = vehicleTypeCount.get(type);
+            if (count > 0) {
+                double percentage = (count * 100.0) / totalVehiclesReceived;
+                double avgWait = vehicleTypeWaitTime.get(type) / count;
+                System.out.printf("  %s: %d (%.1f%%), Avg Wait: %.2fs%n",
+                        type, count, percentage, avgWait);
+            }
+        }
+    }
+
+}

main/src/main/java/sd/IntersectionProcess.java

@@ -0,0 +1,639 @@
+package sd;
+
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+import sd.config.SimulationConfig;
+import sd.coordinator.SocketClient;
+import sd.dashboard.StatsUpdatePayload;
+import sd.engine.TrafficLightThread;
+import sd.model.Intersection;
+import sd.model.Message;
+import sd.model.MessageType;
+import sd.model.TrafficLight;
+import sd.model.Vehicle;
+import sd.protocol.MessageProtocol;
+import sd.protocol.SocketConnection;
+import sd.serialization.SerializationException;
+
+/**
+ * Main class for an Intersection Process in the distributed traffic simulation.
+ * * Each IntersectionProcess runs as an independent Java application (JVM
+ * instance)
+ * representing one of the five intersections (Cr1-Cr5) in the network.
+ */
+public class IntersectionProcess {
+
+    private final String intersectionId;
+
+    private final SimulationConfig config;
+
+    private final Intersection intersection;
+
+    private ServerSocket serverSocket;
+
+    private final Map<String, SocketConnection> outgoingConnections;
+
+    private final ExecutorService connectionHandlerPool;
+
+    private final ExecutorService trafficLightPool;
+
+    private ScheduledExecutorService statsExecutor;
+
+    private volatile boolean running; // Quando uma thread escreve um valor volatile, todas as outras
+                                      // threads veem a mudança imediatamente.
+
+    // Traffic Light Coordination
+    /**
+     * Lock to ensure mutual exclusion between traffic lights.
+     * Only one traffic light can be green at any given time within this
+     * intersection.
+     */
+    private final Lock trafficCoordinationLock;
+
+    /**
+     * Tracks which direction currently has the green light.
+     * null means no direction is currently green (all are red).
+     */
+    private volatile String currentGreenDirection;
+
+    private SocketClient dashboardClient;
+    private volatile int totalArrivals = 0;
+    private volatile int totalDepartures = 0;
+
+    /**
+     * Constructs a new IntersectionProcess.
+     *
+     * @param intersectionId The ID of this intersection (e.g., "Cr1").
+     * @param configFilePath Path to the simulation.properties file.
+     * @throws IOException If configuration cannot be loaded.
+     */
+    public IntersectionProcess(String intersectionId, String configFilePath) throws IOException {
+        this.intersectionId = intersectionId;
+        this.config = new SimulationConfig(configFilePath);
+        this.intersection = new Intersection(intersectionId);
+        this.outgoingConnections = new HashMap<>();
+        this.connectionHandlerPool = Executors.newCachedThreadPool();
+        this.trafficLightPool = Executors.newFixedThreadPool(4); // Max 4 directions
+        this.statsExecutor = Executors.newSingleThreadScheduledExecutor();
+        this.running = false;
+        this.trafficCoordinationLock = new ReentrantLock(true); // Fair lock to prevent starvation
+        this.currentGreenDirection = null;
+
+        System.out.println("=".repeat(60));
+        System.out.println("INTERSECTION PROCESS: " + intersectionId);
+        System.out.println("=".repeat(60));
+    }
+
+    // Main entry point for running an intersection process
+    public static void main(String[] args) {
+        if (args.length < 1) {
+            System.err.println("Usage: java IntersectionProcess <intersectionId> [configFile]");
+            System.err.println("Example: java IntersectionProcess Cr1");
+            System.exit(1);
+        }
+
+        String intersectionId = args[0];
+        String configFile = args.length > 1 ? args[1] : "src/main/resources/simulation.properties";
+
+        try {
+            IntersectionProcess process = new IntersectionProcess(intersectionId, configFile);
+            process.initialize();
+            process.start();
+
+            // Add shutdown hook
+            Runtime.getRuntime().addShutdownHook(new Thread(() -> {
+                System.out.println("\nShutdown signal received...");
+                process.shutdown();
+            }));
+
+        } catch (IOException e) {
+            System.err.println("Failed to start intersection process: " + e.getMessage());
+            e.printStackTrace();
+            System.exit(1);
+        }
+    }
+
+    public void initialize() {
+        System.out.println("\n[" + intersectionId + "] Initializing intersection...");
+
+        createTrafficLights();
+
+        configureRouting();
+
+        connectToDashboard();
+
+        System.out.println("[" + intersectionId + "] Initialization complete.");
+    }
+
+    /**
+     * Establishes connection to the dashboard server for statistics reporting.
+     */
+    private void connectToDashboard() {
+        try {
+            String dashboardHost = config.getDashboardHost();
+            int dashboardPort = config.getDashboardPort();
+
+            System.out.println("[" + intersectionId + "] Connecting to dashboard at " +
+                    dashboardHost + ":" + dashboardPort + "...");
+
+            dashboardClient = new SocketClient(intersectionId, dashboardHost, dashboardPort);
+            dashboardClient.connect();
+
+            System.out.println("[" + intersectionId + "] Connected to dashboard.");
+
+        } catch (IOException e) {
+            System.err.println("[" + intersectionId + "] Failed to connect to dashboard: " +
+                    e.getMessage());
+            System.err.println("[" + intersectionId + "] Will continue without dashboard reporting.");
+            dashboardClient = null;
+        }
+    }
+
+    /**
+     * Creates traffic lights for this intersection based on its physical
+     * connections.
+     * Each intersection has different number and directions of traffic lights
+     * according to the network topology.
+     */
+    private void createTrafficLights() {
+        System.out.println("\n[" + intersectionId + "] Creating traffic lights...");
+
+        SimulationConfig.IntersectionConfig intersectionConfig = getIntersectionConfig();
+        List<String> directions = intersectionConfig.getLights();
+
+        if (directions == null || directions.isEmpty()) {
+            System.err.println("  Warning: No traffic lights configured for " + intersectionId);
+            return;
+        }
+
+        for (String direction : directions) {
+            double greenTime = config.getTrafficLightGreenTime(intersectionId, direction);
+            double redTime = config.getTrafficLightRedTime(intersectionId, direction);
+
+            TrafficLight light = new TrafficLight(
+                    intersectionId + "-" + direction,
+                    direction,
+                    greenTime,
+                    redTime);
+
+            intersection.addTrafficLight(light);
+            System.out.println("  Created traffic light: " + direction +
+                    " (Green: " + greenTime + "s, Red: " + redTime + "s)");
+        }
+    }
+
+    private SimulationConfig.IntersectionConfig getIntersectionConfig() {
+        if (config.getNetworkConfig() == null || config.getNetworkConfig().getIntersections() == null) {
+            throw new RuntimeException("Network configuration not loaded or empty.");
+        }
+        return config.getNetworkConfig().getIntersections().stream()
+                .filter(i -> i.getId().equals(intersectionId))
+                .findFirst()
+                .orElseThrow(() -> new RuntimeException("Intersection config not found for " + intersectionId));
+    }
+
+    private void configureRouting() {
+        System.out.println("\n[" + intersectionId + "] Configuring routing...");
+
+        SimulationConfig.IntersectionConfig intersectionConfig = getIntersectionConfig();
+        Map<String, String> routes = intersectionConfig.getRoutes();
+
+        if (routes != null) {
+            for (Map.Entry<String, String> entry : routes.entrySet()) {
+                String destination = entry.getKey();
+                String direction = entry.getValue();
+                intersection.configureRoute(destination, direction);
+                System.out.println("  Route configured: To " + destination + " -> Use " + direction);
+            }
+        } else {
+            System.out.println("  No routes configured.");
+        }
+
+        System.out.println("  Routing configured.");
+    }
+
+    /**
+     * Requests permission for a traffic light to turn green.
+     * Blocks until permission is granted (no other light is green).
+     * 
+     * @param direction The direction requesting green light
+     */
+    public void requestGreenLight(String direction) {
+        trafficCoordinationLock.lock();
+        currentGreenDirection = direction;
+    }
+
+    /**
+     * Releases the green light permission, allowing another light to turn green.
+     * 
+     * @param direction The direction releasing green light
+     */
+    public void releaseGreenLight(String direction) {
+        if (direction.equals(currentGreenDirection)) {
+            currentGreenDirection = null;
+            trafficCoordinationLock.unlock();
+        }
+    }
+
+    /**
+     * Starts all traffic light threads.
+     */
+    private void startTrafficLights() {
+        System.out.println("\n[" + intersectionId + "] Starting traffic light threads...");
+
+        for (TrafficLight light : intersection.getTrafficLights()) {
+
+            TrafficLightThread lightTask = new TrafficLightThread(light, this, config);
+
+            trafficLightPool.submit(lightTask);
+
+            System.out.println("  Started thread for: " + light.getDirection());
+        }
+    }
+
+    /**
+     * Sends a vehicle to its next destination via socket connection.
+     *
+     * @param vehicle The vehicle that has crossed this intersection.
+     */
+    public void sendVehicleToNextDestination(Vehicle vehicle) {
+        String nextDestination = vehicle.getCurrentDestination();
+
+        try {
+            // Get or create connection to next destination
+            SocketConnection connection = getOrCreateConnection(nextDestination);
+
+            // Create and send message using Message class
+            MessageProtocol message = new Message(
+                    MessageType.VEHICLE_TRANSFER,
+                    intersectionId,
+                    nextDestination,
+                    vehicle,
+                    System.currentTimeMillis());
+
+            connection.sendMessage(message);
+
+            System.out.println("[" + intersectionId + "] Sent vehicle " + vehicle.getId() +
+                    " to " + nextDestination);
+
+            // Record departure for statistics
+            recordVehicleDeparture();
+
+            // Note: vehicle route is advanced when it arrives at the next intersection
+
+        } catch (IOException | InterruptedException e) {
+            System.err.println("[" + intersectionId + "] Failed to send vehicle " +
+                    vehicle.getId() + " to " + nextDestination + ": " + e.getMessage());
+        }
+    }
+
+    /**
+     * Gets an existing connection to a destination or creates a new one.
+     *
+     * @param destinationId The ID of the destination node.
+     * @return The SocketConnection to that destination.
+     * @throws IOException          If connection cannot be established.
+     * @throws InterruptedException If connection attempt is interrupted.
+     */
+    private synchronized SocketConnection getOrCreateConnection(String destinationId)
+            throws IOException, InterruptedException {
+
+        if (!outgoingConnections.containsKey(destinationId)) {
+            String host = getHostForDestination(destinationId);
+            int port = getPortForDestination(destinationId);
+
+            System.out.println("[" + intersectionId + "] Creating connection to " +
+                    destinationId + " at " + host + ":" + port);
+
+            SocketConnection connection = new SocketConnection(host, port);
+            outgoingConnections.put(destinationId, connection);
+        }
+
+        return outgoingConnections.get(destinationId);
+    }
+
+    /**
+     * Gets the host address for a destination node from configuration.
+     *
+     * @param destinationId The destination node ID.
+     * @return The host address.
+     */
+    private String getHostForDestination(String destinationId) {
+        if (destinationId.equals("S")) {
+            return config.getExitHost();
+        } else {
+            return config.getIntersectionHost(destinationId);
+        }
+    }
+
+    /**
+     * Gets the port number for a destination node from configuration.
+     *
+     * @param destinationId The destination node ID.
+     * @return The port number.
+     */
+    private int getPortForDestination(String destinationId) {
+        if (destinationId.equals("S")) {
+            return config.getExitPort();
+        } else {
+            return config.getIntersectionPort(destinationId);
+        }
+    }
+
+    /**
+     * Starts the server socket and begins accepting incoming connections.
+     * This is the main listening loop of the process.
+     *
+     * @throws IOException If the server socket cannot be created.
+     */
+    public void start() throws IOException {
+        int port = config.getIntersectionPort(intersectionId);
+        serverSocket = new ServerSocket(port);
+        running = true;
+
+        System.out.println("\n[" + intersectionId + "] Server started on port " + port);
+
+        // Start traffic light threads when running is true
+        startTrafficLights();
+
+        // Start stats updater
+        statsExecutor.scheduleAtFixedRate(this::sendStatsToDashboard, 1, 1, TimeUnit.SECONDS);
+
+        System.out.println("[" + intersectionId + "] Waiting for incoming connections...\n");
+
+        // Main accept loop
+        while (running) {
+            try {
+                Socket clientSocket = serverSocket.accept();
+
+                System.out.println("[" + intersectionId + "] New connection accepted from " +
+                        clientSocket.getInetAddress().getHostAddress());
+
+                // Check running flag again before handling
+                if (!running) {
+                    clientSocket.close();
+                    break;
+                }
+
+                // **Set timeout before submitting to handler**
+                try {
+                    clientSocket.setSoTimeout(1000);
+                } catch (java.net.SocketException e) {
+                    System.err.println("[" + intersectionId + "] Failed to set timeout: " + e.getMessage());
+                    clientSocket.close();
+                    continue;
+                }
+
+                // Handle each connection in a separate thread
+                connectionHandlerPool.submit(() -> handleIncomingConnection(clientSocket));
+
+            } catch (IOException e) {
+                // Expected when serverSocket.close() is called during shutdown
+                if (!running) {
+                    break; // Normal shutdown
+                }
+                System.err.println("[" + intersectionId + "] Error accepting connection: " +
+                        e.getMessage());
+            }
+        }
+    }
+
+    /**
+     * Handles an incoming connection from another process.
+     * Continuously listens for vehicle transfer messages.
+     *
+     * @param clientSocket The accepted socket connection.
+     */
+    private void handleIncomingConnection(Socket clientSocket) {
+        try {
+            clientSocket.setSoTimeout(1000); // 1 second timeout
+
+        } catch (java.net.SocketException e) {
+            System.err.println("[" + intersectionId + "] Failed to set socket timeout: " + e.getMessage());
+            return;
+        }
+
+        try (SocketConnection connection = new SocketConnection(clientSocket)) {
+
+            System.out.println("[" + intersectionId + "] New connection accepted from " +
+                    clientSocket.getInetAddress().getHostAddress());
+
+            // Continuously receive messages while connection is active
+            while (running && connection.isConnected()) {
+                try {
+                    MessageProtocol message = connection.receiveMessage();
+
+                    // Handle simulation start time synchronization
+                    if (message.getType() == MessageType.SIMULATION_START) {
+                        System.out.println("[" + intersectionId + "] Simulation start time synchronized");
+                        continue;
+                    }
+
+                    // Accept both VEHICLE_TRANSFER and VEHICLE_SPAWN (from coordinator)
+                    if (message.getType() == MessageType.VEHICLE_TRANSFER ||
+                            message.getType() == MessageType.VEHICLE_SPAWN) {
+                        // Cast payload to Vehicle - handle Gson deserialization
+                        Vehicle vehicle;
+                        Object payload = message.getPayload();
+                        if (payload instanceof Vehicle) {
+                            vehicle = (Vehicle) payload;
+                        } else if (payload instanceof java.util.Map) {
+                            // Gson deserialized as LinkedHashMap - re-serialize and deserialize as Vehicle
+                            com.google.gson.Gson gson = new com.google.gson.Gson();
+                            String json = gson.toJson(payload);
+                            vehicle = gson.fromJson(json, Vehicle.class);
+                        } else {
+                            System.err.println("[" + intersectionId + "] Unknown payload type: " + payload.getClass());
+                            continue;
+                        }
+
+                        System.out.println("[" + intersectionId + "] Received vehicle: " +
+                                vehicle.getId() + " from " + message.getSourceNode());
+
+                        // Advance vehicle to next destination in its route
+                        vehicle.advanceRoute();
+
+                        // Add vehicle to appropriate queue
+                        intersection.receiveVehicle(vehicle);
+
+                        // Record arrival for statistics
+                        recordVehicleArrival();
+                    } else if (message.getType() == MessageType.SHUTDOWN) {
+                        System.out.println(
+                                "[" + intersectionId + "] Received SHUTDOWN command from " + message.getSourceNode());
+                        running = false;
+                        // Close this specific connection
+                        break;
+                    }
+
+                } catch (java.net.SocketTimeoutException e) {
+                    // Timeout - check running flag and continue
+                    if (!running) {
+                        break;
+                    }
+                    // Continue waiting for next message
+                } catch (ClassNotFoundException e) {
+                    System.err.println("[" + intersectionId + "] Unknown message type received: " +
+                            e.getMessage());
+                    break; // Invalid message, close connection
+                } catch (IOException e) {
+                    if (running) {
+                        System.err.println("[" + intersectionId + "] Failed to deserialize message: " +
+                                e.getMessage());
+                        e.printStackTrace(); // For debugging - maybe change//remove later
+                    }
+                    break; // Connection error, close connection
+                }
+            }
+
+        } catch (IOException e) {
+            if (running) {
+                System.err.println("[" + intersectionId + "] Connection error: " + e.getMessage());
+            }
+            // Expected during shutdown
+        }
+    }
+
+    /**
+     * Stops the intersection process gracefully.
+     * Shuts down all threads and closes all connections.
+     */
+    public void shutdown() {
+        // Check if already shutdown
+        if (!running) {
+            return; // Already shutdown, do nothing
+        }
+
+        System.out.println("\n[" + intersectionId + "] Shutting down...");
+        running = false;
+
+        // Send final stats before closing connections
+        sendStatsToDashboard();
+
+        // 1. Close ServerSocket first
+        if (serverSocket != null && !serverSocket.isClosed()) {
+            try {
+                serverSocket.close();
+            } catch (IOException e) {
+                // Expected
+            }
+        }
+
+        // 2. Shutdown thread pools with force
+        if (trafficLightPool != null && !trafficLightPool.isShutdown()) {
+            trafficLightPool.shutdownNow();
+        }
+        if (connectionHandlerPool != null && !connectionHandlerPool.isShutdown()) {
+            connectionHandlerPool.shutdownNow();
+        }
+        if (statsExecutor != null && !statsExecutor.isShutdown()) {
+            statsExecutor.shutdownNow();
+        }
+
+        // 3. Wait briefly for termination (don't block forever)
+        try {
+            if (trafficLightPool != null) {
+                trafficLightPool.awaitTermination(1, TimeUnit.SECONDS);
+            }
+            if (connectionHandlerPool != null) {
+                connectionHandlerPool.awaitTermination(1, TimeUnit.SECONDS);
+            }
+            if (statsExecutor != null) {
+                statsExecutor.awaitTermination(1, TimeUnit.SECONDS);
+            }
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+
+        // 4. Close outgoing connections
+        synchronized (outgoingConnections) {
+            for (SocketConnection conn : outgoingConnections.values()) {
+                try {
+                    conn.close();
+                } catch (Exception e) {
+                    // Ignore
+                }
+            }
+            outgoingConnections.clear();
+        }
+
+        // 5. Close dashboard connection
+        if (dashboardClient != null) {
+            dashboardClient.close();
+        }
+
+        System.out.println("[" + intersectionId + "] Shutdown complete.");
+        System.out.println("============================================================\n");
+    }
+
+    /**
+     * Gets the Intersection object managed by this process.
+     * Useful for testing and monitoring.
+     * 
+     * @return The Intersection object.
+     */
+    public Intersection getIntersection() {
+        return intersection;
+    }
+
+    /**
+     * Records that a vehicle has arrived at this intersection.
+     */
+    public void recordVehicleArrival() {
+        totalArrivals++;
+    }
+
+    /**
+     * Records that a vehicle has departed from this intersection.
+     */
+    public void recordVehicleDeparture() {
+        totalDepartures++;
+    }
+
+    /**
+     * Sends current statistics to the dashboard server.
+     */
+    private void sendStatsToDashboard() {
+        if (dashboardClient == null || !dashboardClient.isConnected()) {
+            return;
+        }
+
+        try {
+            // Calculate current queue size
+            int currentQueueSize = intersection.getTrafficLights().stream()
+                    .mapToInt(TrafficLight::getQueueSize)
+                    .sum();
+
+            StatsUpdatePayload payload = new StatsUpdatePayload()
+                    .setIntersectionArrivals(totalArrivals)
+                    .setIntersectionDepartures(totalDepartures)
+                    .setIntersectionQueueSize(currentQueueSize);
+
+            // Send StatsUpdatePayload directly as the message payload
+            sd.model.Message message = new sd.model.Message(
+                    MessageType.STATS_UPDATE,
+                    intersectionId,
+                    "Dashboard",
+                    payload);
+
+            dashboardClient.send(message);
+
+            System.out.printf("[%s] Sent stats to dashboard (arrivals=%d, departures=%d, queue=%d)%n",
+                    intersectionId, totalArrivals, totalDepartures, currentQueueSize);
+
+        } catch (SerializationException | IOException e) {
+            System.err.println("[" + intersectionId + "] Failed to send stats to dashboard: " + e.getMessage());
+        }
+    }
+}

main/src/main/java/sd/config/SimulationConfig.java

@@ -3,8 +3,16 @@ package sd.config;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
 import java.util.Properties;
 
+import com.google.gson.Gson;
+
 /**
  * Class to load and manage simulation configurations.
  * Configurations are read from a .properties file. This class provides
@@ -17,59 +25,144 @@ public class SimulationConfig {
      * Holds all properties loaded from the file.
      */
     private final Properties properties;
+    private NetworkConfig networkConfig;
+
+    public static class NetworkConfig {
+        private List<IntersectionConfig> intersections;
+
+        public List<IntersectionConfig> getIntersections() {
+            return intersections;
+        }
+    }
+
+    public static class IntersectionConfig {
+        private String id;
+        private List<String> lights;
+        private Map<String, String> routes;
+
+        public String getId() {
+            return id;
+        }
+
+        public List<String> getLights() {
+            return lights;
+        }
+
+        public Map<String, String> getRoutes() {
+            return routes;
+        }
+    }
 
     /**
      * Constructs a new SimulationConfig object by loading properties
      * from the specified file path.
      * 
-     * @param filePath The path to the .properties file (e.g., "src/main/resources/simulation.properties").
+     * This constructor attempts to load the configuration file using multiple
-     * @throws IOException If the file cannot be found or read.
+     * strategies:
+     * 1. Direct file system path
+     * 2. Classpath resource (with automatic path normalization)
+     * 3. Classpath resource with leading slash
+     *
+     * @param filePath The path to the .properties file (e.g.,
+     *                 "src/main/resources/simulation.properties").
+     * @throws IOException If the file cannot be found or read from any location.
      */
     public SimulationConfig(String filePath) throws IOException {
         properties = new Properties();
-        /**Tenta carregar diretamente a partir do sistema de ficheiros, se o ficheiro não existir
-         * (por exemplo quando executado a partir do classpath/jar),
-         * faz fallback para carregar a partir do classpath usando o ClassLoader.
-        */
-        IOException lastException = null;
 
-        try {
+        // List to track all attempted paths for better error reporting
+        List<String> attemptedPaths = new ArrayList<>();
+        IOException fileSystemException = null;
+
+        // Strategy 1: Try to load directly from file system
         try (InputStream input = new FileInputStream(filePath)) {
             properties.load(input);
-                return; // carregado com sucesso a partir do caminho fornecido
+            loadNetworkConfig();
-            }
+            return; // Successfully loaded from file system
         } catch (IOException e) {
-            lastException = e;
+            fileSystemException = e;
-            //tenta carregar a partir do classpath sem prefixos comuns
+            attemptedPaths.add("File system: " + filePath);
-            String resourcePath = filePath;
-            //Remove prefixos que apontam para src/main/resources quando presentes
-            resourcePath = resourcePath.replace("src/main/resources/", "").replace("src\\main\\resources\\", "");
-            //Remove prefixo classpath: se fornecido
-            if (resourcePath.startsWith("classpath:")) {
-                resourcePath = resourcePath.substring("classpath:".length());
-                if (resourcePath.startsWith("/")) resourcePath = resourcePath.substring(1);
         }
 
+        // Strategy 2: Try to load from classpath with path normalization
+        String resourcePath = filePath;
+
+        // Remove common src/main/resources prefixes
+        resourcePath = resourcePath.replace("src/main/resources/", "").replace("src\\main\\resources\\", "");
+
+        // Remove classpath: prefix if provided
+        if (resourcePath.startsWith("classpath:")) {
+            resourcePath = resourcePath.substring("classpath:".length());
+            if (resourcePath.startsWith("/")) {
+                resourcePath = resourcePath.substring(1);
+            }
+        }
+
+        // Try loading from classpath using thread context class loader
         InputStream resourceStream = Thread.currentThread().getContextClassLoader().getResourceAsStream(resourcePath);
+        attemptedPaths.add("Classpath (context): " + resourcePath);
+
         if (resourceStream == null) {
-                //como último recurso, tentar com um leading slash
+            // Strategy 3: Try with leading slash
-                resourceStream = SimulationConfig.class.getResourceAsStream('/' + resourcePath);
+            String slashPath = "/" + resourcePath;
+            resourceStream = SimulationConfig.class.getResourceAsStream(slashPath);
+            attemptedPaths.add("Classpath (class): " + slashPath);
         }
 
         if (resourceStream != null) {
             try (InputStream input = resourceStream) {
                 properties.load(input);
+                loadNetworkConfig();
+                return; // Successfully loaded from classpath
+            } catch (IOException e) {
+                // Failed to read from classpath resource
+                throw new IOException(
+                        String.format("Failed to read properties from classpath resource '%s': %s",
+                                resourcePath, e.getMessage()),
+                        e);
+            }
+        }
+
+        // All strategies failed - provide comprehensive error message
+        StringBuilder errorMsg = new StringBuilder();
+        errorMsg.append("Configuration file '").append(filePath).append("' could not be found.\n");
+        errorMsg.append("Attempted locations:\n");
+        for (String path : attemptedPaths) {
+            errorMsg.append("  - ").append(path).append("\n");
+        }
+
+        if (fileSystemException != null) {
+            errorMsg.append("\nOriginal error: ").append(fileSystemException.getMessage());
+        }
+
+        throw new IOException(errorMsg.toString(), fileSystemException);
+    }
+
+    private void loadNetworkConfig() {
+        try (InputStream is = getClass().getClassLoader().getResourceAsStream("network_config.json")) {
+            if (is == null) {
+                System.err.println("Warning: network_config.json not found in classpath. Using defaults/empty.");
                 return;
             }
+            try (Reader reader = new InputStreamReader(is, StandardCharsets.UTF_8)) {
+                Gson gson = new Gson();
+                this.networkConfig = gson.fromJson(reader, NetworkConfig.class);
+            }
+        } catch (IOException e) {
+            System.err.println("Failed to load network_config.json: " + e.getMessage());
+            e.printStackTrace();
         }
     }
-        if (lastException != null) throw lastException;
+
+    public NetworkConfig getNetworkConfig() {
+        return networkConfig;
     }
 
     // --- Network configurations ---
 
     /**
      * Gets the host address for a specific intersection.
+     * 
      * @param intersectionId The ID of the intersection (e.g., "Cr1").
      * @return The host (e.g., "localhost").
      */
@@ -79,6 +172,7 @@ public class SimulationConfig {
 
     /**
      * Gets the port number for a specific intersection.
+     * 
      * @param intersectionId The ID of the intersection (e.g., "Cr1").
      * @return The port number.
      */
@@ -88,6 +182,7 @@ public class SimulationConfig {
 
     /**
      * Gets the host address for the dashboard server.
+     * 
      * @return The dashboard host.
      */
     public String getDashboardHost() {
@@ -96,6 +191,7 @@ public class SimulationConfig {
 
     /**
      * Gets the port number for the dashboard server.
+     * 
      * @return The dashboard port.
      */
     public int getDashboardPort() {
@@ -104,6 +200,7 @@ public class SimulationConfig {
 
     /**
      * Gets the host address for the exit node.
+     * 
      * @return The exit node host.
      */
     public String getExitHost() {
@@ -112,6 +209,7 @@ public class SimulationConfig {
 
     /**
      * Gets the port number for the exit node.
+     * 
      * @return The exit node port.
      */
     public int getExitPort() {
@@ -122,14 +220,26 @@ public class SimulationConfig {
 
     /**
      * Gets the total duration of the simulation in virtual seconds.
+     * 
      * @return The simulation duration.
      */
     public double getSimulationDuration() {
         return Double.parseDouble(properties.getProperty("simulation.duration", "3600.0"));
     }
 
+    /**
+     * Gets the drain time (in virtual seconds) to allow vehicles to exit after
+     * generation stops.
+     * 
+     * @return The drain time.
+     */
+    public double getDrainTime() {
+        return Double.parseDouble(properties.getProperty("simulation.drain.time", "60.0"));
+    }
+
     /**
      * Gets the vehicle arrival model ("POISSON" or "FIXED").
+     * 
      * @return The arrival model as a string.
      */
     public String getArrivalModel() {
@@ -139,6 +249,7 @@ public class SimulationConfig {
     /**
      * Gets the average arrival rate (lambda) for the POISSON model.
      * This represents the average number of vehicles arriving per second.
+     * 
      * @return The arrival rate.
      */
     public double getArrivalRate() {
@@ -147,6 +258,7 @@ public class SimulationConfig {
 
     /**
      * Gets the fixed time interval between vehicle arrivals for the FIXED model.
+     * 
      * @return The fixed interval in seconds.
      */
     public double getFixedArrivalInterval() {
@@ -157,6 +269,7 @@ public class SimulationConfig {
 
     /**
      * Gets the duration of the GREEN light state for a specific traffic light.
+     * 
      * @param intersectionId The ID of the intersection (e.g., "Cr1").
      * @param direction      The direction of the light (e.g., "North").
      * @return The green light time in seconds.
@@ -168,6 +281,7 @@ public class SimulationConfig {
 
     /**
      * Gets the duration of the RED light state for a specific traffic light.
+     * 
      * @param intersectionId The ID of the intersection (e.g., "Cr1").
      * @param direction      The direction of the light (e.g., "North").
      * @return The red light time in seconds.
@@ -181,6 +295,7 @@ public class SimulationConfig {
 
     /**
      * Gets the probability (0.0 to 1.0) that a generated vehicle is of type LIGHT.
+     * 
      * @return The probability for LIGHT vehicles.
      */
     public double getLightVehicleProbability() {
@@ -189,6 +304,7 @@ public class SimulationConfig {
 
     /**
      * Gets the average time it takes a LIGHT vehicle to cross an intersection.
+     * 
      * @return The crossing time in seconds.
      */
     public double getLightVehicleCrossingTime() {
@@ -197,6 +313,7 @@ public class SimulationConfig {
 
     /**
      * Gets the probability (0.0 to 1.0) that a generated vehicle is of type BIKE.
+     * 
      * @return The probability for BIKE vehicles.
      */
     public double getBikeVehicleProbability() {
@@ -205,6 +322,7 @@ public class SimulationConfig {
 
     /**
      * Gets the average time it takes a BIKE vehicle to cross an intersection.
+     * 
      * @return The crossing time in seconds.
      */
     public double getBikeVehicleCrossingTime() {
@@ -213,6 +331,7 @@ public class SimulationConfig {
 
     /**
      * Gets the probability (0.0 to 1.0) that a generated vehicle is of type HEAVY.
+     * 
      * @return The probability for HEAVY vehicles.
      */
     public double getHeavyVehicleProbability() {
@@ -221,26 +340,58 @@ public class SimulationConfig {
 
     /**
      * Gets the average time it takes a HEAVY vehicle to cross an intersection.
+     * 
      * @return The crossing time in seconds.
      */
     public double getHeavyVehicleCrossingTime() {
         return Double.parseDouble(properties.getProperty("vehicle.crossing.time.heavy", "4.0"));
     }
 
+    /**
+     * Gets the base travel time between intersections for light vehicles.
+     * 
+     * @return The base travel time in seconds.
+     */
+    public double getBaseTravelTime() {
+        return Double.parseDouble(properties.getProperty("vehicle.travel.time.base", "8.0"));
+    }
+
+    /**
+     * Gets the travel time multiplier for bike vehicles.
+     * Bike travel time = base time × this multiplier.
+     * 
+     * @return The multiplier for bike travel time.
+     */
+    public double getBikeTravelTimeMultiplier() {
+        return Double.parseDouble(properties.getProperty("vehicle.travel.time.bike.multiplier", "0.5"));
+    }
+
+    /**
+     * Gets the travel time multiplier for heavy vehicles.
+     * Heavy vehicle travel time = base time × this multiplier.
+     * 
+     * @return The multiplier for heavy vehicle travel time.
+     */
+    public double getHeavyTravelTimeMultiplier() {
+        return Double.parseDouble(properties.getProperty("vehicle.travel.time.heavy.multiplier", "2.0"));
+    }
+
     // --- Statistics ---
 
     /**
      * Gets the interval (in virtual seconds) between periodic statistics updates.
+     * 
      * @return The statistics update interval.
      */
     public double getStatisticsUpdateInterval() {
-        return Double.parseDouble(properties.getProperty("statistics.update.interval", "10.0"));
+        return Double.parseDouble(properties.getProperty("statistics.update.interval", "1.0"));
     }
 
     // --- Generic getters ---
 
     /**
      * Generic method to get any property as a string, with a default value.
+     * 
      * @param key          The property key.
      * @param defaultValue The value to return if the key is not found.
      * @return The property value or the default.
@@ -251,6 +402,7 @@ public class SimulationConfig {
 
     /**
      * Generic method to get any property as a string.
+     * 
      * @param key The property key.
      * @return The property value, or null if not found.
      */

main/src/main/java/sd/coordinator/CoordinatorProcess.java

@@ -0,0 +1,302 @@
+package sd.coordinator;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+import sd.config.SimulationConfig;
+import sd.dashboard.StatsUpdatePayload;
+import sd.model.Message;
+import sd.model.MessageType;
+import sd.model.Vehicle;
+import sd.serialization.SerializationException;
+import sd.util.VehicleGenerator;
+
+/**
+ * Coordinator process responsible for:
+ * 1. Vehicle generation (using VehicleGenerator)
+ * 2. Distributing vehicles to intersection processes via sockets
+ * 3. Managing simulation timing and shutdown
+ * 
+ * This is the main entry point for the distributed simulation architecture.
+ */
+public class CoordinatorProcess {
+
+    private final SimulationConfig config;
+    private final VehicleGenerator vehicleGenerator;
+    private final Map<String, SocketClient> intersectionClients;
+    private SocketClient dashboardClient;
+    private double currentTime;
+    private int vehicleCounter;
+    private boolean running;
+    private double nextGenerationTime;
+
+    public static void main(String[] args) {
+        System.out.println("=".repeat(60));
+        System.out.println("COORDINATOR PROCESS - DISTRIBUTED TRAFFIC SIMULATION");
+        System.out.println("=".repeat(60));
+
+        try {
+            // 1. Load configuration
+            String configFile = args.length > 0 ? args[0] : "src/main/resources/simulation.properties";
+            System.out.println("Loading configuration from: " + configFile);
+
+            SimulationConfig config = new SimulationConfig(configFile);
+            CoordinatorProcess coordinator = new CoordinatorProcess(config);
+
+            // 2. Connect to intersection processes
+            System.out.println("\n" + "=".repeat(60));
+            coordinator.initialize();
+
+            // 3. Run the sim
+            System.out.println("\n" + "=".repeat(60));
+            coordinator.run();
+
+        } catch (IOException e) {
+            System.err.println("Failed to load configuration: " + e.getMessage());
+            System.exit(1);
+        } catch (Exception e) {
+            System.err.println("Coordinator error: " + e.getMessage());
+            System.exit(1);
+        }
+    }
+
+    public CoordinatorProcess(SimulationConfig config) {
+        this.config = config;
+        this.vehicleGenerator = new VehicleGenerator(config);
+        this.intersectionClients = new HashMap<>();
+        this.currentTime = 0.0;
+        this.vehicleCounter = 0;
+        this.running = false;
+        this.nextGenerationTime = 0.0;
+
+        System.out.println("Coordinator initialized with configuration:");
+        System.out.println("  - Simulation duration: " + config.getSimulationDuration() + "s");
+        System.out.println("  - Arrival model: " + config.getArrivalModel());
+        System.out.println("  - Arrival rate: " + config.getArrivalRate() + " vehicles/s");
+    }
+
+    public void initialize() {
+        // Connect to dashboard first
+        connectToDashboard();
+
+        System.out.println("Connecting to intersection processes...");
+
+        String[] intersectionIds = { "Cr1", "Cr2", "Cr3", "Cr4", "Cr5" };
+
+        for (String intersectionId : intersectionIds) {
+            try {
+                String host = config.getIntersectionHost(intersectionId);
+                int port = config.getIntersectionPort(intersectionId);
+
+                SocketClient client = new SocketClient(intersectionId, host, port);
+                client.connect();
+                intersectionClients.put(intersectionId, client);
+
+            } catch (IOException e) {
+                System.err.println("Failed to connect to " + intersectionId + ": " + e.getMessage());
+            }
+        }
+
+        System.out.println("Successfully connected to " + intersectionClients.size() + " intersection(s)");
+
+        if (intersectionClients.isEmpty()) {
+            System.err.println("WARNING: No intersections connected. Simulation cannot proceed.");
+        }
+    }
+
+    public void run() {
+        double duration = config.getSimulationDuration();
+        running = true;
+
+        System.out.println("Starting vehicle generation simulation...");
+        System.out.println("Duration: " + duration + " seconds");
+        System.out.println();
+
+        // Send simulation start time to all processes for synchronization
+        sendSimulationStartTime();
+
+        nextGenerationTime = vehicleGenerator.getNextArrivalTime(currentTime);
+        final double TIME_STEP = 0.1;
+
+        double drainTime = config.getDrainTime();
+        double totalDuration = duration + drainTime;
+        boolean draining = false;
+
+        while (running && currentTime < totalDuration) {
+            // Only generate vehicles during the main duration
+            if (currentTime < duration) {
+                if (currentTime >= nextGenerationTime) {
+                    generateAndSendVehicle();
+                    nextGenerationTime = vehicleGenerator.getNextArrivalTime(currentTime);
+                }
+            } else if (!draining) {
+                draining = true;
+                System.out.println("\n[t=" + String.format("%.2f", currentTime)
+                        + "] Generation complete. Entering DRAIN MODE for " + drainTime + "s...");
+            }
+
+            try {
+                Thread.sleep((long) (TIME_STEP * 1000));
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                break;
+            }
+
+            currentTime += TIME_STEP;
+        }
+
+        System.out.println();
+        System.out.println("Simulation complete at t=" + String.format("%.2f", currentTime) + "s");
+        System.out.println("Total vehicles generated: " + vehicleCounter);
+
+        shutdown();
+    }
+
+    private void generateAndSendVehicle() {
+        Vehicle vehicle = vehicleGenerator.generateVehicle("V" + (++vehicleCounter), currentTime);
+
+        System.out.printf("[t=%.2f] Vehicle %s generated (type=%s, route=%s)%n",
+                currentTime, vehicle.getId(), vehicle.getType(), vehicle.getRoute());
+
+        // Send generation count to dashboard
+        sendGenerationStatsToDashboard();
+
+        if (vehicle.getRoute().isEmpty()) {
+            System.err.println("ERROR: Vehicle " + vehicle.getId() + " has empty route!");
+            return;
+        }
+
+        String entryIntersection = vehicle.getRoute().get(0);
+        sendVehicleToIntersection(vehicle, entryIntersection);
+    }
+
+    private void sendVehicleToIntersection(Vehicle vehicle, String intersectionId) {
+        SocketClient client = intersectionClients.get(intersectionId);
+
+        if (client == null || !client.isConnected()) {
+            System.err.println("ERROR: No connection to " + intersectionId + " for vehicle " + vehicle.getId());
+            return;
+        }
+
+        try {
+            Message message = new Message(
+                    MessageType.VEHICLE_SPAWN,
+                    "COORDINATOR",
+                    intersectionId,
+                    vehicle);
+
+            client.send(message);
+            System.out.printf("->Sent to %s%n", intersectionId);
+
+        } catch (SerializationException | IOException e) {
+            System.err.println("ERROR: Failed to send vehicle " + vehicle.getId() + " to " + intersectionId);
+            System.err.println("Reason: " + e.getMessage());
+        }
+    }
+
+    public void shutdown() {
+        System.out.println();
+        System.out.println("=".repeat(60));
+        System.out.println("Shutting down coordinator...");
+
+        for (Map.Entry<String, SocketClient> entry : intersectionClients.entrySet()) {
+            String intersectionId = entry.getKey();
+            SocketClient client = entry.getValue();
+
+            try {
+                if (client.isConnected()) {
+                    Message personalizedShutdown = new Message(
+                            MessageType.SHUTDOWN,
+                            "COORDINATOR",
+                            intersectionId,
+                            "Simulation complete");
+                    client.send(personalizedShutdown);
+                    System.out.println("Sent shutdown message to " + intersectionId);
+                }
+            } catch (SerializationException | IOException e) {
+                System.err.println("Error sending shutdown to " + intersectionId + ": " + e.getMessage());
+            } finally {
+                client.close();
+            }
+        }
+
+        System.out.println("Coordinator shutdown complete");
+        System.out.println("=".repeat(60));
+    }
+
+    public void stop() {
+        System.out.println("\nStop signal received...");
+        running = false;
+    }
+
+    private void connectToDashboard() {
+        try {
+            String host = config.getDashboardHost();
+            int port = config.getDashboardPort();
+
+            System.out.println("Connecting to dashboard at " + host + ":" + port);
+            dashboardClient = new SocketClient("Dashboard", host, port);
+            dashboardClient.connect();
+            System.out.println("Successfully connected to dashboard\n");
+        } catch (IOException e) {
+            System.err.println("WARNING: Failed to connect to dashboard: " + e.getMessage());
+            System.err.println("Coordinator will continue without dashboard connection\n");
+        }
+    }
+
+    private void sendGenerationStatsToDashboard() {
+        if (dashboardClient == null || !dashboardClient.isConnected()) {
+            return;
+        }
+
+        try {
+            // Create stats payload with vehicle generation count
+            StatsUpdatePayload payload = new StatsUpdatePayload();
+            payload.setTotalVehiclesGenerated(vehicleCounter);
+
+            Message message = new Message(
+                    MessageType.STATS_UPDATE,
+                    "COORDINATOR",
+                    "Dashboard",
+                    payload);
+
+            dashboardClient.send(message);
+        } catch (Exception e) { // This is fine - can add IOException if need be
+            // Don't crash if dashboard update fails
+            System.err.println("Failed to send stats to dashboard: " + e.getMessage());
+        }
+    }
+
+    private void sendSimulationStartTime() {
+        long startTimeMillis = System.currentTimeMillis();
+
+        // Send to all intersections
+        for (Map.Entry<String, SocketClient> entry : intersectionClients.entrySet()) {
+            try {
+                Message message = new Message(
+                        MessageType.SIMULATION_START,
+                        "COORDINATOR",
+                        entry.getKey(),
+                        startTimeMillis);
+                entry.getValue().send(message);
+            } catch (Exception e) { // Same thing here
+                System.err.println("Failed to send start time to " + entry.getKey() + ": " + e.getMessage());
+            }
+        }
+
+        // Send to dashboard
+        if (dashboardClient != null && dashboardClient.isConnected()) {
+            try {
+                Message message = new Message(
+                        MessageType.SIMULATION_START,
+                        "COORDINATOR",
+                        "Dashboard",
+                        startTimeMillis);
+                dashboardClient.send(message);
+            } catch (Exception e) { // And here
+                // Don't crash
+            }
+        }
+    }
+}

main/src/main/java/sd/coordinator/SocketClient.java

@@ -0,0 +1,124 @@
+package sd.coordinator;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.Socket;
+
+import sd.model.Message;
+import sd.serialization.MessageSerializer;
+import sd.serialization.SerializationException;
+import sd.serialization.SerializerFactory;
+
+/**
+ * Socket client for communication with a single intersection process.
+ * 
+ * Handles a persistent TCP connection to one intersection,
+ * providing a simple way to send serialized messages.
+ */
+public class SocketClient {
+    
+    private final String intersectionId;
+    private final String host;
+    private final int port;
+    private Socket socket;
+    private OutputStream outputStream;
+    private MessageSerializer serializer;
+    
+    /**
+     * Creates a new SocketClient for a given intersection.
+     *
+     * @param intersectionId Intersection ID (ex. "Cr1")
+     * @param host Host address (ex. "localhost")
+     * @param port Port number
+     */
+    public SocketClient(String intersectionId, String host, int port) {
+        this.intersectionId = intersectionId;
+        this.host = host;
+        this.port = port;
+        this.serializer = SerializerFactory.createDefault();
+    }
+    
+    /**
+     * Connects to the intersection process via TCP.
+     * 
+     * @throws IOException if the connection cannot be established
+     */
+
+    public void connect() throws IOException {
+        try {
+            socket = new Socket(host, port);
+            outputStream = socket.getOutputStream();
+            System.out.println("Connected to " + intersectionId + " at " + host + ":" + port);
+        } catch (IOException e) {
+            System.err.println("Failed to connect to " + intersectionId + " at " + host + ":" + port);
+            throw e;
+        }
+    }
+    
+    /**
+     * Sends a message to the connected intersection.
+     * The message is serialized and written over the socket.
+     *
+     * @param message The message to send
+     * @throws SerializationException if serialization fails
+     * @throws IOException if the socket write fails
+     */
+    public void send(Message message) throws SerializationException, IOException {
+        if (socket == null || socket.isClosed()) {
+            throw new IOException("Socket is not connected to " + intersectionId);
+        }
+        
+        try {
+            byte[] data = serializer.serialize(message);
+            
+            // Prefix with message length (so receiver knows how much to read)
+            int length = data.length;
+            outputStream.write((length >> 24) & 0xFF);
+            outputStream.write((length >> 16) & 0xFF);
+            outputStream.write((length >> 8) & 0xFF);
+            outputStream.write(length & 0xFF);
+            
+            outputStream.write(data);
+            outputStream.flush();
+            
+        } catch (SerializationException | IOException e) {
+            System.err.println("Error sending message to " + intersectionId + ": " + e.getMessage());
+            throw e;
+        }
+    }
+    
+    /**
+     * Closes the socket connection safely.
+     * Calling it multiple times won’t cause issues.
+     */
+    public void close() {
+        try {
+            if (outputStream != null) {
+                outputStream.close();
+            }
+            if (socket != null && !socket.isClosed()) {
+                socket.close();
+                System.out.println("Closed connection to " + intersectionId);
+            }
+        } catch (IOException e) {
+            System.err.println("Error closing connection to " + intersectionId + ": " + e.getMessage());
+        }
+    }
+    
+    /**
+     * @return true if connected and socket is open, false otherwise
+     */
+    public boolean isConnected() {
+        return socket != null && socket.isConnected() && !socket.isClosed();
+    }
+    
+    public String getIntersectionId() {
+        return intersectionId;
+    }
+    
+    @Override
+    public String toString() {
+        return String.format("SocketClient[intersection=%s, host=%s, port=%d, connected=%s]",
+            intersectionId, host, port, isConnected());
+    }
+}

main/src/main/java/sd/dashboard/DashboardClientHandler.java

@@ -0,0 +1,137 @@
+package sd.dashboard;
+
+import java.io.IOException;
+import java.net.Socket;
+import java.util.Map;
+
+import sd.model.MessageType;
+import sd.protocol.MessageProtocol;
+import sd.protocol.SocketConnection;
+
+/**
+ * Processes statistics messages from a single client connection.
+ * Runs in a separate thread per client.
+ */
+public class DashboardClientHandler implements Runnable {
+    
+    private final Socket clientSocket;
+    private final DashboardStatistics statistics;
+    
+    public DashboardClientHandler(Socket clientSocket, DashboardStatistics statistics) {
+        this.clientSocket = clientSocket;
+        this.statistics = statistics;
+    }
+    
+    @Override
+    public void run() {
+        String clientInfo = clientSocket.getInetAddress().getHostAddress() + ":" + clientSocket.getPort();
+        
+        try (SocketConnection connection = new SocketConnection(clientSocket)) {
+            System.out.println("[Handler] Started handling client: " + clientInfo);
+            
+            while (!Thread.currentThread().isInterrupted()) {
+                try {
+                    MessageProtocol message = connection.receiveMessage();
+                    
+                    if (message == null) {
+                        System.out.println("[Handler] Client disconnected: " + clientInfo);
+                        break;
+                    }
+                    
+                    processMessage(message);
+                    
+                } catch (ClassNotFoundException e) {
+                    System.err.println("[Handler] Unknown message class from " + clientInfo + ": " + e.getMessage());
+                } catch (IOException e) {
+                    System.out.println("[Handler] Connection error with " + clientInfo + ": " + e.getMessage());
+                    break;
+                }
+            }
+            
+        } catch (IOException e) {
+            System.err.println("[Handler] Error initializing connection with " + clientInfo + ": " + e.getMessage());
+        } finally {
+            try {
+                if (!clientSocket.isClosed()) {
+                    clientSocket.close();
+                }
+            } catch (IOException e) {
+                System.err.println("[Handler] Error closing socket for " + clientInfo + ": " + e.getMessage());
+            }
+        }
+    }
+    
+    private void processMessage(MessageProtocol message) {
+        if (message.getType() != MessageType.STATS_UPDATE) {
+            System.out.println("[Handler] Ignoring non-statistics message type: " + message.getType());
+            return;
+        }
+        
+        String senderId = message.getSourceNode();
+        Object payload = message.getPayload();
+        
+        System.out.println("[Handler] Received STATS_UPDATE from: " + senderId);
+        
+        // Handle both direct StatsUpdatePayload and Gson-deserialized Map
+        StatsUpdatePayload stats;
+        if (payload instanceof StatsUpdatePayload) {
+            stats = (StatsUpdatePayload) payload;
+        } else if (payload instanceof java.util.Map) {
+            // Gson deserialized as LinkedHashMap - re-serialize and deserialize properly
+            com.google.gson.Gson gson = new com.google.gson.Gson();
+            String json = gson.toJson(payload);
+            stats = gson.fromJson(json, StatsUpdatePayload.class);
+        } else {
+            System.err.println("[Handler] Unknown payload type: " + 
+                (payload != null ? payload.getClass().getName() : "null"));
+            return;
+        }
+        
+        updateStatistics(senderId, stats);
+    }
+    
+    private void updateStatistics(String senderId, StatsUpdatePayload stats) {
+        if (stats.getTotalVehiclesGenerated() >= 0) {
+            statistics.updateVehiclesGenerated(stats.getTotalVehiclesGenerated());
+        }
+        
+        if (stats.getTotalVehiclesCompleted() >= 0) {
+            statistics.updateVehiclesCompleted(stats.getTotalVehiclesCompleted());
+        }
+        
+        // Exit Node sends cumulative totals, so we SET rather than ADD
+        if (stats.getTotalSystemTime() >= 0) {
+            statistics.setTotalSystemTime(stats.getTotalSystemTime());
+        }
+        
+        if (stats.getTotalWaitingTime() >= 0) {
+            statistics.setTotalWaitingTime(stats.getTotalWaitingTime());
+        }
+        
+        // Process vehicle type statistics (from Exit Node)
+        if (stats.getVehicleTypeCounts() != null && !stats.getVehicleTypeCounts().isEmpty()) {
+            Map<sd.model.VehicleType, Integer> counts = stats.getVehicleTypeCounts();
+            Map<sd.model.VehicleType, Long> waitTimes = stats.getVehicleTypeWaitTimes();
+            
+            for (var entry : counts.entrySet()) {
+                sd.model.VehicleType type = entry.getKey();
+                int count = entry.getValue();
+                long waitTime = (waitTimes != null && waitTimes.containsKey(type)) 
+                    ? waitTimes.get(type) : 0L;
+                statistics.updateVehicleTypeStats(type, count, waitTime);
+            }
+        }
+        
+        // Process intersection statistics (from Intersection processes)
+        if (senderId.startsWith("Cr") || senderId.startsWith("E")) {
+            statistics.updateIntersectionStats(
+                senderId,
+                stats.getIntersectionArrivals(),
+                stats.getIntersectionDepartures(),
+                stats.getIntersectionQueueSize()
+            );
+        }
+        
+        System.out.println("[Handler] Successfully updated statistics from: " + senderId);
+    }
+}

main/src/main/java/sd/dashboard/DashboardServer.java

@@ -0,0 +1,165 @@
+package sd.dashboard;
+
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import sd.config.SimulationConfig;
+
+/**
+ * Aggregates and displays real-time statistics from all simulation processes.
+ * Uses a thread pool to handle concurrent client connections.
+ */
+public class DashboardServer {
+    
+    private final int port;
+    private final DashboardStatistics statistics;
+    private final ExecutorService clientHandlerPool;
+    private final AtomicBoolean running;
+    private ServerSocket serverSocket;
+    
+    public static void main(String[] args) {
+        // Check if GUI mode is requested
+        boolean useGUI = false;
+        String configFile = "src/main/resources/simulation.properties";
+        
+        for (int i = 0; i < args.length; i++) {
+            if (args[i].equals("--gui") || args[i].equals("-g")) {
+                useGUI = true;
+            } else {
+                configFile = args[i];
+            }
+        }
+        
+        if (useGUI) {
+            // Launch JavaFX UI
+            System.out.println("Launching Dashboard with JavaFX GUI...");
+            DashboardUI.main(args);
+        } else {
+            // Traditional terminal mode
+            System.out.println("=".repeat(60));
+            System.out.println("DASHBOARD SERVER - DISTRIBUTED TRAFFIC SIMULATION");
+            System.out.println("=".repeat(60));
+            
+            try {
+                System.out.println("Loading configuration from: " + configFile);
+                
+                SimulationConfig config = new SimulationConfig(configFile);
+                DashboardServer server = new DashboardServer(config);
+                
+                // Start the server
+                System.out.println("\n" + "=".repeat(60));
+                server.start();
+                
+                // Keep running until interrupted
+                Runtime.getRuntime().addShutdownHook(new Thread(() -> {
+                    System.out.println("\n\nShutdown signal received...");
+                    server.stop();
+                }));
+                
+                // Display statistics periodically
+                server.displayLoop();
+                
+            } catch (IOException e) {
+                System.err.println("Failed to start Dashboard Server: " + e.getMessage());
+                System.exit(1);
+            }
+        }
+    }
+    
+    public DashboardServer(SimulationConfig config) {
+        this.port = config.getDashboardPort();
+        this.statistics = new DashboardStatistics();
+        this.clientHandlerPool = Executors.newFixedThreadPool(10);
+        this.running = new AtomicBoolean(false);
+    }
+    
+    public void start() throws IOException {
+        if (running.get()) {
+            System.out.println("Dashboard Server is already running.");
+            return;
+        }
+        
+        serverSocket = new ServerSocket(port);
+        running.set(true);
+        
+        System.out.println("Dashboard Server started on port " + port);
+        System.out.println("Waiting for statistics updates from simulation processes...");
+        System.out.println("=".repeat(60));
+        
+        Thread acceptThread = new Thread(this::acceptConnections, "DashboardServer-Accept");
+        acceptThread.setDaemon(false);
+        acceptThread.start();
+    }
+    
+    private void acceptConnections() {
+        while (running.get()) {
+            try {
+                Socket clientSocket = serverSocket.accept();
+                System.out.println("[Connection] New client connected: " + 
+                    clientSocket.getInetAddress().getHostAddress() + ":" + clientSocket.getPort());
+                
+                clientHandlerPool.execute(new DashboardClientHandler(clientSocket, statistics));
+                
+            } catch (IOException e) {
+                if (running.get()) {
+                    System.err.println("[Error] Failed to accept client connection: " + e.getMessage());
+                }
+            }
+        }
+    }
+    
+    @SuppressWarnings("BusyWait")
+    private void displayLoop() {
+        final long DISPLAY_INTERVAL_MS = 5000;
+        
+        while (running.get()) {
+            try {
+                Thread.sleep(DISPLAY_INTERVAL_MS);
+                displayStatistics();
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                break;
+            }
+        }
+    }
+    
+    public void displayStatistics() {
+        System.out.println("\n" + "=".repeat(60));
+        System.out.println("REAL-TIME SIMULATION STATISTICS");
+        System.out.println("=".repeat(60));
+        statistics.display();
+        System.out.println("=".repeat(60));
+    }
+    
+    public void stop() {
+        if (!running.get()) {
+            return;
+        }
+        
+        System.out.println("\nStopping Dashboard Server...");
+        running.set(false);
+        
+        try {
+            if (serverSocket != null && !serverSocket.isClosed()) {
+                serverSocket.close();
+            }
+        } catch (IOException e) {
+            System.err.println("Error closing server socket: " + e.getMessage());
+        }
+        
+        clientHandlerPool.shutdownNow();
+        System.out.println("Dashboard Server stopped.");
+    }
+    
+    public DashboardStatistics getStatistics() {
+        return statistics;
+    }
+    
+    public boolean isRunning() {
+        return running.get();
+    }
+}

main/src/main/java/sd/dashboard/DashboardStatistics.java

@@ -0,0 +1,224 @@
+package sd.dashboard;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+
+import sd.model.VehicleType;
+
+/**
+ * Thread-safe storage for aggregated simulation statistics.
+ * Uses atomic types and concurrent collections for lock-free updates.
+ */
+public class DashboardStatistics {
+    
+    private final AtomicInteger totalVehiclesGenerated;
+    private final AtomicInteger totalVehiclesCompleted;
+    private final AtomicLong totalSystemTime;
+    private final AtomicLong totalWaitingTime;
+    
+    private final Map<String, IntersectionStats> intersectionStats;
+    private final Map<VehicleType, AtomicInteger> vehicleTypeCount;
+    private final Map<VehicleType, AtomicLong> vehicleTypeWaitTime;
+    
+    private volatile long lastUpdateTime;
+    
+    public DashboardStatistics() {
+        this.totalVehiclesGenerated = new AtomicInteger(0);
+        this.totalVehiclesCompleted = new AtomicInteger(0);
+        this.totalSystemTime = new AtomicLong(0);
+        this.totalWaitingTime = new AtomicLong(0);
+        
+        this.intersectionStats = new ConcurrentHashMap<>();
+        this.vehicleTypeCount = new ConcurrentHashMap<>();
+        this.vehicleTypeWaitTime = new ConcurrentHashMap<>();
+        
+        for (VehicleType type : VehicleType.values()) {
+            vehicleTypeCount.put(type, new AtomicInteger(0));
+            vehicleTypeWaitTime.put(type, new AtomicLong(0));
+        }
+        
+        this.lastUpdateTime = System.currentTimeMillis();
+    }
+    
+    public void updateVehiclesGenerated(int count) {
+        totalVehiclesGenerated.set(count);
+        updateTimestamp();
+    }
+    
+    public void incrementVehiclesGenerated() {
+        totalVehiclesGenerated.incrementAndGet();
+        updateTimestamp();
+    }
+    
+    public void updateVehiclesCompleted(int count) {
+        totalVehiclesCompleted.set(count);
+        updateTimestamp();
+    }
+    
+    public void incrementVehiclesCompleted() {
+        totalVehiclesCompleted.incrementAndGet();
+        updateTimestamp();
+    }
+    
+    public void addSystemTime(long timeMs) {
+        totalSystemTime.addAndGet(timeMs);
+        updateTimestamp();
+    }
+    
+    public void setTotalSystemTime(long timeMs) {
+        totalSystemTime.set(timeMs);
+        updateTimestamp();
+    }
+    
+    public void addWaitingTime(long timeMs) {
+        totalWaitingTime.addAndGet(timeMs);
+        updateTimestamp();
+    }
+    
+    public void setTotalWaitingTime(long timeMs) {
+        totalWaitingTime.set(timeMs);
+        updateTimestamp();
+    }
+    
+    public void updateVehicleTypeStats(VehicleType type, int count, long waitTimeMs) {
+        vehicleTypeCount.get(type).set(count);
+        vehicleTypeWaitTime.get(type).set(waitTimeMs);
+        updateTimestamp();
+    }
+    
+    public void incrementVehicleType(VehicleType type) {
+        vehicleTypeCount.get(type).incrementAndGet();
+        updateTimestamp();
+    }
+    
+    public void updateIntersectionStats(String intersectionId, int arrivals, 
+                                       int departures, int currentQueueSize) {
+        intersectionStats.compute(intersectionId, (id, stats) -> {
+            if (stats == null) {
+                stats = new IntersectionStats(intersectionId);
+            }
+            stats.updateStats(arrivals, departures, currentQueueSize);
+            return stats;
+        });
+        updateTimestamp();
+    }
+    
+    private void updateTimestamp() {
+        lastUpdateTime = System.currentTimeMillis();
+    }
+    
+    public int getTotalVehiclesGenerated() {
+        return totalVehiclesGenerated.get();
+    }
+    
+    public int getTotalVehiclesCompleted() {
+        return totalVehiclesCompleted.get();
+    }
+    
+    public double getAverageSystemTime() {
+        int completed = totalVehiclesCompleted.get();
+        if (completed == 0) return 0.0;
+        return (double) totalSystemTime.get() / completed;
+    }
+    
+    public double getAverageWaitingTime() {
+        int completed = totalVehiclesCompleted.get();
+        if (completed == 0) return 0.0;
+        return (double) totalWaitingTime.get() / completed;
+    }
+    
+    public int getVehicleTypeCount(VehicleType type) {
+        return vehicleTypeCount.get(type).get();
+    }
+    
+    public double getAverageWaitingTimeByType(VehicleType type) {
+        int count = vehicleTypeCount.get(type).get();
+        if (count == 0) return 0.0;
+        return (double) vehicleTypeWaitTime.get(type).get() / count;
+    }
+    
+    public IntersectionStats getIntersectionStats(String intersectionId) {
+        return intersectionStats.get(intersectionId);
+    }
+    
+    public Map<String, IntersectionStats> getAllIntersectionStats() {
+        return new HashMap<>(intersectionStats);
+    }
+    
+    public long getLastUpdateTime() {
+        return lastUpdateTime;
+    }
+    
+    public void display() {
+        System.out.println("\n--- GLOBAL STATISTICS ---");
+        System.out.printf("Total Vehicles Generated: %d%n", getTotalVehiclesGenerated());
+        System.out.printf("Total Vehicles Completed: %d%n", getTotalVehiclesCompleted());
+        System.out.printf("Vehicles In Transit: %d%n", 
+            getTotalVehiclesGenerated() - getTotalVehiclesCompleted());
+        System.out.printf("Average System Time: %.2f ms%n", getAverageSystemTime());
+        System.out.printf("Average Waiting Time: %.2f ms%n", getAverageWaitingTime());
+        
+        System.out.println("\n--- VEHICLE TYPE STATISTICS ---");
+        for (VehicleType type : VehicleType.values()) {
+            int count = getVehicleTypeCount(type);
+            double avgWait = getAverageWaitingTimeByType(type);
+            System.out.printf("%s: %d vehicles, avg wait: %.2f ms%n", 
+                type, count, avgWait);
+        }
+        
+        System.out.println("\n--- INTERSECTION STATISTICS ---");
+        if (intersectionStats.isEmpty()) {
+            System.out.println("(No data received yet)");
+        } else {
+            for (IntersectionStats stats : intersectionStats.values()) {
+                stats.display();
+            }
+        }
+        
+        System.out.printf("%nLast Update: %tT%n", lastUpdateTime);
+    }
+    
+    public static class IntersectionStats {
+        private final String intersectionId;
+        private final AtomicInteger totalArrivals;
+        private final AtomicInteger totalDepartures;
+        private final AtomicInteger currentQueueSize;
+        
+        public IntersectionStats(String intersectionId) {
+            this.intersectionId = intersectionId;
+            this.totalArrivals = new AtomicInteger(0);
+            this.totalDepartures = new AtomicInteger(0);
+            this.currentQueueSize = new AtomicInteger(0);
+        }
+        
+        public void updateStats(int arrivals, int departures, int queueSize) {
+            this.totalArrivals.set(arrivals);
+            this.totalDepartures.set(departures);
+            this.currentQueueSize.set(queueSize);
+        }
+        
+        public String getIntersectionId() {
+            return intersectionId;
+        }
+        
+        public int getTotalArrivals() {
+            return totalArrivals.get();
+        }
+        
+        public int getTotalDepartures() {
+            return totalDepartures.get();
+        }
+        
+        public int getCurrentQueueSize() {
+            return currentQueueSize.get();
+        }
+        
+        public void display() {
+            System.out.printf("%s: Arrivals=%d, Departures=%d, Queue=%d%n",
+                intersectionId, getTotalArrivals(), getTotalDepartures(), getCurrentQueueSize());
+        }
+    }
+}

main/src/main/java/sd/dashboard/DashboardUI.java

@@ -0,0 +1,450 @@
+package sd.dashboard;
+
+import java.io.IOException;
+import java.util.Map;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+import javafx.application.Application;
+import javafx.application.Platform;
+import javafx.geometry.Insets;
+import javafx.geometry.Pos;
+import javafx.scene.Scene;
+import javafx.scene.control.Alert;
+import javafx.scene.control.Button;
+import javafx.scene.control.Label;
+import javafx.scene.control.TableColumn;
+import javafx.scene.control.TableView;
+import javafx.scene.control.cell.PropertyValueFactory;
+import javafx.scene.layout.BorderPane;
+import javafx.scene.layout.GridPane;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.Priority;
+import javafx.scene.layout.Region;
+import javafx.scene.layout.VBox;
+import javafx.scene.shape.Circle;
+import javafx.stage.Stage;
+import sd.config.SimulationConfig;
+import sd.model.VehicleType;
+
+/**
+ * JavaFX-based Dashboard UI for displaying real-time simulation statistics.
+ * Provides a graphical interface with auto-updating statistics panels.
+ */
+public class DashboardUI extends Application {
+
+    private DashboardServer server;
+    private DashboardStatistics statistics;
+
+    // Global Statistics Labels
+    private Label lblVehiclesGenerated;
+    private Label lblVehiclesCompleted;
+    private Label lblVehiclesInTransit;
+    private Label lblAvgSystemTime;
+    private Label lblAvgWaitingTime;
+    private Label lblLastUpdate;
+
+    // Vehicle Type Table
+    private TableView<VehicleTypeRow> vehicleTypeTable;
+
+    // Intersection Table
+    private TableView<IntersectionRow> intersectionTable;
+
+    // Update scheduler
+    private ScheduledExecutorService updateScheduler;
+
+    @Override
+    public void start(Stage primaryStage) {
+        try {
+            // Initialize server
+            String configFile = getParameters().getRaw().isEmpty()
+                    ? "src/main/resources/simulation.properties"
+                    : getParameters().getRaw().get(0);
+
+            SimulationConfig config = new SimulationConfig(configFile);
+            server = new DashboardServer(config);
+            statistics = server.getStatistics();
+
+            // Start the dashboard server
+            server.start();
+
+            // Build UI
+            BorderPane root = new BorderPane();
+            root.getStyleClass().add("root");
+
+            // Header
+            VBox header = createHeader();
+            root.setTop(header);
+
+            // Main content
+            VBox mainContent = createMainContent();
+            root.setCenter(mainContent);
+
+            // Footer
+            HBox footer = createFooter();
+            root.setBottom(footer);
+
+            // Create scene
+            Scene scene = new Scene(root, 1200, 850);
+
+            // Load CSS
+            String cssUrl = getClass().getResource("/dashboard.css").toExternalForm();
+            scene.getStylesheets().add(cssUrl);
+
+            primaryStage.setTitle("Traffic Simulation Dashboard - Real-time Statistics");
+            primaryStage.setScene(scene);
+            primaryStage.show();
+
+            // Start periodic updates
+            startPeriodicUpdates();
+
+            // Handle window close
+            primaryStage.setOnCloseRequest(event -> {
+                shutdown();
+            });
+
+        } catch (Exception e) {
+            showErrorAlert("Failed to start Dashboard Server", e.getMessage());
+            e.printStackTrace();
+            Platform.exit();
+        }
+    }
+
+    private VBox createHeader() {
+        VBox header = new VBox(10);
+        header.getStyleClass().add("header");
+        header.setAlignment(Pos.CENTER);
+
+        Label title = new Label("DISTRIBUTED TRAFFIC SIMULATION DASHBOARD");
+        title.getStyleClass().add("header-title");
+
+        Label subtitle = new Label("Real-time Statistics and Monitoring");
+        subtitle.getStyleClass().add("header-subtitle");
+
+        // Control Buttons
+        HBox controls = new HBox(15);
+        controls.setAlignment(Pos.CENTER);
+
+        Button btnStart = new Button("START SIMULATION");
+        btnStart.getStyleClass().add("button-start");
+
+        Button btnStop = new Button("STOP SIMULATION");
+        btnStop.getStyleClass().add("button-stop");
+        btnStop.setDisable(true);
+
+        SimulationProcessManager processManager = new SimulationProcessManager();
+
+        btnStart.setOnAction(e -> {
+            try {
+                processManager.startSimulation();
+                btnStart.setDisable(true);
+                btnStop.setDisable(false);
+            } catch (IOException ex) {
+                showErrorAlert("Start Failed", "Could not start simulation processes: " + ex.getMessage());
+            }
+        });
+
+        btnStop.setOnAction(e -> {
+            processManager.stopSimulation();
+            btnStart.setDisable(false);
+            btnStop.setDisable(true);
+        });
+
+        controls.getChildren().addAll(btnStart, btnStop);
+
+        header.getChildren().addAll(title, subtitle, controls);
+
+        return header;
+    }
+
+    private VBox createMainContent() {
+        VBox mainContent = new VBox(20);
+        mainContent.setPadding(new Insets(20));
+
+        // Global Statistics Panel
+        VBox globalStatsCard = createGlobalStatisticsPanel();
+
+        // Tables Container
+        HBox tablesContainer = new HBox(20);
+        tablesContainer.setAlignment(Pos.TOP_CENTER);
+
+        // Vehicle Type Statistics Panel
+        VBox vehicleTypeCard = createVehicleTypePanel();
+        HBox.setHgrow(vehicleTypeCard, Priority.ALWAYS);
+
+        // Intersection Statistics Panel
+        VBox intersectionCard = createIntersectionPanel();
+        HBox.setHgrow(intersectionCard, Priority.ALWAYS);
+
+        tablesContainer.getChildren().addAll(vehicleTypeCard, intersectionCard);
+
+        mainContent.getChildren().addAll(globalStatsCard, tablesContainer);
+
+        return mainContent;
+    }
+
+    private VBox createGlobalStatisticsPanel() {
+        VBox card = new VBox();
+        card.getStyleClass().add("card");
+
+        // Card Header
+        HBox cardHeader = new HBox();
+        cardHeader.getStyleClass().add("card-header");
+        Label cardTitle = new Label("Global Statistics");
+        cardTitle.getStyleClass().add("card-title");
+        cardHeader.getChildren().add(cardTitle);
+
+        // Card Content
+        GridPane grid = new GridPane();
+        grid.getStyleClass().add("card-content");
+        grid.setHgap(40);
+        grid.setVgap(15);
+        grid.setAlignment(Pos.CENTER);
+
+        // Initialize labels
+        lblVehiclesGenerated = createStatValueLabel("0");
+        lblVehiclesCompleted = createStatValueLabel("0");
+        lblVehiclesInTransit = createStatValueLabel("0");
+        lblAvgSystemTime = createStatValueLabel("0.00 s");
+        lblAvgWaitingTime = createStatValueLabel("0.00 s");
+
+        // Add labels with descriptions
+        addStatRow(grid, 0, 0, "Total Vehicles Generated", lblVehiclesGenerated);
+        addStatRow(grid, 1, 0, "Total Vehicles Completed", lblVehiclesCompleted);
+        addStatRow(grid, 2, 0, "Vehicles In Transit", lblVehiclesInTransit);
+        addStatRow(grid, 0, 1, "Average System Time", lblAvgSystemTime);
+        addStatRow(grid, 1, 1, "Average Waiting Time", lblAvgWaitingTime);
+
+        card.getChildren().addAll(cardHeader, grid);
+        return card;
+    }
+
+    private VBox createVehicleTypePanel() {
+        VBox card = new VBox();
+        card.getStyleClass().add("card");
+
+        // Card Header
+        HBox cardHeader = new HBox();
+        cardHeader.getStyleClass().add("card-header");
+        Label cardTitle = new Label("Vehicle Type Statistics");
+        cardTitle.getStyleClass().add("card-title");
+        cardHeader.getChildren().add(cardTitle);
+
+        // Table
+        vehicleTypeTable = new TableView<>();
+        vehicleTypeTable.setColumnResizePolicy(TableView.CONSTRAINED_RESIZE_POLICY);
+        vehicleTypeTable.setPrefHeight(300);
+
+        TableColumn<VehicleTypeRow, String> typeCol = new TableColumn<>("Vehicle Type");
+        typeCol.setCellValueFactory(new PropertyValueFactory<>("vehicleType"));
+
+        TableColumn<VehicleTypeRow, Integer> countCol = new TableColumn<>("Count");
+        countCol.setCellValueFactory(new PropertyValueFactory<>("count"));
+
+        TableColumn<VehicleTypeRow, String> avgWaitCol = new TableColumn<>("Avg Wait Time");
+        avgWaitCol.setCellValueFactory(new PropertyValueFactory<>("avgWaitTime"));
+
+        vehicleTypeTable.getColumns().addAll(typeCol, countCol, avgWaitCol);
+
+        card.getChildren().addAll(cardHeader, vehicleTypeTable);
+        return card;
+    }
+
+    private VBox createIntersectionPanel() {
+        VBox card = new VBox();
+        card.getStyleClass().add("card");
+
+        // Card Header
+        HBox cardHeader = new HBox();
+        cardHeader.getStyleClass().add("card-header");
+        Label cardTitle = new Label("Intersection Statistics");
+        cardTitle.getStyleClass().add("card-title");
+        cardHeader.getChildren().add(cardTitle);
+
+        // Table
+        intersectionTable = new TableView<>();
+        intersectionTable.setColumnResizePolicy(TableView.CONSTRAINED_RESIZE_POLICY);
+        intersectionTable.setPrefHeight(300);
+
+        TableColumn<IntersectionRow, String> idCol = new TableColumn<>("Intersection ID");
+        idCol.setCellValueFactory(new PropertyValueFactory<>("intersectionId"));
+
+        TableColumn<IntersectionRow, Integer> arrivalsCol = new TableColumn<>("Total Arrivals");
+        arrivalsCol.setCellValueFactory(new PropertyValueFactory<>("arrivals"));
+
+        TableColumn<IntersectionRow, Integer> departuresCol = new TableColumn<>("Total Departures");
+        departuresCol.setCellValueFactory(new PropertyValueFactory<>("departures"));
+
+        TableColumn<IntersectionRow, Integer> queueCol = new TableColumn<>("Current Queue");
+        queueCol.setCellValueFactory(new PropertyValueFactory<>("queueSize"));
+
+        intersectionTable.getColumns().addAll(idCol, arrivalsCol, departuresCol, queueCol);
+
+        card.getChildren().addAll(cardHeader, intersectionTable);
+        return card;
+    }
+
+    private HBox createFooter() {
+        HBox footer = new HBox(10);
+        footer.getStyleClass().add("footer");
+        footer.setAlignment(Pos.CENTER_LEFT);
+
+        Label statusLabel = new Label("Status:");
+        statusLabel.getStyleClass().add("footer-text");
+        statusLabel.setStyle("-fx-font-weight: bold;");
+
+        Circle statusIndicator = new Circle(6);
+        statusIndicator.setFill(javafx.scene.paint.Color.LIME);
+
+        Label statusText = new Label("Connected and Receiving Data");
+        statusText.getStyleClass().add("footer-text");
+
+        lblLastUpdate = new Label("Last Update: --:--:--");
+        lblLastUpdate.getStyleClass().add("footer-text");
+
+        Region spacer = new Region();
+        HBox.setHgrow(spacer, Priority.ALWAYS);
+
+        footer.getChildren().addAll(statusLabel, statusIndicator, statusText, spacer, lblLastUpdate);
+
+        return footer;
+    }
+
+    private Label createStatValueLabel(String initialValue) {
+        Label label = new Label(initialValue);
+        label.getStyleClass().add("stat-value");
+        return label;
+    }
+
+    private void addStatRow(GridPane grid, int row, int colGroup, String description, Label valueLabel) {
+        VBox container = new VBox(5);
+        container.setAlignment(Pos.CENTER_LEFT);
+
+        Label descLabel = new Label(description);
+        descLabel.getStyleClass().add("stat-label");
+
+        container.getChildren().addAll(descLabel, valueLabel);
+
+        grid.add(container, colGroup, row);
+    }
+
+    private void startPeriodicUpdates() {
+        updateScheduler = Executors.newSingleThreadScheduledExecutor();
+        updateScheduler.scheduleAtFixedRate(() -> {
+            Platform.runLater(this::updateUI);
+        }, 0, 5, TimeUnit.SECONDS);
+    }
+
+    private void updateUI() {
+        // Update global statistics
+        lblVehiclesGenerated.setText(String.valueOf(statistics.getTotalVehiclesGenerated()));
+        lblVehiclesCompleted.setText(String.valueOf(statistics.getTotalVehiclesCompleted()));
+        lblVehiclesInTransit.setText(String.valueOf(
+                statistics.getTotalVehiclesGenerated() - statistics.getTotalVehiclesCompleted()));
+        lblAvgSystemTime.setText(String.format("%.2f s", statistics.getAverageSystemTime() / 1000.0));
+        lblAvgWaitingTime.setText(String.format("%.2f s", statistics.getAverageWaitingTime() / 1000.0));
+        lblLastUpdate.setText(String.format("Last Update: %tT", statistics.getLastUpdateTime()));
+
+        // Update vehicle type table
+        vehicleTypeTable.getItems().clear();
+        for (VehicleType type : VehicleType.values()) {
+            int count = statistics.getVehicleTypeCount(type);
+            double avgWait = statistics.getAverageWaitingTimeByType(type);
+            vehicleTypeTable.getItems().add(new VehicleTypeRow(
+                    type.toString(), count, String.format("%.2f s", avgWait / 1000.0)));
+        }
+
+        // Update intersection table
+        intersectionTable.getItems().clear();
+        Map<String, DashboardStatistics.IntersectionStats> intersectionStats = statistics.getAllIntersectionStats();
+        for (DashboardStatistics.IntersectionStats stats : intersectionStats.values()) {
+            intersectionTable.getItems().add(new IntersectionRow(
+                    stats.getIntersectionId(),
+                    stats.getTotalArrivals(),
+                    stats.getTotalDepartures(),
+                    stats.getCurrentQueueSize()));
+        }
+    }
+
+    private void shutdown() {
+        System.out.println("Shutting down Dashboard UI...");
+
+        if (updateScheduler != null && !updateScheduler.isShutdown()) {
+            updateScheduler.shutdownNow();
+        }
+
+        if (server != null) {
+            server.stop();
+        }
+
+        Platform.exit();
+    }
+
+    private void showErrorAlert(String title, String message) {
+        Alert alert = new Alert(Alert.AlertType.ERROR);
+        alert.setTitle(title);
+        alert.setHeaderText(null);
+        alert.setContentText(message);
+        alert.showAndWait();
+    }
+
+    public static void main(String[] args) {
+        launch(args);
+    }
+
+    // Inner classes for TableView data models
+    public static class VehicleTypeRow {
+        private final String vehicleType;
+        private final int count;
+        private final String avgWaitTime;
+
+        public VehicleTypeRow(String vehicleType, int count, String avgWaitTime) {
+            this.vehicleType = vehicleType;
+            this.count = count;
+            this.avgWaitTime = avgWaitTime;
+        }
+
+        public String getVehicleType() {
+            return vehicleType;
+        }
+
+        public int getCount() {
+            return count;
+        }
+
+        public String getAvgWaitTime() {
+            return avgWaitTime;
+        }
+    }
+
+    public static class IntersectionRow {
+        private final String intersectionId;
+        private final int arrivals;
+        private final int departures;
+        private final int queueSize;
+
+        public IntersectionRow(String intersectionId, int arrivals, int departures, int queueSize) {
+            this.intersectionId = intersectionId;
+            this.arrivals = arrivals;
+            this.departures = departures;
+            this.queueSize = queueSize;
+        }
+
+        public String getIntersectionId() {
+            return intersectionId;
+        }
+
+        public int getArrivals() {
+            return arrivals;
+        }
+
+        public int getDepartures() {
+            return departures;
+        }
+
+        public int getQueueSize() {
+            return queueSize;
+        }
+    }
+}

main/src/main/java/sd/dashboard/Launcher.java

@@ -0,0 +1,7 @@
+package sd.dashboard;
+
+public class Launcher {
+    public static void main(String[] args) {
+        DashboardUI.main(args);
+    }
+}

main/src/main/java/sd/dashboard/SimulationProcessManager.java

@@ -0,0 +1,118 @@
+package sd.dashboard;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Manages the lifecycle of simulation processes (Intersections, Exit Node,
+ * Coordinator).
+ * Allows starting and stopping the distributed simulation from within the Java
+ * application.
+ */
+public class SimulationProcessManager {
+
+    private final List<Process> runningProcesses;
+    private final String classpath;
+
+    public SimulationProcessManager() {
+        this.runningProcesses = new ArrayList<>();
+        this.classpath = System.getProperty("java.class.path");
+    }
+
+    /**
+     * Starts the full simulation: 5 Intersections, 1 Exit Node, and 1 Coordinator.
+     * 
+     * @throws IOException If a process fails to start.
+     */
+    public void startSimulation() throws IOException {
+        if (!runningProcesses.isEmpty()) {
+            stopSimulation();
+        }
+
+        System.out.println("Starting simulation processes...");
+
+        // 1. Start Intersections (Cr1 - Cr5)
+        String[] intersectionIds = { "Cr1", "Cr2", "Cr3", "Cr4", "Cr5" };
+        for (String id : intersectionIds) {
+            startProcess("sd.IntersectionProcess", id);
+        }
+
+        // 2. Start Exit Node
+        startProcess("sd.ExitNodeProcess", null);
+
+        // 3. Start Coordinator (Wait a bit for others to initialize)
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+        startProcess("sd.coordinator.CoordinatorProcess", null);
+
+        System.out.println("All simulation processes started.");
+    }
+
+    /**
+     * Stops all running simulation processes.
+     */
+    public void stopSimulation() {
+        System.out.println("Stopping simulation processes...");
+
+        for (Process process : runningProcesses) {
+            if (process.isAlive()) {
+                process.destroy(); // Try graceful termination first
+            }
+        }
+
+        // Wait a bit and force kill if necessary
+        try {
+            Thread.sleep(500);
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+
+        for (Process process : runningProcesses) {
+            if (process.isAlive()) {
+                process.destroyForcibly();
+            }
+        }
+
+        runningProcesses.clear();
+        System.out.println("All simulation processes stopped.");
+    }
+
+    /**
+     * Helper to start a single Java process.
+     */
+    private void startProcess(String className, String arg) throws IOException {
+        String javaBin = System.getProperty("java.home") + File.separator + "bin" + File.separator + "java";
+
+        ProcessBuilder builder;
+        if (arg != null) {
+            builder = new ProcessBuilder(javaBin, "-cp", classpath, className, arg);
+        } else {
+            builder = new ProcessBuilder(javaBin, "-cp", classpath, className);
+        }
+
+        // get the OS temp folder
+        // Linux: /tmp/
+        // Windows: %AppData%\Local\Temp\
+        String tempDir = System.getProperty("java.io.tmpdir");
+
+        String logName = className.substring(className.lastIndexOf('.') + 1) + (arg != null ? "-" + arg : "") + ".log";
+
+        // use the (File parent, String child) constructor to handle slash/backslash
+        // automatically
+        File logFile = new File(tempDir, logName);
+
+        builder.redirectOutput(logFile);
+        builder.redirectError(logFile);
+
+        Process process = builder.start();
+        runningProcesses.add(process);
+        System.out.println("Started " + className + (arg != null ? " " + arg : ""));
+        // print where the logs are actually going
+        System.out.println("Logs redirected to: " + logFile.getAbsolutePath());
+    }
+}

main/src/main/java/sd/dashboard/StatsMessage.java

@@ -0,0 +1,48 @@
+package sd.dashboard;
+
+import sd.model.MessageType;
+import sd.protocol.MessageProtocol;
+
+/**
+ * Message wrapper for sending statistics to the dashboard.
+ */
+public class StatsMessage implements MessageProtocol {
+    
+    private static final long serialVersionUID = 1L;
+    
+    private final String sourceNode;
+    private final String destinationNode;
+    private final StatsUpdatePayload payload;
+    
+    public StatsMessage(String sourceNode, StatsUpdatePayload payload) {
+        this.sourceNode = sourceNode;
+        this.destinationNode = "DashboardServer";
+        this.payload = payload;
+    }
+    
+    @Override
+    public MessageType getType() {
+        return MessageType.STATS_UPDATE;
+    }
+    
+    @Override
+    public Object getPayload() {
+        return payload;
+    }
+    
+    @Override
+    public String getSourceNode() {
+        return sourceNode;
+    }
+    
+    @Override
+    public String getDestinationNode() {
+        return destinationNode;
+    }
+    
+    @Override
+    public String toString() {
+        return String.format("StatsMessage[from=%s, to=%s, payload=%s]", 
+            sourceNode, destinationNode, payload);
+    }
+}

main/src/main/java/sd/dashboard/StatsUpdatePayload.java

@@ -0,0 +1,121 @@
+package sd.dashboard;
+
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.Map;
+
+import sd.model.VehicleType;
+
+/**
+ * Data transfer object for statistics updates to the dashboard.
+ * Use -1 for fields not being updated in this message.
+ */
+public class StatsUpdatePayload implements Serializable {
+    
+    private static final long serialVersionUID = 1L;
+    
+    private int totalVehiclesGenerated = -1;
+    private int totalVehiclesCompleted = -1;
+    private long totalSystemTime = -1;
+    private long totalWaitingTime = -1;
+    
+    private int intersectionArrivals = 0;
+    private int intersectionDepartures = 0;
+    private int intersectionQueueSize = 0;
+    
+    private Map<VehicleType, Integer> vehicleTypeCounts;
+    private Map<VehicleType, Long> vehicleTypeWaitTimes;
+    
+    public StatsUpdatePayload() {
+        this.vehicleTypeCounts = new HashMap<>();
+        this.vehicleTypeWaitTimes = new HashMap<>();
+    }
+    
+    public int getTotalVehiclesGenerated() {
+        return totalVehiclesGenerated;
+    }
+    
+    public int getTotalVehiclesCompleted() {
+        return totalVehiclesCompleted;
+    }
+    
+    public long getTotalSystemTime() {
+        return totalSystemTime;
+    }
+    
+    public long getTotalWaitingTime() {
+        return totalWaitingTime;
+    }
+    
+    public int getIntersectionArrivals() {
+        return intersectionArrivals;
+    }
+    
+    public int getIntersectionDepartures() {
+        return intersectionDepartures;
+    }
+    
+    public int getIntersectionQueueSize() {
+        return intersectionQueueSize;
+    }
+    
+    public Map<VehicleType, Integer> getVehicleTypeCounts() {
+        return vehicleTypeCounts;
+    }
+    
+    public Map<VehicleType, Long> getVehicleTypeWaitTimes() {
+        return vehicleTypeWaitTimes;
+    }
+    
+    public StatsUpdatePayload setTotalVehiclesGenerated(int totalVehiclesGenerated) {
+        this.totalVehiclesGenerated = totalVehiclesGenerated;
+        return this;
+    }
+    
+    public StatsUpdatePayload setTotalVehiclesCompleted(int totalVehiclesCompleted) {
+        this.totalVehiclesCompleted = totalVehiclesCompleted;
+        return this;
+    }
+    
+    public StatsUpdatePayload setTotalSystemTime(long totalSystemTime) {
+        this.totalSystemTime = totalSystemTime;
+        return this;
+    }
+    
+    public StatsUpdatePayload setTotalWaitingTime(long totalWaitingTime) {
+        this.totalWaitingTime = totalWaitingTime;
+        return this;
+    }
+    
+    public StatsUpdatePayload setIntersectionArrivals(int intersectionArrivals) {
+        this.intersectionArrivals = intersectionArrivals;
+        return this;
+    }
+    
+    public StatsUpdatePayload setIntersectionDepartures(int intersectionDepartures) {
+        this.intersectionDepartures = intersectionDepartures;
+        return this;
+    }
+    
+    public StatsUpdatePayload setIntersectionQueueSize(int intersectionQueueSize) {
+        this.intersectionQueueSize = intersectionQueueSize;
+        return this;
+    }
+    
+    public StatsUpdatePayload setVehicleTypeCounts(Map<VehicleType, Integer> vehicleTypeCounts) {
+        this.vehicleTypeCounts = vehicleTypeCounts;
+        return this;
+    }
+    
+    public StatsUpdatePayload setVehicleTypeWaitTimes(Map<VehicleType, Long> vehicleTypeWaitTimes) {
+        this.vehicleTypeWaitTimes = vehicleTypeWaitTimes;
+        return this;
+    }
+    
+    @Override
+    public String toString() {
+        return String.format("StatsUpdatePayload[generated=%d, completed=%d, arrivals=%d, departures=%d, queueSize=%d]",
+            totalVehiclesGenerated, totalVehiclesCompleted, intersectionArrivals, 
+            intersectionDepartures, intersectionQueueSize);
+    }
+}

main/src/main/java/sd/engine/SimulationEngine.java

@@ -1,645 +0,0 @@
-package sd.engine;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.PriorityQueue;
-
-import sd.config.SimulationConfig;
-import sd.model.Event;
-import sd.model.EventType;
-import sd.model.Intersection;
-import sd.model.TrafficLight;
-import sd.model.TrafficLightState;
-import sd.model.Vehicle;
-import sd.model.VehicleType;
-import sd.util.StatisticsCollector;
-import sd.util.VehicleGenerator;
-
-/**
- * Core simulation engine using discrete event simulation (DES).
- * * This class orchestrates the entire simulation. It maintains a
- * {@link PriorityQueue} of {@link Event} objects, representing all
- * scheduled future actions. The engine processes events in strict
- * chronological order (based on their timestamp).
- * * It manages the simulation's state, including:
- * - The current simulation time ({@code currentTime}).
- * - The collection of all {@link Intersection} objects.
- * - The {@link VehicleGenerator} for creating new vehicles.
- * - The {@link StatisticsCollector} for tracking metrics.
- */
-public class SimulationEngine {
-    
-    /**
-     * Holds all simulation parameters loaded from the properties file.
-     */
-    private final SimulationConfig config;
-    
-    /**
-     * The core of the discrete event simulation. Events are pulled from this
-     * queue in order of their timestamp.
-     */
-    private final PriorityQueue<Event> eventQueue;
-    
-    /**
-     * A map storing all intersections in the simulation, keyed by their ID (e.g., "Cr1").
-     */
-    private final Map<String, Intersection> intersections;
-    
-    /**
-     * Responsible for creating new vehicles according to the configured arrival model.
-     */
-    private final VehicleGenerator vehicleGenerator;
-    
-    /**
-     * Collects and calculates statistics throughout the simulation.
-     */
-    private final StatisticsCollector statisticsCollector;
-    
-    /**
-     * The current time in the simulation (in virtual seconds).
-     * This time advances based on the timestamp of the event being processed.
-     */
-    private double currentTime;
-    
-    /**
-     * A simple counter to generate unique IDs for vehicles.
-     */
-    private int vehicleCounter;
-    
-    /**
-     * Constructs a new SimulationEngine.
-     *
-     * @param config The {@link SimulationConfig} object containing all
-     * simulation parameters.
-     */
-    public SimulationEngine(SimulationConfig config) {
-        this.config = config;
-        this.eventQueue = new PriorityQueue<>();
-        this.intersections = new HashMap<>();
-        this.vehicleGenerator = new VehicleGenerator(config);
-        this.statisticsCollector = new StatisticsCollector(config);
-        this.currentTime = 0.0;
-        this.vehicleCounter = 0;
-    }
-    
-    /**
-     * Initializes the simulation. This involves:
-     * 1. Creating all {@link Intersection} and {@link TrafficLight} objects.
-     * 2. Configuring the routing logic between intersections.
-     * 3. Scheduling the initial events (first traffic light changes,
-     * first vehicle generation, and periodic statistics updates).
-     */
-    public void initialize() {
-        System.out.println("Initializing simulation...");
-        
-        setupIntersections();
-        setupRouting();
-        
-        // Schedule initial events to "bootstrap" the simulation
-        scheduleTrafficLightEvents();
-        scheduleNextVehicleGeneration(0.0);
-        scheduleStatisticsUpdates();
-        
-        System.out.println("Simulation initialized with " + intersections.size() + " intersections");
-    }
-    
-    /**
-     * Creates all intersections defined in the configuration
-     * and adds their corresponding traffic lights.
-     */
-    private void setupIntersections() {
-        String[] intersectionIds = {"Cr1", "Cr2", "Cr3", "Cr4", "Cr5"};
-        // Note: "North" is commented out, so it won't be created.
-        String[] directions = {/*"North",*/ "South", "East", "West"};
-        
-        for (String id : intersectionIds) {
-            Intersection intersection = new Intersection(id);
-            
-            // Add traffic lights for each configured direction
-            for (String direction : directions) {
-                double greenTime = config.getTrafficLightGreenTime(id, direction);
-                double redTime = config.getTrafficLightRedTime(id, direction);
-                
-                TrafficLight light = new TrafficLight(
-                    id + "-" + direction,
-                    direction,
-                    greenTime,
-                    redTime
-                );
-                
-                intersection.addTrafficLight(light);
-            }
-            
-            intersections.put(id, intersection);
-        }
-    }
-    
-    /**
-     * Configures how vehicles should be routed between intersections.
-     * This hardcoded logic defines the "map" of the city.
-     * * For example, `intersections.get("Cr1").configureRoute("Cr2", "East");` means
-     * "at intersection Cr1, any vehicle whose *next* destination is Cr2
-     * should be sent to the 'East' traffic light queue."
-     */
-    private void setupRouting() {
-        // Cr1 routing
-        intersections.get("Cr1").configureRoute("Cr2", "East");
-        intersections.get("Cr1").configureRoute("Cr4", "South");
-        
-        // Cr2 routing
-        intersections.get("Cr2").configureRoute("Cr1", "West");
-        intersections.get("Cr2").configureRoute("Cr3", "East");
-        intersections.get("Cr2").configureRoute("Cr5", "South");
-        
-        // Cr3 routing
-        intersections.get("Cr3").configureRoute("Cr2", "West");
-        intersections.get("Cr3").configureRoute("S", "South"); // "S" is the exit
-        
-        // Cr4 routing
-        //intersections.get("Cr4").configureRoute("Cr1", "North");
-        intersections.get("Cr4").configureRoute("Cr5", "East");
-        
-        // Cr5 routing
-        //intersections.get("Cr5").configureRoute("Cr2", "North");
-        //intersections.get("Cr5").configureRoute("Cr4", "West");
-        intersections.get("Cr5").configureRoute("S", "East"); // "S" is the exit
-    }
-    
-    /**
-     * Schedules the initial {@link EventType#TRAFFIC_LIGHT_CHANGE} event
-     * for every traffic light in the simulation.
-     * A small random delay is added to "stagger" the lights, preventing
-     * all of them from changing at the exact same time at t=0.
-     */
-    private void scheduleTrafficLightEvents() {
-        for (Intersection intersection : intersections.values()) {
-            for (TrafficLight light : intersection.getTrafficLights()) {
-                // Start with lights in RED state, schedule first GREEN change
-                // Stagger the start times slightly to avoid all lights changing at once
-                double staggerDelay = Math.random() * 1.5;
-                scheduleTrafficLightChange(light, intersection.getId(), staggerDelay);
-            }
-        }
-    }
-    
-    /**
-     * Creates and schedules a new {@link EventType#TRAFFIC_LIGHT_CHANGE} event.
-     * The event is scheduled to occur at {@code currentTime + delay}.
-     *
-     * @param light The {@link TrafficLight} that will change state.
-     * @param intersectionId The ID of the intersection where the light is located.
-     * @param delay The time (in seconds) from {@code currentTime} when the change should occur.
-     */
-    private void scheduleTrafficLightChange(TrafficLight light, String intersectionId, double delay) {
-        double changeTime = currentTime + delay;
-        Event event = new Event(changeTime, EventType.TRAFFIC_LIGHT_CHANGE, light, intersectionId);
-        eventQueue.offer(event);
-    }
-    
-    /**
-     * Schedules the next {@link EventType#VEHICLE_GENERATION} event.
-     * The time of the next arrival is determined by the {@link VehicleGenerator}.
-     *
-     * @param baseTime The time from which to calculate the next arrival (usually {@code currentTime}).
-     */
-    private void scheduleNextVehicleGeneration(double baseTime) {
-        // Get the absolute time for the next arrival.
-        double nextArrivalTime = vehicleGenerator.getNextArrivalTime(baseTime);
-        
-        // Only schedule the event if it's within the simulation's total duration.
-        if (nextArrivalTime < config.getSimulationDuration()) {
-            Event event = new Event(nextArrivalTime, EventType.VEHICLE_GENERATION, null, null);
-            eventQueue.offer(event);
-        }
-    }
-    
-    /**
-     * Schedules all periodic {@link EventType#STATISTICS_UPDATE} events
-     * for the entire duration of the simulation.
-     */
-    private void scheduleStatisticsUpdates() {
-        double interval = config.getStatisticsUpdateInterval();
-        double duration = config.getSimulationDuration();
-        
-        for (double time = interval; time < duration; time += interval) {
-            Event event = new Event(time, EventType.STATISTICS_UPDATE, null, null);
-            eventQueue.offer(event);
-        }
-    }
-    
-    /**
-     * Runs the main simulation loop.
-     * The loop continues as long as there are events in the queue and
-     * the {@code currentTime} is less than the total simulation duration.
-     * * In each iteration, it:
-     * 1. Polls the next event from the {@link #eventQueue}.
-     * 2. Advances {@link #currentTime} to the event's timestamp.
-     * 3. Calls {@link #processEvent(Event)} to handle the event.
-     * * After the loop, it prints the final statistics.
-     */
-    public void run() {
-        System.out.println("Starting simulation...");
-        double duration = config.getSimulationDuration();
-        
-        while (!eventQueue.isEmpty() && currentTime < duration) {
-            // Get the next event in chronological order
-            Event event = eventQueue.poll();
-            
-            // Advance simulation time to this event's time
-            currentTime = event.getTimestamp();
-            
-            // Process the event
-            processEvent(event);
-        }
-        
-        System.out.println("\nSimulation completed at t=" + String.format("%.2f", currentTime) + "s");
-        printFinalStatistics();
-    }
-    
-    /**
-     * Main event processing logic.
-     * Delegates the event to the appropriate handler method based on its {@link EventType}.
-     *
-     * @param event The {@link Event} to be processed.
-     */
-    private void processEvent(Event event) {
-        switch (event.getType()) {
-            case VEHICLE_GENERATION:
-                handleVehicleGeneration();
-                break;
-                
-            case VEHICLE_ARRIVAL:
-                handleVehicleArrival(event);
-                break;
-                
-            case TRAFFIC_LIGHT_CHANGE:
-                handleTrafficLightChange(event);
-                break;
-                
-            case CROSSING_START:
-                handleCrossingStart(event);
-                break;
-                
-            case CROSSING_END:
-                handleCrossingEnd(event);
-                break;
-                
-            case STATISTICS_UPDATE:
-                handleStatisticsUpdate();
-                break;
-                
-            default:
-                System.err.println("Unknown event type: " + event.getType());
-        }
-    }
-    
-    /**
-     * Handles {@link EventType#VEHICLE_GENERATION}.
-     * 1. Creates a new {@link Vehicle} using the {@link #vehicleGenerator}.
-     * 2. Records the generation event with the {@link #statisticsCollector}.
-     * 3. Schedules a {@link EventType#VEHICLE_ARRIVAL} event for the vehicle
-     * at its first destination intersection.
-     * 4. Schedules the *next* {@link EventType#VEHICLE_GENERATION} event.
-     * (Note: This line is commented out in the original, which might be a bug,
-     * as it implies only one vehicle is ever generated. It should likely be active.)
-     */
-    private void handleVehicleGeneration() {
-        Vehicle vehicle = vehicleGenerator.generateVehicle("V" + (++vehicleCounter), currentTime);
-        
-        System.out.printf("[t=%.2f] Vehicle %s generated (type=%s, route=%s)%n",
-            currentTime, vehicle.getId(), vehicle.getType(), vehicle.getRoute());
-        
-        // Register with statistics collector
-        statisticsCollector.recordVehicleGeneration(vehicle, currentTime);
-        
-        // Schedule arrival at first intersection
-        String firstIntersection = vehicle.getCurrentDestination();
-        if (firstIntersection != null && !firstIntersection.equals("S")) {
-            // Assume minimal travel time to first intersection (e.g., 1-3 seconds)
-            double arrivalTime = currentTime + 1.0 + Math.random() * 2.0;
-            Event arrivalEvent = new Event(arrivalTime, EventType.VEHICLE_ARRIVAL, vehicle, firstIntersection);
-            eventQueue.offer(arrivalEvent);
-        }
-        
-        // Schedule next vehicle generation
-        // This was commented out in the original file.
-        // For a continuous simulation, it should be enabled:
-        scheduleNextVehicleGeneration(currentTime);
-    }
-    
-    /**
-     * Handles {@link EventType#VEHICLE_ARRIVAL} at an intersection.
-     * 1. Records the arrival for statistics.
-     * 2. Advances the vehicle's internal route planner to its *next* destination.
-     * 3. If the next destination is the exit ("S") or null,
-     * the vehicle exits the system via {@link #handleVehicleExit(Vehicle)}.
-     * 4. Otherwise, the vehicle is placed in the correct queue at the
-     * current intersection using {@link Intersection#receiveVehicle(Vehicle)}.
-     * 5. Attempts to process the vehicle immediately if its light is green.
-     *
-     * @param event The arrival event, containing the {@link Vehicle} and intersection ID.
-     */
-    private void handleVehicleArrival(Event event) {
-        Vehicle vehicle = (Vehicle) event.getData();
-        String intersectionId = event.getLocation();
-        
-        Intersection intersection = intersections.get(intersectionId);
-        if (intersection == null) {
-            System.err.println("Unknown intersection: " + intersectionId);
-            return;
-        }
-        
-        System.out.printf("[t=%.2f] Vehicle %s arrived at %s%n",
-            currentTime, vehicle.getId(), intersectionId);
-        
-        // Record arrival time (used to calculate waiting time later)
-        statisticsCollector.recordVehicleArrival(vehicle, intersectionId, currentTime);
-        
-        // Advance the vehicle's route to the *next* stop
-        // (it has now arrived at its *current* destination)
-        boolean hasNext = vehicle.advanceRoute();
-        
-        if (!hasNext) {
-            // This was the last stop
-            handleVehicleExit(vehicle);
-            return;
-        }
-        
-        String nextDestination = vehicle.getCurrentDestination();
-        if (nextDestination == null || "S".equals(nextDestination)) {
-            // Next stop is the exit
-            handleVehicleExit(vehicle);
-            return;
-        }
-        
-        // Add vehicle to the appropriate traffic light queue based on its next destination
-        intersection.receiveVehicle(vehicle);
-        
-        // Try to process the vehicle immediately if its light is already green
-        tryProcessVehicle(vehicle, intersection);
-    }
-    
-    /**
-     * Checks if a newly arrived vehicle (or a vehicle in a queue
-     * that just turned green) can start crossing.
-     *
-     * @param vehicle The vehicle to process.
-     * @param intersection The intersection where the vehicle is.
-     */
-    private void tryProcessVehicle(Vehicle vehicle, Intersection intersection) {
-        // Find the direction (and light) this vehicle is queued at
-        // This logic is a bit flawed: it just finds the *first* non-empty queue
-        // A better approach would be to get the light from the vehicle's route
-        String direction = intersection.getTrafficLights().stream()
-            .filter(tl -> tl.getQueueSize() > 0)
-            .map(TrafficLight::getDirection)
-            .findFirst()
-            .orElse(null);
-        
-        if (direction != null) {
-            TrafficLight light = intersection.getTrafficLight(direction);
-            // If the light is green and it's the correct one...
-            if (light != null && light.getState() == TrafficLightState.GREEN) {
-                // ...remove the vehicle from the queue (if it's at the front)
-                Vehicle v = light.removeVehicle();
-                if (v != null) {
-                    // ...and schedule its crossing.
-                    scheduleCrossing(v, intersection);
-                }
-            }
-        }
-    }
-    
-    /**
-     * Schedules the crossing for a vehicle that has just been dequeued
-     * from a green light.
-     * 1. Calculates and records the vehicle's waiting time.
-     * 2. Schedules an immediate {@link EventType#CROSSING_START} event.
-     *
-     * @param vehicle The {@link Vehicle} that is crossing.
-     * @param intersection The {@link Intersection} it is crossing.
-     */
-    private void scheduleCrossing(Vehicle vehicle, Intersection intersection) {
-        // Calculate time spent waiting at the red light
-        double waitTime = currentTime - statisticsCollector.getArrivalTime(vehicle);
-        vehicle.addWaitingTime(waitTime);
-        
-        // Schedule crossing start event *now*
-        Event crossingStart = new Event(currentTime, EventType.CROSSING_START, vehicle, intersection.getId());
-        processEvent(crossingStart); // Process immediately
-    }
-    
-    /**
-     * Handles {@link EventType#CROSSING_START}.
-     * 1. Determines the crossing time based on vehicle type.
-     * 2. Schedules a {@link EventType#CROSSING_END} event to occur
-     * at {@code currentTime + crossingTime}.
-     *
-     * @param event The crossing start event.
-     */
-    private void handleCrossingStart(Event event) {
-        Vehicle vehicle = (Vehicle) event.getData();
-        String intersectionId = event.getLocation();
-        
-        double crossingTime = getCrossingTime(vehicle.getType());
-        
-        System.out.printf("[t=%.2f] Vehicle %s started crossing at %s (duration=%.2fs)%n",
-            currentTime, vehicle.getId(), intersectionId, crossingTime);
-        
-        // Schedule the *end* of the crossing
-        double endTime = currentTime + crossingTime;
-        Event crossingEnd = new Event(endTime, EventType.CROSSING_END, vehicle, intersectionId);
-        eventQueue.offer(crossingEnd);
-    }
-    
-    /**
-     * Handles {@link EventType#CROSSING_END}.
-     * 1. Updates intersection and vehicle statistics.
-     * 2. Checks the vehicle's *next* destination.
-     * 3. If the next destination is the exit ("S"), call {@link #handleVehicleExit(Vehicle)}.
-     * 4. Otherwise, schedule a {@link EventType#VEHICLE_ARRIVAL} event at the
-     * *next* intersection, after some travel time.
-     *
-     * @param event The crossing end event.
-     */
-    private void handleCrossingEnd(Event event) {
-        Vehicle vehicle = (Vehicle) event.getData();
-        String intersectionId = event.getLocation();
-        
-        // Update stats
-        Intersection intersection = intersections.get(intersectionId);
-        if (intersection != null) {
-            intersection.incrementVehiclesSent();
-        }
-        
-        double crossingTime = getCrossingTime(vehicle.getType());
-        vehicle.addCrossingTime(crossingTime);
-        
-        System.out.printf("[t=%.2f] Vehicle %s finished crossing at %s%n",
-            currentTime, vehicle.getId(), intersectionId);
-        
-        // Decide what to do next
-        String nextDest = vehicle.getCurrentDestination();
-        if (nextDest != null && !nextDest.equals("S")) {
-            // Route to the *next* intersection
-            // Assume 5-10 seconds travel time between intersections
-            double travelTime = 5.0 + Math.random() * 5.0; 
-            double arrivalTime = currentTime + travelTime;
-            Event arrivalEvent = new Event(arrivalTime, EventType.VEHICLE_ARRIVAL, vehicle, nextDest);
-            eventQueue.offer(arrivalEvent);
-        } else {
-            // Reached the exit
-            handleVehicleExit(vehicle);
-        }
-    }
-    
-    /**
-     * Handles a vehicle exiting the simulation.
-     * Records final statistics for the vehicle.
-     *
-     * @param vehicle The {@link Vehicle} that has completed its route.
-     */
-    private void handleVehicleExit(Vehicle vehicle) {
-        System.out.printf("[t=%.2f] Vehicle %s exited the system (wait=%.2fs, travel=%.2fs)%n",
-            currentTime, vehicle.getId(), 
-            vehicle.getTotalWaitingTime(), 
-            vehicle.getTotalTravelTime(currentTime));
-        
-        // Record the exit for final statistics calculation
-        statisticsCollector.recordVehicleExit(vehicle, currentTime);
-    }
-    
-    /**
-     * Handles {@link EventType#TRAFFIC_LIGHT_CHANGE}.
-     * 1. Toggles the light's state (RED to GREEN or GREEN to RED).
-     * 2. If the light just turned GREEN, call {@link #processGreenLight(TrafficLight, Intersection)}
-     * to process any waiting vehicles.
-     * 3. Schedules the *next* state change for this light based on its
-     * green/red time duration.
-     *
-     * @param event The light change event.
-     */
-    private void handleTrafficLightChange(Event event) {
-        TrafficLight light = (TrafficLight) event.getData();
-        String intersectionId = event.getLocation();
-        
-        // Toggle state
-        TrafficLightState newState = (light.getState() == TrafficLightState.RED) 
-            ? TrafficLightState.GREEN 
-            : TrafficLightState.RED;
-        
-        light.changeState(newState);
-        
-        System.out.printf("[t=%.2f] Traffic light %s changed to %s%n",
-            currentTime, light.getId(), newState);
-        
-        // If changed to GREEN, process waiting vehicles
-        if (newState == TrafficLightState.GREEN) {
-            Intersection intersection = intersections.get(intersectionId);
-            if (intersection != null) {
-                processGreenLight(light, intersection);
-            }
-        }
-        
-        // Schedule the *next* state change for this same light
-        double nextChangeDelay = (newState == TrafficLightState.GREEN) 
-            ? light.getGreenTime() 
-            : light.getRedTime();
-        
-        scheduleTrafficLightChange(light, intersectionId, nextChangeDelay);
-    }
-    
-    /**
-     * Processes vehicles when a light turns green.
-     * It loops as long as the light is green and there are vehicles in the queue,
-     * dequeuing one vehicle at a time and scheduling its crossing.
-     * * *Note*: This is a simplified model. A real simulation would
-     * account for the *time* it takes each vehicle to cross, processing
-     * one vehicle every {@code crossingTime} seconds. This implementation
-     * processes the entire queue "instantaneously" at the moment
-     * the light turns green.
-     *
-     * @param light The {@link TrafficLight} that just turned green.
-     * @param intersection The {@link Intersection} where the light is.
-     */
-    private void processGreenLight(TrafficLight light, Intersection intersection) {
-        // While the light is green and vehicles are waiting...
-        while (light.getState() == TrafficLightState.GREEN && light.getQueueSize() > 0) {
-            Vehicle vehicle = light.removeVehicle();
-            if (vehicle != null) {
-                // Dequeue one vehicle and schedule its crossing
-                scheduleCrossing(vehicle, intersection);
-            }
-        }
-    }
-    
-    /**
-     * Handles {@link EventType#STATISTICS_UPDATE}.
-     * Calls the {@link StatisticsCollector} to print the current
-     * state of the simulation (queue sizes, averages, etc.).
-     */
-    private void handleStatisticsUpdate() {
-        System.out.printf("\n=== Statistics at t=%.2f ===%n", currentTime);
-        statisticsCollector.printCurrentStatistics(intersections, currentTime);
-        System.out.println();
-    }
-    
-    /**
-     * Utility method to get the configured crossing time for a given {@link VehicleType}.
-     *
-     * @param type The type of vehicle.
-     * @return The crossing time in seconds.
-     */
-    private double getCrossingTime(VehicleType type) {
-        switch (type) {
-            case BIKE:
-                return config.getBikeVehicleCrossingTime();
-            case LIGHT:
-                return config.getLightVehicleCrossingTime();
-            case HEAVY:
-                return config.getHeavyVehicleCrossingTime();
-            default:
-                return 2.0; // Default fallback
-        }
-    }
-    
-    /**
-     * Prints the final summary of statistics at the end of the simulation.
-     */
-    private void printFinalStatistics() {
-        System.out.println("\n" + "=".repeat(60));
-        System.out.println("FINAL SIMULATION STATISTICS");
-        System.out.println("=".repeat(60));
-        
-        statisticsCollector.printFinalStatistics(intersections, currentTime);
-        
-        System.out.println("=".repeat(60));
-    }
-    
-    // --- Public Getters ---
-
-    /**
-     * Gets the current simulation time.
-     * @return The time in virtual seconds.
-     */
-    public double getCurrentTime() {
-        return currentTime;
-    }
-    
-    /**
-     * Gets a map of all intersections in the simulation.
-     * Returns a copy to prevent external modification.
-     * @return A {@link Map} of intersection IDs to {@link Intersection} objects.
-     */
-    public Map<String, Intersection> getIntersections() {
-        return new HashMap<>(intersections);
-    }
-    
-    /**
-     * Gets the statistics collector instance.
-     * @return The {@link StatisticsCollector}.
-     */
-    public StatisticsCollector getStatisticsCollector() {
-        return statisticsCollector;
-    }
-}

main/src/main/java/sd/engine/TrafficLightThread.java

@@ -0,0 +1,126 @@
+package sd.engine;
+
+import sd.IntersectionProcess;
+import sd.config.SimulationConfig;
+import sd.model.TrafficLight;
+import sd.model.TrafficLightState;
+import sd.model.Vehicle;
+
+/**
+ * Implements the control logic for a single TrafficLight
+ * as a Runnable task that runs in its own Thread.
+ */
+public class TrafficLightThread implements Runnable {
+
+    private final TrafficLight light;
+    private final IntersectionProcess process;
+    private final SimulationConfig config;
+    private volatile boolean running;
+
+    // Store the thread reference for proper interruption
+    private Thread currentThread;
+
+    public TrafficLightThread(TrafficLight light, IntersectionProcess process, SimulationConfig config) {
+        this.light = light;
+        this.process = process;
+        this.config = config;
+        this.running = false;
+    }
+
+    @Override
+    public void run() {
+        this.currentThread = Thread.currentThread();
+        this.running = true;
+        System.out.println("[" + light.getId() + "] Traffic light thread started.");
+
+        try {
+            while (running && !Thread.currentThread().isInterrupted()) {
+
+                // Request permission to turn green (blocks until granted)
+                process.requestGreenLight(light.getDirection());
+
+                try {
+                    // --- GREEN Phase ---
+                    light.changeState(TrafficLightState.GREEN);
+                    System.out.println("[" + light.getId() + "] State: GREEN");
+
+                    // Process queue for the duration of the green light
+                    long greenDurationMs = (long) (light.getGreenTime() * 1000);
+                    processGreenLightQueue(greenDurationMs);
+
+                    if (!running || Thread.currentThread().isInterrupted())
+                        break;
+
+                    // --- RED Phase ---
+                    light.changeState(TrafficLightState.RED);
+                    System.out.println("[" + light.getId() + "] State: RED");
+
+                } finally {
+                    // Always release the green light permission
+                    process.releaseGreenLight(light.getDirection());
+                }
+
+                // Wait for red duration
+                Thread.sleep((long) (light.getRedTime() * 1000));
+            }
+        } catch (InterruptedException e) {
+            System.out.println("[" + light.getId() + "] Traffic light thread interrupted.");
+            Thread.currentThread().interrupt();
+        } finally {
+            this.running = false;
+            System.out.println("[" + light.getId() + "] Traffic light thread stopped.");
+        }
+    }
+
+    private void processGreenLightQueue(long greenDurationMs) throws InterruptedException {
+        long startTime = System.currentTimeMillis();
+
+        while (running && !Thread.currentThread().isInterrupted()
+                && light.getState() == TrafficLightState.GREEN) {
+
+            // Check if green time has expired
+            long elapsed = System.currentTimeMillis() - startTime;
+            if (elapsed >= greenDurationMs) {
+                break;
+            }
+
+            if (light.getQueueSize() > 0) {
+                Vehicle vehicle = light.removeVehicle();
+
+                if (vehicle != null) {
+                    double crossingTime = getCrossingTimeForVehicle(vehicle);
+                    long crossingTimeMs = (long) (crossingTime * 1000);
+
+                    Thread.sleep(crossingTimeMs);
+
+                    vehicle.addCrossingTime(crossingTime);
+                    process.getIntersection().incrementVehiclesSent();
+                    process.sendVehicleToNextDestination(vehicle);
+                }
+            } else {
+                // Queue is empty, wait briefly for new vehicles or until time expires
+                Thread.sleep(50);
+            }
+        }
+    }
+
+    private double getCrossingTimeForVehicle(Vehicle vehicle) {
+        return switch (vehicle.getType()) {
+            case BIKE -> config.getBikeVehicleCrossingTime();
+            case LIGHT -> config.getLightVehicleCrossingTime();
+            case HEAVY -> config.getHeavyVehicleCrossingTime();
+            default -> config.getLightVehicleCrossingTime();
+        };
+    }
+
+    /**
+     * Requests the thread to stop gracefully.
+     * Sets the running flag and interrupts the thread to unblock any sleep() calls.
+     */
+    public void shutdown() {
+        this.running = false;
+        if (currentThread != null && currentThread.isAlive()) {
+            currentThread.interrupt();
+        }
+    }
+}

main/src/main/java/sd/model/Event.java

@@ -1,131 +0,0 @@
-package sd.model;
-
-import java.io.Serializable;
-
-/**
- * Represents a single event in the discrete event simulation.
- * * An Event is the fundamental unit of action in the simulation. It contains:
- * - A {@code timestamp} (when the event should occur).
- * - A {@link EventType} (what kind of event it is).
- * - Associated {@code data} (e.g., the {@link Vehicle} or {@link TrafficLight} involved).
- * - An optional {@code location} (e.g., the ID of the {@link Intersection}).
- * * Events are {@link Comparable}, allowing them to be sorted in a
- * {@link java.util.PriorityQueue}. The primary sorting key is the
- * {@code timestamp}. If timestamps are equal, {@code EventType} is used
- * as a tie-breaker to ensure a consistent, deterministic order.
- * * Implements {@link Serializable} so events could (in theory) be sent
- * across a network in a distributed simulation.
- */
-public class Event implements Comparable<Event>, Serializable {
-    private static final long serialVersionUID = 1L;
-    
-    /**
-     * The simulation time (in seconds) when this event is scheduled to occur.
-     */
-    private final double timestamp;
-    
-    /**
-     * The type of event (e.g., VEHICLE_ARRIVAL, TRAFFIC_LIGHT_CHANGE).
-     */
-    private final EventType type;
-    
-    /**
-     * The data payload associated with this event.
-     * This could be a {@link Vehicle}, {@link TrafficLight}, or null.
-     */
-    private final Object data;
-    
-    /**
-     * The ID of the location where the event occurs (e.g., "Cr1").
-     * Can be null if the event is not location-specific (like VEHICLE_GENERATION).
-     */
-    private final String location;
-    
-    /**
-     * Constructs a new Event.
-     *
-     * @param timestamp The simulation time when the event occurs.
-     * @param type The {@link EventType} of the event.
-     * @param data The associated data (e.g., a Vehicle object).
-     * @param location The ID of the location (e.g., an Intersection ID).
-     */
-    public Event(double timestamp, EventType type, Object data, String location) {
-        this.timestamp = timestamp;
-        this.type = type;
-        this.data = data;
-        this.location = location;
-    }
-    
-    /**
-     * Convenience constructor for an Event without a specific location.
-     *
-     * @param timestamp The simulation time when the event occurs.
-     * @param type The {@link EventType} of the event.
-     * @param data The associated data (e.g., a Vehicle object).
-     */
-    public Event(double timestamp, EventType type, Object data) {
-        this(timestamp, type, data, null);
-    }
-    
-    /**
-     * Compares this event to another event for ordering.
-     * * Events are ordered primarily by {@link #timestamp} (ascending).
-     * If timestamps are identical, they are ordered by {@link #type} (alphabetical)
-     * to provide a stable, deterministic tie-breaking mechanism.
-     *
-     * @param other The other Event to compare against.
-     * @return A negative integer if this event comes before {@code other},
-     * zero if they are "equal" in sorting (though this is rare),
-     * or a positive integer if this event comes after {@code other}.
-     */
-    @Override
-    public int compareTo(Event other) {
-        // Primary sort: timestamp (earlier events come first)
-        int cmp = Double.compare(this.timestamp, other.timestamp);
-        if (cmp == 0) {
-            // Tie-breaker: event type (ensures deterministic order)
-            return this.type.compareTo(other.type);
-        }
-        return cmp;
-    }
-    
-    // --- Getters ---
-    
-    /**
-     * @return The simulation time when the event occurs.
-     */
-    public double getTimestamp() {
-        return timestamp;
-    }
-    
-    /**
-     * @return The {@link EventType} of the event.
-     */
-    public EventType getType() {
-        return type;
-    }
-    
-    /**
-     * @return The data payload (e.g., {@link Vehicle}, {@link TrafficLight}).
-     * The caller must cast this to the expected type.
-     */
-    public Object getData() {
-        return data;
-    }
-    
-    /**
-     * @return The location ID (e.g., "Cr1"), or null if not applicable.
-     */
-    public String getLocation() {
-        return location;
-    }
-    
-    /**
-     * @return A string representation of the event for logging.
-     */
-    @Override
-    public String toString() {
-        return String.format("Event{t=%.2f, type=%s, loc=%s}", 
-                           timestamp, type, location);
-    }
-}

main/src/main/java/sd/model/EventType.java

@@ -1,45 +0,0 @@
-package sd.model;
-
-/**
- * Enumeration representing all possible event types in the discrete event simulation.
- * These types are used by the {@link sd.engine.SimulationEngine} to determine
- * how to process a given {@link Event}.
- */
-public enum EventType {
-    
-    /**
-     * Fired when a {@link Vehicle} arrives at an {@link Intersection}.
-     * Data: {@link Vehicle}, Location: Intersection ID
-     */
-    VEHICLE_ARRIVAL,
-    
-    /**
-     * Fired when a {@link TrafficLight} is scheduled to change its state.
-     * Data: {@link TrafficLight}, Location: Intersection ID
-     */
-    TRAFFIC_LIGHT_CHANGE,
-    
-    /**
-     * Fired when a {@link Vehicle} begins to cross an {@link Intersection}.
-     * Data: {@link Vehicle}, Location: Intersection ID
-     */
-    CROSSING_START,
-    
-    /**
-     * Fired when a {@link Vehicle} finishes crossing an {@link Intersection}.
-     * Data: {@link Vehicle}, Location: Intersection ID
-     */
-    CROSSING_END,
-    
-    /**
-     * Fired when a new {@link Vehicle} should be created and added to the system.
-     * Data: null, Location: null
-     */
-    VEHICLE_GENERATION,
-    
-    /**
-     * Fired periodically to trigger the printing or sending of simulation statistics.
-     * Data: null, Location: null
-     */
-    STATISTICS_UPDATE
-}

main/src/main/java/sd/model/Intersection.java

@@ -104,16 +104,28 @@ public class Intersection {
      * Accepts an incoming vehicle and places it in the correct queue.
      * * This method:
      * 1. Increments the {@link #totalVehiclesReceived} counter.
-     * 2. Gets the vehicle's *next* destination (from {@link Vehicle#getCurrentDestination()}).
+     * 2. Advances the vehicle's route (since it just arrived here)
-     * 3. Uses the {@link #routing} map to find the correct *direction* for that destination.
+     * 3. Gets the vehicle's *next* destination (from {@link Vehicle#getCurrentDestination()}).
-     * 4. Adds the vehicle to the queue of the {@link TrafficLight} for that direction.
+     * 4. Uses the {@link #routing} map to find the correct *direction* for that destination.
+     * 5. Adds the vehicle to the queue of the {@link TrafficLight} for that direction.
      *
      * @param vehicle The {@link Vehicle} arriving at the intersection.
      */
     public void receiveVehicle(Vehicle vehicle) {
         totalVehiclesReceived++;
 
+        // Note: Route advancement is handled by SimulationEngine.handleVehicleArrival()
+        // before calling this method, so we don't advance here.
+        
         String nextDestination = vehicle.getCurrentDestination();
+        
+        // Check if vehicle reached final destination
+        if (nextDestination == null) {
+            System.out.printf("[%s] Vehicle %s reached final destination%n", 
+                this.id, vehicle.getId());
+            return;
+        }
+        
         String direction = routing.get(nextDestination);
 
         if (direction != null && trafficLights.containsKey(direction)) {
@@ -128,6 +140,16 @@ public class Intersection {
         }
     }
 
+    /**
+     * Returns the direction a vehicle should take to reach a given destination.
+     *
+     * @param destination The next destination (e.g., "Cr3", "S").
+     * @return The direction (e.g., "East"), or null if no route is configured.
+     */
+    public String getDirectionForDestination(String destination) {
+        return routing.get(destination);
+    }
+
     /**
      * Returns the traffic light controlling the given direction.
      *

main/src/main/java/sd/model/Message.java

@@ -1,14 +1,15 @@
 package sd.model;
 
-import java.io.Serializable;
 import java.util.UUID;
 
+import sd.protocol.MessageProtocol;
+
 /**
  * Represents a message exchanged between processes in the distributed simulation.
  * Each message has a unique ID, a type, a sender, a destination, and a payload.
- * This class implements {@link Serializable} to allow transmission over the network.
+ * This class implements {@link MessageProtocol} which extends Serializable for network transmission.
  */
-public class Message implements Serializable {
+public class Message implements MessageProtocol {
     
     private static final long serialVersionUID = 1L;
     
@@ -132,6 +133,17 @@ public class Message implements Serializable {
         return (T) payload;
     }
     
+    // Impl MessageProtocol interface
+    @Override
+    public String getSourceNode() {
+        return senderId;
+    }
+    
+    @Override
+    public String getDestinationNode() {
+        return destinationId;
+    }
+    
     @Override
     public String toString() {
         return String.format("Message[id=%s, type=%s, from=%s, to=%s, timestamp=%d]",

main/src/main/java/sd/model/MessageType.java

@@ -19,6 +19,12 @@ public enum MessageType {
      */
     STATS_UPDATE,
     
+    /**
+     * Message to synchronize simulation start time across all processes.
+     * Payload: Start timestamp (long milliseconds)
+     */
+    SIMULATION_START,
+    
     /**
      * Message to synchronize traffic light states between processes.
      * Payload: TrafficLight state and timing information

main/src/main/java/sd/model/TrafficLight.java

@@ -1,6 +1,8 @@
 package sd.model;
 
+import java.util.HashMap;
 import java.util.LinkedList;
+import java.util.Map;
 import java.util.Queue;
 import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.Lock;
@@ -94,6 +96,12 @@ public class TrafficLight {
      */
     private int totalVehiclesProcessed;
     
+    /**
+     * Track when vehicles arrive at this light for wait time calculation.
+     * Maps vehicle ID to arrival timestamp (milliseconds).
+     */
+    private final Map<String, Long> vehicleArrivalTimes;
+
     /**
      * Constructs a new TrafficLight.
      *
@@ -115,6 +123,7 @@ public class TrafficLight {
 
         this.greenTime = greenTime;
         this.redTime = redTime;
+        this.vehicleArrivalTimes = new HashMap<>();
         this.totalVehiclesProcessed = 0;
     }
 
@@ -128,6 +137,7 @@ public class TrafficLight {
         lock.lock(); // Acquire the lock
         try {
             queue.offer(vehicle); // Add vehicle to queue
+            vehicleArrivalTimes.put(vehicle.getId(), System.currentTimeMillis());
             vehicleAdded.signalAll(); // Signal (for concurrent models)
         } finally {
             lock.unlock(); // Always release the lock
@@ -152,6 +162,13 @@ public class TrafficLight {
                 Vehicle vehicle = queue.poll(); // Remove vehicle from queue
                 if (vehicle != null) {
                     totalVehiclesProcessed++;
+                    
+                    // Calculate wait time (time spent in queue)
+                    Long arrivalTime = vehicleArrivalTimes.remove(vehicle.getId());
+                    if (arrivalTime != null) {
+                        double waitTimeSeconds = (System.currentTimeMillis() - arrivalTime) / 1000.0;
+                        vehicle.addWaitingTime(waitTimeSeconds);
+                    }
                 }
                 return vehicle;
             }

main/src/main/java/sd/model/Vehicle.java

@@ -12,7 +12,7 @@ import java.util.List;
  * - Its complete, pre-determined {@code route} (a list of intersection IDs).
  * - Its current position in the route ({@code currentRouteIndex}).
  * - Metrics for total time spent waiting at red lights and time spent crossing.
- * * This object is passed around the simulation, primarily inside {@link Event}
+ * * This object is passed around the simulation, primarily inside message
  * payloads and stored in {@link TrafficLight} queues.
  * * Implements {@link Serializable} so it can be sent between processes
  * or nodes (e.g., over a socket in a distributed version of the simulation).
@@ -70,7 +70,8 @@ public class Vehicle implements Serializable {
      * @param id        The unique ID for the vehicle.
      * @param type      The {@link VehicleType}.
      * @param entryTime The simulation time when the vehicle is created.
-     * @param route The complete list of destination IDs (e.t., ["Cr1", "Cr2", "S"]).
+     * @param route     The complete list of destination IDs (e.t., ["Cr1", "Cr2",
+     *                  "S"]).
      */
     public Vehicle(String id, VehicleType type, double entryTime, List<String> route) {
         this.id = id;
@@ -151,7 +152,8 @@ public class Vehicle implements Serializable {
     }
 
     /**
-     * @return The current index pointing to the vehicle's destination in its route list.
+     * @return The current index pointing to the vehicle's destination in its route
+     *         list.
      */
     public int getCurrentRouteIndex() {
         return currentRouteIndex;
@@ -212,7 +214,6 @@ public class Vehicle implements Serializable {
     public String toString() {
         return String.format(
                 "Vehicle{id='%s', type=%s, next='%s', route=%s}",
-            id, type, getCurrentDestination(), route
+                id, type, getCurrentDestination(), route);
-        );
     }
 }

main/src/main/java/sd/protocol/MessageProtocol.java

@@ -0,0 +1,41 @@
+package sd.protocol;
+
+import java.io.Serializable;
+import sd.model.MessageType; // Assuming MessageType is in sd.model or sd.protocol
+
+/**
+ * Interface defining the contract for all messages exchanged in the simulator.
+ * Ensures that any message can be identified and routed.
+ * * This interface extends Serializable to allow objects that implement it
+ * to be sent over Sockets (ObjectOutputStream).
+ *
+ */
+public interface MessageProtocol extends Serializable {
+
+    /**
+     * Returns the type of the message, indicating its purpose.
+     * @return The MessageType (e.g., VEHICLE_TRANSFER, STATS_UPDATE).
+     */
+    MessageType getType();
+
+    /**
+     * Returns the data object (payload) that this message carries.
+     * The type of object will depend on the MessageType.
+     * * - If getType() == VEHICLE_TRANSFER, the payload will be a {@link sd.model.Vehicle} object.
+     * - If getType() == STATS_UPDATE, the payload will be a statistics object.
+     * * @return The data object (payload), which must also be Serializable.
+     */
+    Object getPayload();
+
+    /**
+     * Returns the ID of the node (Process) that sent this message.
+     * @return String (e.g., "Cr1", "Cr5", "S").
+     */
+    String getSourceNode();
+
+    /**
+     * Returns the ID of the destination node (Process) for this message.
+     * @return String (e.g., "Cr2", "DashboardServer").
+     */
+    String getDestinationNode();
+}

main/src/main/java/sd/protocol/SocketConnection.java

@@ -0,0 +1,198 @@
+package sd.protocol; 
+
+import java.io.Closeable;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.ConnectException;
+import java.net.Socket;
+import java.net.SocketTimeoutException;
+import java.net.UnknownHostException;
+import java.util.concurrent.TimeUnit;
+
+import sd.serialization.MessageSerializer;
+import sd.serialization.SerializationException;
+import sd.serialization.SerializerFactory;
+
+
+/**
+ * Wrapper class that simplifies communication via Sockets.
+ * Includes connection retry logic for robustness.
+ */
+public class SocketConnection implements Closeable {
+
+    private final Socket socket;
+    private final OutputStream outputStream;
+    private final InputStream inputStream;
+    private final MessageSerializer serializer;
+
+    // --- Configuration for Retry Logic ---
+    /** Maximum number of connection attempts. */
+    private static final int MAX_RETRIES = 5; 
+    /** Delay between retry attempts in milliseconds. */
+    private static final long RETRY_DELAY_MS = 1000; 
+
+    /**
+     * Constructor for the "Client" (who initiates the connection).
+     * Tries to connect to a process that is already listening (Server).
+     * Includes retry logic in case of initial connection failure.
+     *
+     * @param host The host address (e.g., "localhost" from your simulation.properties)
+     * @param port The port (e.g., 8001 from your simulation.properties)
+     * @throws IOException If connection fails after all retries.
+     * @throws UnknownHostException If the host is not found (this error usually doesn't need retry).
+     * @throws InterruptedException If the thread is interrupted while waiting between retries.
+     */
+    public SocketConnection(String host, int port) throws IOException, UnknownHostException, InterruptedException {
+        Socket tempSocket = null;
+        IOException lastException = null;
+
+        System.out.printf("[SocketConnection] Attempting to connect to %s:%d...%n", host, port);
+
+        // --- Retry Loop ---
+        for (int attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+            try {
+                // Try to establish the connection
+                tempSocket = new Socket(host, port);
+
+                // If successful, break out of the retry loop
+                System.out.printf("[SocketConnection] Connected successfully on attempt %d.%n", attempt);
+                lastException = null; // Clear last error on success
+                break;
+
+            } catch (ConnectException | SocketTimeoutException e) {
+                // These are common errors indicating the server might not be ready.
+                lastException = e;
+                System.out.printf("[SocketConnection] Attempt %d/%d failed: %s. Retrying in %d ms...%n",
+                        attempt, MAX_RETRIES, e.getMessage(), RETRY_DELAY_MS);
+
+                if (attempt < MAX_RETRIES) {
+                    // Wait before the next attempt
+                    TimeUnit.MILLISECONDS.sleep(RETRY_DELAY_MS);
+                }
+            } catch (IOException e) {
+                // Other IOExceptions might be more permanent, but we retry anyway.
+                 lastException = e;
+                 System.out.printf("[SocketConnection] Attempt %d/%d failed with IOException: %s. Retrying in %d ms...%n",
+                        attempt, MAX_RETRIES, e.getMessage(), RETRY_DELAY_MS);
+                 if (attempt < MAX_RETRIES) {
+                     TimeUnit.MILLISECONDS.sleep(RETRY_DELAY_MS);
+                 }
+            }
+        } // --- End of Retry Loop ---
+
+        // If after all retries tempSocket is still null, it means connection failed permanently.
+        if (tempSocket == null) {
+            System.err.printf("[SocketConnection] Failed to connect to %s:%d after %d attempts.%n", host, port, MAX_RETRIES);
+            if (lastException != null) {
+                 throw lastException; // Throw the last exception encountered
+            } else {
+                 // Should not happen if loop ran, but as a fallback
+                 throw new IOException("Failed to connect after " + MAX_RETRIES + " attempts, reason unknown.");
+            }
+        }
+
+        // If connection was successful, assign to final variable and create streams
+        this.socket = tempSocket;
+          
+        this.outputStream = socket.getOutputStream();
+        this.inputStream = socket.getInputStream();
+        this.serializer = SerializerFactory.createDefault();
+
+    }
+
+
+    /**
+     * Constructor for the "Server" (who accepts the connection).
+     * Receives a Socket that has already been accepted by a ServerSocket.
+     * No retry logic needed here as the connection is already established.
+     *
+     * @param acceptedSocket The Socket returned by serverSocket.accept().
+     * @throws IOException If stream creation fails.
+     */
+    public SocketConnection(Socket acceptedSocket) throws IOException {
+        this.socket = acceptedSocket;
+        this.outputStream = socket.getOutputStream();
+        this.inputStream = socket.getInputStream();
+        this.serializer = SerializerFactory.createDefault();
+        
+    }
+
+    /**
+     * Sends (serializes) a MessageProtocol object over the socket.
+     *
+     * @param message The "envelope" (which contains the Vehicle) to be sent.
+     * @throws IOException If writing to the stream fails or socket is not connected.
+     */
+    public synchronized void sendMessage(MessageProtocol message) throws IOException {
+   if (socket == null || !socket.isConnected()) {
+            throw new IOException("Socket is not connected");
+        }
+
+        try {
+            // Serializa para bytes JSON
+            byte[] data = serializer.serialize(message);
+            
+            // Write 4-byte length prefix
+            DataOutputStream dataOut = new DataOutputStream(outputStream);
+            dataOut.writeInt(data.length);
+            dataOut.write(data);
+            dataOut.flush();
+            
+        } catch (SerializationException e) {
+            throw new IOException("Failed to serialize message", e);
+        }
+    }
+
+    /**
+     * Tries to read (deserialize) a MessageProtocol object from the socket.
+     *
+     * @return The "envelope" (MessageProtocol) that was received.
+     * @throws IOException If the connection is lost, the stream is corrupted, or socket is not connected.
+     * @throws ClassNotFoundException If the received object is unknown.
+     */
+    public MessageProtocol receiveMessage() throws IOException, ClassNotFoundException {
+       if (socket == null || !socket.isConnected()) {
+            throw new IOException("Socket is not connected");
+        }
+
+        try {
+            // Lê um prefixo de 4 bytes - indicador de tamanho
+            DataInputStream dataIn = new DataInputStream(inputStream);
+            int length = dataIn.readInt();
+            
+            if (length <= 0 || length > 10_000_000) { // Sanity check (10MB max)
+                throw new IOException("Invalid message length: " + length);
+            }
+            
+            // Ler dados da mensagem
+            byte[] data = new byte[length];
+            dataIn.readFully(data);
+            
+            // Deserialize do JSON - use concrete Message class, not interface
+            return serializer.deserialize(data, sd.model.Message.class);
+            
+        } catch (SerializationException e) {
+            throw new IOException("Failed to deserialize message", e);
+        }
+    }
+
+    /**
+     * Closes the socket and all streams (Input and Output).
+     */
+    @Override
+    public void close() throws IOException {
+        if (inputStream != null) inputStream.close();
+        if (outputStream != null) outputStream.close();
+        if (socket != null) socket.close();
+    }
+
+    /**
+     * @return true if the socket is still connected and not closed.
+     */
+    public boolean isConnected() {
+        return socket != null && socket.isConnected() && !socket.isClosed();
+    }
+}

main/src/main/java/sd/serialization/SerializationExample.java

@@ -1,134 +0,0 @@
-package sd.serialization;
-
-import sd.model.Message;
-import sd.model.MessageType;
-import sd.model.Vehicle;
-import sd.model.VehicleType;
-
-import java.util.Arrays;
-import java.util.List;
-
-/**
- * Demonstration of JSON serialization usage in the traffic simulation system.
- * 
- * This class shows practical examples of how to use JSON (Gson) serialization
- * for network communication between simulation processes.
- */
-public class SerializationExample {
-    
-    public static void main(String[] args) {
-        System.out.println("=== JSON Serialization Example ===\n");
-        
-        // Create a sample vehicle
-        List<String> route = Arrays.asList("Cr1", "Cr2", "Cr5", "S");
-        Vehicle vehicle = new Vehicle("V001", VehicleType.LIGHT, 10.5, route);
-        vehicle.addWaitingTime(2.3);
-        vehicle.addCrossingTime(1.2);
-        
-        // Create a message containing the vehicle
-        Message message = new Message(
-            MessageType.VEHICLE_TRANSFER,
-            "Cr1",
-            "Cr2",
-            vehicle
-        );
-        
-        // ===== JSON Serialization =====
-        demonstrateJsonSerialization(message);
-        
-        // ===== Factory Usage =====
-        demonstrateFactoryUsage(message);
-        
-        // ===== Performance Test =====
-        performanceTest(message);
-    }
-    
-    private static void demonstrateJsonSerialization(Message message) {
-        System.out.println("--- JSON Serialization ---");
-        
-        try {
-            // Create JSON serializer with pretty printing for readability
-            MessageSerializer serializer = new JsonMessageSerializer(true);
-            
-            // Serialize to bytes
-            byte[] data = serializer.serialize(message);
-            
-            // Display the JSON
-            String json = new String(data);
-            System.out.println("Serialized JSON (" + data.length + " bytes):");
-            System.out.println(json);
-            
-            // Deserialize back
-            Message deserialized = serializer.deserialize(data, Message.class);
-            System.out.println("\nDeserialized: " + deserialized);
-            System.out.println("✓ JSON serialization successful\n");
-            
-        } catch (SerializationException e) {
-            System.err.println("❌ JSON serialization failed: " + e.getMessage());
-        }
-    }
-    
-    private static void demonstrateFactoryUsage(Message message) {
-        System.out.println("--- Using SerializerFactory ---");
-        
-        try {
-            // Get default serializer (JSON)
-            MessageSerializer serializer = SerializerFactory.createDefault();
-            System.out.println("Default serializer: " + serializer.getName());
-            
-            // Use it
-            byte[] data = serializer.serialize(message);
-            Message deserialized = serializer.deserialize(data, Message.class);
-            
-            System.out.println("Message type: " + deserialized.getType());
-            System.out.println("From: " + deserialized.getSenderId() + 
-                             " → To: " + deserialized.getDestinationId());
-            System.out.println("✓ Factory usage successful\n");
-            
-        } catch (SerializationException e) {
-            System.err.println("❌ Factory usage failed: " + e.getMessage());
-        }
-    }
-    
-    private static void performanceTest(Message message) {
-        System.out.println("--- Performance Test ---");
-        
-        int iterations = 1000;
-        
-        try {
-            MessageSerializer compactSerializer = new JsonMessageSerializer(false);
-            MessageSerializer prettySerializer = new JsonMessageSerializer(true);
-            
-            // Warm up
-            for (int i = 0; i < 100; i++) {
-                compactSerializer.serialize(message);
-            }
-            
-            // Test compact JSON
-            long compactStart = System.nanoTime();
-            byte[] compactData = null;
-            for (int i = 0; i < iterations; i++) {
-                compactData = compactSerializer.serialize(message);
-            }
-            long compactTime = System.nanoTime() - compactStart;
-            
-            // Test pretty JSON
-            byte[] prettyData = prettySerializer.serialize(message);
-            
-            // Results
-            System.out.println("Iterations: " + iterations);
-            System.out.println("\nJSON Compact:");
-            System.out.println("  Size: " + compactData.length + " bytes");
-            System.out.println("  Time: " + (compactTime / 1_000_000.0) + " ms total");
-            System.out.println("  Avg:  " + (compactTime / iterations / 1_000.0) + " μs/operation");
-            
-            System.out.println("\nJSON Pretty-Print:");
-            System.out.println("  Size: " + prettyData.length + " bytes");
-            System.out.println("  Size increase: " + 
-                String.format("%.1f%%", ((double)prettyData.length / compactData.length - 1) * 100));
-            
-        } catch (SerializationException e) {
-            System.err.println("❌ Performance test failed: " + e.getMessage());
-        }
-    }
-}

main/src/main/java/sd/util/StatisticsCollector.java

@@ -1,379 +0,0 @@
-package sd.util;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import sd.config.SimulationConfig;
-import sd.model.Intersection;
-import sd.model.Vehicle;
-import sd.model.VehicleType;
-
-/**
- * Collects, manages, and reports statistics throughout the simulation.
- * * This class acts as the central bookkeeper for simulation metrics. It tracks:
- * - Overall system statistics (total vehicles, completion time, wait time).
- * - Per-vehicle-type statistics (counts, average wait time by type).
- * - Per-intersection statistics (arrivals, departures).
- * * It also maintains "in-flight" data, such as the arrival time of a
- * vehicle at its *current* intersection, which is necessary to
- * calculate waiting time when the vehicle later departs.
- */
-public class StatisticsCollector {
-    
-    // --- Vehicle tracking (for in-flight vehicles) ---
-    
-    /**
-     * Tracks the simulation time when a vehicle arrives at its *current* intersection.
-     * This is used later to calculate waiting time (Depart_Time - Arrive_Time).
-     * Key: Vehicle ID (String)
-     * Value: Arrival Time (Double)
-     */
-    private final Map<String, Double> vehicleArrivalTimes;
-    
-    /**
-     * Tracks the sequence of intersections a vehicle has visited.
-     * Key: Vehicle ID (String)
-     * Value: List of Intersection IDs (String)
-     */
-    private final Map<String, List<String>> vehicleIntersectionHistory;
-    
-    // --- Overall system statistics ---
-    
-    /** Total number of vehicles created by the {@link VehicleGenerator}. */
-    private int totalVehiclesGenerated;
-    
-    /** Total number of vehicles that have reached their final destination ("S"). */
-    private int totalVehiclesCompleted;
-    
-    /** The sum of all *completed* vehicles' total travel times. Used for averaging. */
-    private double totalSystemTime;
-    
-    /** The sum of all *completed* vehicles' total waiting times. Used for averaging. */
-    private double totalWaitingTime;
-    
-    // --- Per-vehicle-type statistics ---
-    
-    /**
-     * Tracks the total number of vehicles generated, broken down by type.
-     * Key: {@link VehicleType}
-     * Value: Count (Integer)
-     */
-    private final Map<VehicleType, Integer> vehicleTypeCount;
-    
-    /**
-     * Tracks the total waiting time, broken down by vehicle type.
-     * Key: {@link VehicleType}
-     * Value: Total Wait Time (Double)
-     */
-    private final Map<VehicleType, Double> vehicleTypeWaitTime;
-    
-    // --- Per-intersection statistics ---
-    
-    /**
-     * A map to hold statistics objects for each intersection.
-     * Key: Intersection ID (String)
-     * Value: {@link IntersectionStats} object
-     */
-    private final Map<String, IntersectionStats> intersectionStats;
-    
-    /**
-     * Constructs a new StatisticsCollector.
-     * Initializes all maps and counters.
-     *
-     * @param config The {@link SimulationConfig} (not currently used, but
-     * could be for configuration-dependent stats).
-     */
-    public StatisticsCollector(SimulationConfig config) {
-        this.vehicleArrivalTimes = new HashMap<>();
-        this.vehicleIntersectionHistory = new HashMap<>();
-        this.totalVehiclesGenerated = 0;
-        this.totalVehiclesCompleted = 0;
-        this.totalSystemTime = 0.0;
-        this.totalWaitingTime = 0.0;
-        this.vehicleTypeCount = new HashMap<>();
-        this.vehicleTypeWaitTime = new HashMap<>();
-        this.intersectionStats = new HashMap<>();
-        
-        // Initialize vehicle type counters to 0
-        for (VehicleType type : VehicleType.values()) {
-            vehicleTypeCount.put(type, 0);
-            vehicleTypeWaitTime.put(type, 0.0);
-        }
-    }
-    
-    /**
-     * Records that a new vehicle has been generated.
-     * This is called by the {@link sd.engine.SimulationEngine}
-     * during a {@code VEHICLE_GENERATION} event.
-     *
-     * @param vehicle The {@link Vehicle} that was just created.
-     * @param currentTime The simulation time of the event.
-     */
-    public void recordVehicleGeneration(Vehicle vehicle, double currentTime) {
-        totalVehiclesGenerated++;
-        
-        // Track by vehicle type
-        VehicleType type = vehicle.getType();
-        vehicleTypeCount.put(type, vehicleTypeCount.get(type) + 1);
-        
-        // Initialize history tracking for this vehicle
-        vehicleIntersectionHistory.put(vehicle.getId(), new ArrayList<>());
-    }
-    
-    /**
-     * Records that a vehicle has arrived at an intersection queue.
-     * This is called by the {@link sd.engine.SimulationEngine}
-     * during a {@code VEHICLE_ARRIVAL} event.
-     *
-     * @param vehicle The {@link Vehicle} that arrived.
-     * @param intersectionId The ID of the intersection it arrived at.
-     * @param currentTime The simulation time of the arrival.
-     */
-    public void recordVehicleArrival(Vehicle vehicle, String intersectionId, double currentTime) {
-        // Store arrival time - this is the "start waiting" time
-        vehicleArrivalTimes.put(vehicle.getId(), currentTime);
-        
-        // Track intersection history
-        List<String> history = vehicleIntersectionHistory.get(vehicle.getId());
-        if (history != null) {
-            history.add(intersectionId);
-        }
-        
-        // Update per-intersection statistics
-        getOrCreateIntersectionStats(intersectionId).recordArrival();
-    }
-    
-    /**
-     * Records that a vehicle has completed its route and exited the system.
-     * This is where final metrics for the vehicle are aggregated.
-     * This is called by the {@link sd.engine.SimulationEngine}
-     * when a vehicle reaches destination "S".
-     *
-     * @param vehicle The {@link Vehicle} that is exiting.
-     * @param currentTime The simulation time of the exit.
-     */
-    public void recordVehicleExit(Vehicle vehicle, double currentTime) {
-        totalVehiclesCompleted++;
-        
-        // Calculate and aggregate total system time
-        double systemTime = vehicle.getTotalTravelTime(currentTime);
-        totalSystemTime += systemTime;
-        
-        // Aggregate waiting time
-        double waitTime = vehicle.getTotalWaitingTime();
-        totalWaitingTime += waitTime;
-        
-        // Aggregate waiting time by vehicle type
-        VehicleType type = vehicle.getType();
-        vehicleTypeWaitTime.put(type, vehicleTypeWaitTime.get(type) + waitTime);
-        
-        // Clean up tracking maps to save memory
-        vehicleArrivalTimes.remove(vehicle.getId());
-        vehicleIntersectionHistory.remove(vehicle.getId());
-    }
-    
-    /**
-     * Gets the time a vehicle arrived at its *current* intersection.
-     * This is used by the {@link sd.engine.SimulationEngine} to calculate
-     * wait time just before the vehicle crosses.
-     *
-     * @param vehicle The {@link Vehicle} to check.
-     * @return The arrival time, or 0.0 if not found.
-     */
-    public double getArrivalTime(Vehicle vehicle) {
-        return vehicleArrivalTimes.getOrDefault(vehicle.getId(), 0.0);
-    }
-    
-    /**
-     * Prints a "snapshot" of the current simulation statistics.
-     * This is called periodically by the {@link sd.engine.SimulationEngine}
-     * during a {@code STATISTICS_UPDATE} event.
-     *
-     * @param intersections A map of all intersections (to get queue data).
-     * @param currentTime The current simulation time.
-     */
-    public void printCurrentStatistics(Map<String, Intersection> intersections, double currentTime) {
-        System.out.printf("--- Statistics at t=%.2f ---%n", currentTime);
-        System.out.printf("Vehicles: Generated=%d, Completed=%d, In-System=%d%n",
-            totalVehiclesGenerated,
-            totalVehiclesCompleted,
-            totalVehiclesGenerated - totalVehiclesCompleted);
-        
-        if (totalVehiclesCompleted > 0) {
-            System.out.printf("Average System Time (so far): %.2fs%n", totalSystemTime / totalVehiclesCompleted);
-            System.out.printf("Average Waiting Time (so far): %.2fs%n", totalWaitingTime / totalVehiclesCompleted);
-        }
-        
-        // Print per-intersection queue sizes
-        System.out.println("\nIntersection Queues:");
-        for (Map.Entry<String, Intersection> entry : intersections.entrySet()) {
-            String id = entry.getKey();
-            Intersection intersection = entry.getValue();
-            System.out.printf("  %s: Queue=%d, Received=%d, Sent=%d%n",
-                id,
-                intersection.getTotalQueueSize(),
-                intersection.getTotalVehiclesReceived(),
-                intersection.getTotalVehiclesSent());
-        }
-    }
-    
-    /**
-     * Prints the final simulation summary statistics at the end of the run.
-     *
-     * @param intersections A map of all intersections.
-     * @param currentTime The final simulation time.
-     */
-    public void printFinalStatistics(Map<String, Intersection> intersections, double currentTime) {
-        System.out.println("\n=== SIMULATION SUMMARY ===");
-        System.out.printf("Duration: %.2f seconds%n", currentTime);
-        System.out.printf("Total Vehicles Generated: %d%n", totalVehiclesGenerated);
-        System.out.printf("Total Vehicles Completed: %d%n", totalVehiclesCompleted);
-        System.out.printf("Vehicles Still in System: %d%n", totalVehiclesGenerated - totalVehiclesCompleted);
-        
-        // Overall averages
-        if (totalVehiclesCompleted > 0) {
-            System.out.printf("%nAVERAGE METRICS (for completed vehicles):%n");
-            System.out.printf("  System Time: %.2f seconds%n", totalSystemTime / totalVehiclesCompleted);
-            System.out.printf("  Waiting Time: %.2f seconds%n", totalWaitingTime / totalVehiclesCompleted);
-            System.out.printf("  Throughput: %.2f vehicles/second%n", totalVehiclesCompleted / currentTime);
-        }
-        
-        // Vehicle type breakdown
-        System.out.println("\nVEHICLE TYPE DISTRIBUTION:");
-        for (VehicleType type : VehicleType.values()) {
-            int count = vehicleTypeCount.get(type);
-            if (count > 0) {
-                double percentage = (count * 100.0) / totalVehiclesGenerated;
-                // Calculate avg wait *only* for this type
-                // This assumes all generated vehicles of this type *completed*
-                // A more accurate way would be to track completed vehicle types
-                double avgWait = vehicleTypeWaitTime.get(type) / count; 
-                System.out.printf("  %s: %d (%.1f%%), Avg Wait: %.2fs%n",
-                    type, count, percentage, avgWait);
-            }
-        }
-        
-        // Per-intersection statistics
-        System.out.println("\nINTERSECTION STATISTICS:");
-        for (Map.Entry<String, Intersection> entry : intersections.entrySet()) {
-            String id = entry.getKey();
-            Intersection intersection = entry.getValue();
-            
-            System.out.printf("  %s:%n", id);
-            System.out.printf("    Vehicles Received: %d%n", intersection.getTotalVehiclesReceived());
-            System.out.printf("    Vehicles Sent: %d%n", intersection.getTotalVehiclesSent());
-            System.out.printf("    Final Queue Size: %d%n", intersection.getTotalQueueSize());
-            
-            // Traffic light details
-            intersection.getTrafficLights().forEach(light -> {
-                System.out.printf("      Light %s: State=%s, Queue=%d, Processed=%d%n",
-                    light.getDirection(),
-                    light.getState(),
-                    light.getQueueSize(),
-                    light.getTotalVehiclesProcessed());
-            });
-        }
-        
-        // System health indicators
-        System.out.println("\nSYSTEM HEALTH:");
-        int totalQueuedVehicles = intersections.values().stream()
-            .mapToInt(Intersection::getTotalQueueSize)
-            .sum();
-        System.out.printf("  Total Queued Vehicles (at end): %d%n", totalQueuedVehicles);
-        
-        if (totalVehiclesGenerated > 0) {
-            double completionRate = (totalVehiclesCompleted * 100.0) / totalVehiclesGenerated;
-            System.out.printf("  Completion Rate: %.1f%%%n", completionRate);
-        }
-    }
-    
-    /**
-     * Gets or creates the statistics object for a given intersection.
-     * Uses {@code computeIfAbsent} for efficient, thread-safe-like instantiation.
-     *
-     * @param intersectionId The ID of the intersection.
-     * @return The {@link IntersectionStats} object for that ID.
-     */
-    private IntersectionStats getOrCreateIntersectionStats(String intersectionId) {
-        // If 'intersectionId' is not in the map, create a new IntersectionStats()
-        // and put it in the map, then return it.
-        // Otherwise, just return the one that's already there.
-        return intersectionStats.computeIfAbsent(intersectionId, k -> new IntersectionStats());
-    }
-    
-    /**
-     * Inner class to track per-intersection statistics.
-     * This is a simple data holder.
-     */
-    private static class IntersectionStats {
-        private int totalArrivals;
-        private int totalDepartures;
-        
-        public IntersectionStats() {
-            this.totalArrivals = 0;
-            this.totalDepartures = 0;
-        }
-        
-        public void recordArrival() {
-            totalArrivals++;
-        }
-        
-        public void recordDeparture() {
-            totalDepartures++;
-        }
-        
-        public int getTotalArrivals() {
-            return totalArrivals;
-        }
-        
-        public int getTotalDepartures() {
-            return totalDepartures;
-        }
-    }
-    
-    // --- Public Getters for Final Statistics ---
-    
-    /**
-     * @return Total vehicles generated during the simulation.
-     */
-    public int getTotalVehiclesGenerated() {
-        return totalVehiclesGenerated;
-    }
-    
-    /**
-     * @return Total vehicles that completed their route.
-     */
-    public int getTotalVehiclesCompleted() {
-        return totalVehiclesCompleted;
-    }
-    
-    /**
-     * @return The sum of all travel times for *completed* vehicles.
-     */
-    public double getTotalSystemTime() {
-        return totalSystemTime;
-    }
-    
-    /**
-     * @return The sum of all waiting times for *completed* vehicles.
-     */
-    public double getTotalWaitingTime() {
-        return totalWaitingTime;
-    }
-    
-    /**
-     * @return The average travel time for *completed* vehicles.
-     */
-    public double getAverageSystemTime() {
-        return totalVehiclesCompleted > 0 ? totalSystemTime / totalVehiclesCompleted : 0.0;
-    }
-    
-    /**
-     * @return The average waiting time for *completed* vehicles.
-     */
-    public double getAverageWaitingTime() {
-        return totalVehiclesCompleted > 0 ? totalWaitingTime / totalVehiclesCompleted : 0.0;
-    }
-}

main/src/main/resources/dashboard.css

@@ -0,0 +1,142 @@
+/* Global Styles */
+.root {
+    -fx-background-color: #f4f7f6;
+    -fx-font-family: 'Segoe UI', sans-serif;
+}
+
+/* Header */
+.header {
+    -fx-background-color: linear-gradient(to right, #2c3e50, #4ca1af);
+    -fx-padding: 20;
+    -fx-effect: dropshadow(three-pass-box, rgba(0,0,0,0.2), 10, 0, 0, 5);
+}
+
+.header-title {
+    -fx-font-size: 28px;
+    -fx-font-weight: bold;
+    -fx-text-fill: white;
+}
+
+.header-subtitle {
+    -fx-font-size: 16px;
+    -fx-text-fill: #ecf0f1;
+}
+
+/* Buttons */
+.button-start {
+    -fx-background-color: #2ecc71;
+    -fx-text-fill: white;
+    -fx-font-weight: bold;
+    -fx-padding: 10 20;
+    -fx-background-radius: 5;
+    -fx-cursor: hand;
+    -fx-effect: dropshadow(three-pass-box, rgba(0,0,0,0.1), 5, 0, 0, 2);
+}
+
+.button-start:hover {
+    -fx-background-color: #27ae60;
+}
+
+.button-start:disabled {
+    -fx-background-color: #95a5a6;
+    -fx-opacity: 0.7;
+}
+
+.button-stop {
+    -fx-background-color: #e74c3c;
+    -fx-text-fill: white;
+    -fx-font-weight: bold;
+    -fx-padding: 10 20;
+    -fx-background-radius: 5;
+    -fx-cursor: hand;
+    -fx-effect: dropshadow(three-pass-box, rgba(0,0,0,0.1), 5, 0, 0, 2);
+}
+
+.button-stop:hover {
+    -fx-background-color: #c0392b;
+}
+
+.button-stop:disabled {
+    -fx-background-color: #95a5a6;
+    -fx-opacity: 0.7;
+}
+
+/* Cards / Panels */
+.card {
+    -fx-background-color: white;
+    -fx-background-radius: 8;
+    -fx-effect: dropshadow(three-pass-box, rgba(0,0,0,0.05), 10, 0, 0, 2);
+    -fx-padding: 0; 
+}
+
+.card-header {
+    -fx-background-color: #ecf0f1;
+    -fx-background-radius: 8 8 0 0;
+    -fx-padding: 10 15;
+    -fx-border-color: #bdc3c7;
+    -fx-border-width: 0 0 1 0;
+}
+
+.card-title {
+    -fx-font-size: 16px;
+    -fx-font-weight: bold;
+    -fx-text-fill: #2c3e50;
+}
+
+.card-content {
+    -fx-padding: 15;
+}
+
+/* Statistics Grid */
+.stat-label {
+    -fx-font-size: 14px;
+    -fx-text-fill: #7f8c8d;
+}
+
+.stat-value {
+    -fx-font-size: 20px;
+    -fx-font-weight: bold;
+    -fx-text-fill: #2980b9;
+}
+
+/* Tables */
+.table-view {
+    -fx-background-color: transparent;
+    -fx-border-color: transparent;
+}
+
+.table-view .column-header-background {
+    -fx-background-color: #ecf0f1;
+    -fx-border-color: #bdc3c7;
+    -fx-border-width: 0 0 1 0;
+}
+
+.table-view .column-header .label {
+    -fx-text-fill: #2c3e50;
+    -fx-font-weight: bold;
+}
+
+.table-row-cell {
+    -fx-background-color: white;
+    -fx-border-color: transparent;
+}
+
+.table-row-cell:odd {
+    -fx-background-color: #f9f9f9;
+}
+
+.table-row-cell:selected {
+    -fx-background-color: #3498db;
+    -fx-text-fill: white;
+}
+
+/* Footer */
+.footer {
+    -fx-background-color: #34495e;
+    -fx-padding: 10 20;
+}
+
+.footer-text {
+    -fx-text-fill: #ecf0f1;
+    -fx-font-size: 12px;
+}

main/src/main/resources/network_config.json

@@ -0,0 +1,43 @@
+{
+  "intersections": [
+    {
+      "id": "Cr1",
+      "lights": ["East", "South"],
+      "routes": {
+        "Cr2": "East",
+        "Cr4": "South"
+      }
+    },
+    {
+      "id": "Cr2",
+      "lights": ["West", "East", "South"],
+      "routes": {
+        "Cr1": "West",
+        "Cr3": "East",
+        "Cr5": "South"
+      }
+    },
+    {
+      "id": "Cr3",
+      "lights": ["West", "South"],
+      "routes": {
+        "Cr2": "West",
+        "S": "South"
+      }
+    },
+    {
+      "id": "Cr4",
+      "lights": ["East"],
+      "routes": {
+        "Cr5": "East"
+      }
+    },
+    {
+      "id": "Cr5",
+      "lights": ["East"],
+      "routes": {
+        "S": "East"
+      }
+    }
+  ]
+}

main/src/main/resources/simulation.properties

@@ -46,54 +46,44 @@ simulation.arrival.fixed.interval=2.0
 # === TRAFFIC LIGHT TIMINGS ===
 # Format: trafficlight.<intersection>.<direction>.<state>=<seconds>
 
-# Intersection 1
+# Intersection 1 (Entry point - balanced)
-trafficlight.Cr1.North.green=30.0
+trafficlight.Cr1.South.green=20.0
-trafficlight.Cr1.North.red=30.0
+trafficlight.Cr1.South.red=40.0
-trafficlight.Cr1.South.green=30.0
+trafficlight.Cr1.East.green=20.0
-trafficlight.Cr1.South.red=30.0
+trafficlight.Cr1.East.red=40.0
-trafficlight.Cr1.East.green=30.0
+trafficlight.Cr1.West.green=20.0
-trafficlight.Cr1.East.red=30.0
+trafficlight.Cr1.West.red=40.0
-trafficlight.Cr1.West.green=30.0
-trafficlight.Cr1.West.red=30.0
 
-# Intersection 2
+# Intersection 2 (Main hub - shorter cycles, favor East-West)
-trafficlight.Cr2.North.green=25.0
+trafficlight.Cr2.South.green=12.0
-trafficlight.Cr2.North.red=35.0
+trafficlight.Cr2.South.red=36.0
-trafficlight.Cr2.South.green=25.0
+trafficlight.Cr2.East.green=18.0
-trafficlight.Cr2.South.red=35.0
+trafficlight.Cr2.East.red=30.0
-trafficlight.Cr2.East.green=35.0
+trafficlight.Cr2.West.green=18.0
-trafficlight.Cr2.East.red=25.0
+trafficlight.Cr2.West.red=30.0
-trafficlight.Cr2.West.green=35.0
-trafficlight.Cr2.West.red=25.0
 
-# Intersection 3
+# Intersection 3 (Path to exit - favor East)
-trafficlight.Cr3.North.green=30.0
+trafficlight.Cr3.South.green=15.0
-trafficlight.Cr3.North.red=30.0
-trafficlight.Cr3.South.green=30.0
 trafficlight.Cr3.South.red=30.0
-trafficlight.Cr3.East.green=30.0
+trafficlight.Cr3.East.green=20.0
-trafficlight.Cr3.East.red=30.0
+trafficlight.Cr3.East.red=25.0
-trafficlight.Cr3.West.green=30.0
+trafficlight.Cr3.West.green=15.0
 trafficlight.Cr3.West.red=30.0
 
-# Intersection 4
+# Intersection 4 (Favor East toward Cr5)
-trafficlight.Cr4.North.green=30.0
+trafficlight.Cr4.South.green=15.0
-trafficlight.Cr4.North.red=30.0
-trafficlight.Cr4.South.green=30.0
 trafficlight.Cr4.South.red=30.0
-trafficlight.Cr4.East.green=30.0
+trafficlight.Cr4.East.green=20.0
-trafficlight.Cr4.East.red=30.0
+trafficlight.Cr4.East.red=25.0
-trafficlight.Cr4.West.green=30.0
+trafficlight.Cr4.West.green=15.0
 trafficlight.Cr4.West.red=30.0
 
-# Intersection 5
+# Intersection 5 (Near exit - favor East)
-trafficlight.Cr5.North.green=30.0
+trafficlight.Cr5.South.green=15.0
-trafficlight.Cr5.North.red=30.0
-trafficlight.Cr5.South.green=30.0
 trafficlight.Cr5.South.red=30.0
-trafficlight.Cr5.East.green=30.0
+trafficlight.Cr5.East.green=22.0
-trafficlight.Cr5.East.red=30.0
+trafficlight.Cr5.East.red=23.0
-trafficlight.Cr5.West.green=30.0
+trafficlight.Cr5.West.green=15.0
 trafficlight.Cr5.West.red=30.0
 
 # === VEHICLE CONFIGURATION ===
@@ -103,11 +93,19 @@ vehicle.probability.light=0.6
 vehicle.probability.heavy=0.2
 
 # Average crossing times (in seconds)
-vehicle.crossing.time.bike=1.5
+vehicle.crossing.time.bike=1.0
 vehicle.crossing.time.light=2.0
 vehicle.crossing.time.heavy=4.0
 
+# Travel times between intersections (in seconds)
+# Base time for light vehicles (cars)
+vehicle.travel.time.base=8.0
+# Bike travel time = 0.5 × car travel time
+vehicle.travel.time.bike.multiplier=0.5
+# Heavy vehicle travel time = 4 × bike travel time
+vehicle.travel.time.heavy.multiplier=2.0
+
 # === STATISTICS ===
 
 # Interval between dashboard updates (seconds)
-statistics.update.interval=10.0
+statistics.update.interval=1.0

main/src/test/java/IntersectionProcessTest.java

@@ -0,0 +1,527 @@
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Arrays;
+
+import org.junit.jupiter.api.AfterEach;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
+import org.junit.jupiter.api.io.TempDir;
+
+import sd.IntersectionProcess;
+import sd.model.MessageType;
+import sd.model.Vehicle;
+import sd.model.VehicleType;
+import sd.protocol.SocketConnection;
+
+/**
+ * Tests for IntersectionProcess - covers initialization, traffic lights,
+ * vehicle transfer and network stuff
+ */
+public class IntersectionProcessTest {
+
+    @TempDir
+    Path tempDir;
+
+    private Path configFile;
+    private IntersectionProcess intersectionProcess;
+
+    // setup test config before each test
+    @BeforeEach
+    public void setUp() throws IOException {
+        // create temp config file
+        configFile = tempDir.resolve("test-simulation.properties");
+
+        String configContent = """
+                # Test Simulation Configuration
+
+                # Intersection Network Configuration
+                intersection.Cr1.host=localhost
+                intersection.Cr1.port=18001
+                intersection.Cr2.host=localhost
+                intersection.Cr2.port=18002
+                intersection.Cr3.host=localhost
+                intersection.Cr3.port=18003
+                intersection.Cr4.host=localhost
+                intersection.Cr4.port=18004
+                intersection.Cr5.host=localhost
+                intersection.Cr5.port=18005
+
+                # Exit Configuration
+                exit.host=localhost
+                exit.port=18099
+
+                # Dashboard Configuration
+                dashboard.host=localhost
+                dashboard.port=18100
+
+                # Traffic Light Timing (seconds)
+                trafficLight.Cr1.East.greenTime=5.0
+                trafficLight.Cr1.East.redTime=5.0
+                trafficLight.Cr1.South.greenTime=5.0
+                trafficLight.Cr1.South.redTime=5.0
+                trafficLight.Cr1.West.greenTime=5.0
+                trafficLight.Cr1.West.redTime=5.0
+
+                trafficLight.Cr2.West.greenTime=4.0
+                trafficLight.Cr2.West.redTime=6.0
+                trafficLight.Cr2.East.greenTime=4.0
+                trafficLight.Cr2.East.redTime=6.0
+                trafficLight.Cr2.South.greenTime=4.0
+                trafficLight.Cr2.South.redTime=6.0
+
+                trafficLight.Cr3.West.greenTime=3.0
+                trafficLight.Cr3.West.redTime=7.0
+                trafficLight.Cr3.East.greenTime=3.0
+                trafficLight.Cr3.East.redTime=7.0
+
+                trafficLight.Cr4.East.greenTime=6.0
+                trafficLight.Cr4.East.redTime=4.0
+
+                trafficLight.Cr5.East.greenTime=5.0
+                trafficLight.Cr5.East.redTime=5.0
+
+                # Vehicle Crossing Times (seconds)
+                vehicle.bike.crossingTime=2.0
+                vehicle.light.crossingTime=3.0
+                vehicle.heavy.crossingTime=5.0
+                """;
+
+        Files.writeString(configFile, configContent);
+    }
+
+    @AfterEach
+    public void tearDown() {
+        if (intersectionProcess != null) {
+            try {
+                // Only shutdown if still running
+                intersectionProcess.shutdown();
+            } catch (Exception e) {
+                System.err.println("Error in tearDown: " + e.getMessage());
+            } finally {
+                intersectionProcess = null;
+            }
+        }
+    }
+
+    // ==================== Initialization Tests ====================
+
+    @Test
+    public void testConstructor_Success() throws IOException {
+        intersectionProcess = new IntersectionProcess("Cr1", configFile.toString());
+        assertNotNull(intersectionProcess);
+    }
+
+    @Test
+    public void testConstructor_InvalidConfig() {
+        Exception exception = assertThrows(IOException.class, () -> {
+            new IntersectionProcess("Cr1", "non-existent-config.properties");
+        });
+        assertNotNull(exception);
+    }
+
+    @Test
+    public void testInitialize_Cr1() throws IOException {
+        intersectionProcess = new IntersectionProcess("Cr1", configFile.toString());
+        assertDoesNotThrow(() -> intersectionProcess.initialize());
+    }
+
+    @Test
+    public void testInitialize_Cr2() throws IOException {
+        intersectionProcess = new IntersectionProcess("Cr2", configFile.toString());
+        assertDoesNotThrow(() -> intersectionProcess.initialize());
+    }
+
+    @Test
+    public void testInitialize_Cr3() throws IOException {
+        intersectionProcess = new IntersectionProcess("Cr3", configFile.toString());
+        assertDoesNotThrow(() -> intersectionProcess.initialize());
+    }
+
+    @Test
+    public void testInitialize_Cr4() throws IOException {
+        intersectionProcess = new IntersectionProcess("Cr4", configFile.toString());
+        assertDoesNotThrow(() -> intersectionProcess.initialize());
+    }
+
+    @Test
+    public void testInitialize_Cr5() throws IOException {
+        intersectionProcess = new IntersectionProcess("Cr5", configFile.toString());
+        assertDoesNotThrow(() -> intersectionProcess.initialize());
+    }
+
+    // traffic light creation tests
+
+    @Test
+    public void testTrafficLightCreation_Cr1_HasCorrectDirections() throws IOException {
+        intersectionProcess = new IntersectionProcess("Cr1", configFile.toString());
+        intersectionProcess.initialize();
+
+        // cant access private fields but initialization succeds
+        assertNotNull(intersectionProcess);
+    }
+
+    @Test
+    public void testTrafficLightCreation_Cr3_HasCorrectDirections() throws IOException {
+        intersectionProcess = new IntersectionProcess("Cr3", configFile.toString());
+        intersectionProcess.initialize();
+
+        // Cr3 has west and south only
+        assertNotNull(intersectionProcess);
+    }
+
+    @Test
+    public void testTrafficLightCreation_Cr4_HasSingleDirection() throws IOException {
+        intersectionProcess = new IntersectionProcess("Cr4", configFile.toString());
+        intersectionProcess.initialize();
+
+        // Cr4 only has east direction
+        assertNotNull(intersectionProcess);
+    }
+
+    // server startup tests
+
+    @Test
+    @Timeout(5)
+    public void testServerStart_BindsToCorrectPort() throws IOException, InterruptedException {
+        intersectionProcess = new IntersectionProcess("Cr1", configFile.toString());
+        intersectionProcess.initialize();
+
+        // start server in separate thread
+        Thread serverThread = new Thread(() -> {
+            try {
+                intersectionProcess.start();
+            } catch (IOException e) {
+                // expected on shutdown
+            }
+        });
+        serverThread.start();
+
+        // Wait for server to actually start with retries
+        boolean serverReady = false;
+        for (int i = 0; i < 20; i++) {
+            Thread.sleep(100);
+            try (Socket testSocket = new Socket()) {
+                testSocket.connect(new java.net.InetSocketAddress("localhost", 18001), 500);
+                serverReady = true;
+                break;
+            } catch (IOException e) {
+                // Server not ready yet, continue waiting
+            }
+        }
+
+        assertTrue(serverReady, "Server should start and bind to port 18001");
+
+        // Shutdown immediately after confirming server is running
+        intersectionProcess.shutdown();
+        serverThread.join(2000);
+    }
+
+    @Test
+    @Timeout(5)
+    public void testServerStart_MultipleIntersections() throws IOException, InterruptedException {
+        // test 2 intersections on diferent ports
+        IntersectionProcess cr1 = new IntersectionProcess("Cr1", configFile.toString());
+        IntersectionProcess cr2 = new IntersectionProcess("Cr2", configFile.toString());
+
+        cr1.initialize();
+        cr2.initialize();
+
+        Thread thread1 = new Thread(() -> {
+            try {
+                cr1.start();
+            } catch (IOException e) {
+            }
+        });
+
+        Thread thread2 = new Thread(() -> {
+            try {
+                cr2.start();
+            } catch (IOException e) {
+            }
+        });
+
+        thread1.start();
+        thread2.start();
+
+        Thread.sleep(500);
+
+        // check both are running
+        try (Socket socket1 = new Socket("localhost", 18001);
+                Socket socket2 = new Socket("localhost", 18002)) {
+            assertTrue(socket1.isConnected());
+            assertTrue(socket2.isConnected());
+        }
+
+        cr1.shutdown();
+        cr2.shutdown();
+        thread1.join(2000);
+        thread2.join(2000);
+    }
+
+    // vehicle transfer tests
+
+    @Test
+    @Timeout(10)
+    public void testVehicleTransfer_ReceiveVehicle() throws IOException, InterruptedException {
+        // setup reciever intersection
+        intersectionProcess = new IntersectionProcess("Cr2", configFile.toString());
+        intersectionProcess.initialize();
+
+        Thread serverThread = new Thread(() -> {
+            try {
+                intersectionProcess.start();
+            } catch (IOException e) {
+            }
+        });
+        serverThread.start();
+
+        Thread.sleep(500);
+
+        try {
+            // create test vehicle - FIXED: use 4-parameter constructor
+            java.util.List<String> route = Arrays.asList("Cr2", "Cr3", "S");
+            Vehicle vehicle = new Vehicle("V001", VehicleType.LIGHT, 0.0, route);
+
+            // send vehicle from Cr1 to Cr2 - FIXED: use SocketConnection
+            try (Socket socket = new Socket("localhost", 18002);
+                    SocketConnection conn = new SocketConnection(socket)) {
+
+                TestVehicleMessage message = new TestVehicleMessage("Cr1", "Cr2", vehicle);
+                conn.sendMessage(message);
+
+                Thread.sleep(1000); // wait for processing
+            }
+        } finally {
+            intersectionProcess.shutdown();
+            serverThread.join(2000);
+        }
+    }
+
+    // routing config tests
+
+    @Test
+    public void testRoutingConfiguration_Cr1() throws IOException {
+        intersectionProcess = new IntersectionProcess("Cr1", configFile.toString());
+        intersectionProcess.initialize();
+
+        // indirect test - if init works routing should be ok
+        assertNotNull(intersectionProcess);
+    }
+
+    @Test
+    public void testRoutingConfiguration_Cr5() throws IOException {
+        intersectionProcess = new IntersectionProcess("Cr5", configFile.toString());
+        intersectionProcess.initialize();
+
+        // Cr5 routes to exit
+        assertNotNull(intersectionProcess);
+    }
+
+    // shutdown tests
+
+    @Test
+    @Timeout(5)
+    public void testShutdown_GracefulTermination() throws IOException, InterruptedException {
+        intersectionProcess = new IntersectionProcess("Cr1", configFile.toString());
+        intersectionProcess.initialize();
+
+        Thread serverThread = new Thread(() -> {
+            try {
+                intersectionProcess.start();
+            } catch (IOException e) {
+            }
+        });
+        serverThread.start();
+
+        Thread.sleep(500);
+
+        // shutdown should be fast
+        assertDoesNotThrow(() -> intersectionProcess.shutdown());
+
+        serverThread.join(2000);
+    }
+
+    @Test
+    @Timeout(5)
+    public void testShutdown_ClosesServerSocket() throws IOException, InterruptedException {
+        intersectionProcess = new IntersectionProcess("Cr1", configFile.toString());
+        intersectionProcess.initialize();
+
+        // Start server in separate thread
+        Thread serverThread = new Thread(() -> {
+            try {
+                intersectionProcess.start();
+            } catch (IOException e) {
+                // Expected on shutdown
+            }
+        });
+        serverThread.start();
+
+        // Wait for server to start
+        Thread.sleep(500);
+
+        // Shutdown
+        intersectionProcess.shutdown();
+        serverThread.join(2000);
+
+        // Give shutdown time to complete
+        Thread.sleep(200);
+
+        // Verify we cannot connect (server socket is closed)
+        boolean connectionFailed = false;
+        try (Socket testSocket = new Socket()) {
+            testSocket.connect(new InetSocketAddress("localhost", 18001), 500);
+        } catch (IOException e) {
+            connectionFailed = true; // Expected - server should be closed
+        }
+
+        assertTrue(connectionFailed, "Server socket should be closed after shutdown");
+    }
+
+    @Test
+    @Timeout(5)
+    public void testShutdown_StopsTrafficLightThreads() throws IOException, InterruptedException {
+        intersectionProcess = new IntersectionProcess("Cr1", configFile.toString());
+        intersectionProcess.initialize();
+
+        Thread serverThread = new Thread(() -> {
+            try {
+                intersectionProcess.start();
+            } catch (IOException e) {
+            }
+        });
+        serverThread.start();
+
+        Thread.sleep(500);
+
+        int threadCountBefore = Thread.activeCount();
+
+        intersectionProcess.shutdown();
+        serverThread.join(2000);
+
+        Thread.sleep(500); // wait for threads to die
+
+        // thread count should decrese (traffic light threads stop)
+        int threadCountAfter = Thread.activeCount();
+        assertTrue(threadCountAfter <= threadCountBefore);
+    }
+
+    // integration tests
+
+    @Test
+    @Timeout(15)
+    public void testIntegration_TwoIntersectionsVehicleTransfer() throws IOException, InterruptedException {
+        IntersectionProcess cr1 = null;
+        IntersectionProcess cr2 = null;
+        Thread thread1 = null;
+        Thread thread2 = null;
+
+        try {
+            // setup 2 intersections
+            cr1 = new IntersectionProcess("Cr1", configFile.toString());
+            cr2 = new IntersectionProcess("Cr2", configFile.toString());
+
+            cr1.initialize();
+            cr2.initialize();
+
+            // start both
+            final IntersectionProcess cr1Final = cr1;
+            thread1 = new Thread(() -> {
+                try {
+                    cr1Final.start();
+                } catch (IOException e) {
+                }
+            });
+
+            final IntersectionProcess cr2Final = cr2;
+            thread2 = new Thread(() -> {
+                try {
+                    cr2Final.start();
+                } catch (IOException e) {
+                }
+            });
+
+            thread1.start();
+            thread2.start();
+
+            Thread.sleep(1000); // wait for servers
+
+            // send vehicle to Cr1 that goes to Cr2 - FIXED: use 4-parameter constructor
+            java.util.List<String> route = Arrays.asList("Cr1", "Cr2", "S");
+            Vehicle vehicle = new Vehicle("V001", VehicleType.LIGHT, 0.0, route);
+
+            // FIXED: use SocketConnection
+            try (Socket socket = new Socket("localhost", 18001);
+                    SocketConnection conn = new SocketConnection(socket)) {
+
+                TestVehicleMessage message = new TestVehicleMessage("Entry", "Cr1", vehicle);
+                conn.sendMessage(message);
+
+                Thread.sleep(2000); // time for processing
+            }
+        } finally {
+            if (cr1 != null) {
+                cr1.shutdown();
+            }
+            if (cr2 != null) {
+                cr2.shutdown();
+            }
+            if (thread1 != null) {
+                thread1.join(2000);
+            }
+            if (thread2 != null) {
+                thread2.join(2000);
+            }
+        }
+    }
+
+    @Test
+    public void testMain_MissingArguments() {
+        // main needs intersection ID as argument
+        // cant test System.exit easily in modern java
+        assertTrue(true, "Main method expects intersection ID as first argument");
+    }
+
+    // helper class for testing vehicle messages
+    private static class TestVehicleMessage implements sd.protocol.MessageProtocol {
+        private static final long serialVersionUID = 1L;
+
+        private final String sourceNode;
+        private final String destinationNode;
+        private final Vehicle payload;
+
+        public TestVehicleMessage(String sourceNode, String destinationNode, Vehicle vehicle) {
+            this.sourceNode = sourceNode;
+            this.destinationNode = destinationNode;
+            this.payload = vehicle;
+        }
+
+        @Override
+        public MessageType getType() {
+            return MessageType.VEHICLE_TRANSFER;
+        }
+
+        @Override
+        public Object getPayload() {
+            return payload;
+        }
+
+        @Override
+        public String getSourceNode() {
+            return sourceNode;
+        }
+
+        @Override
+        public String getDestinationNode() {
+            return destinationNode;
+        }
+    }
+}

main/src/test/java/SimulationTest.java

@@ -6,15 +6,11 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
 import org.junit.jupiter.api.Test;
 
 import sd.config.SimulationConfig;
-import sd.engine.SimulationEngine;
-import sd.model.Event;
-import sd.model.EventType;
 import sd.model.Intersection;
 import sd.model.TrafficLight;
 import sd.model.TrafficLightState;
 import sd.model.Vehicle;
 import sd.model.VehicleType;
-import sd.util.StatisticsCollector;
 import sd.util.VehicleGenerator;
 
 /**
@@ -29,7 +25,7 @@ class SimulationTest {
         assertEquals(60.0, config.getSimulationDuration());
         assertEquals("POISSON", config.getArrivalModel());
         assertEquals(0.5, config.getArrivalRate());
-        assertEquals(10.0, config.getStatisticsUpdateInterval());
+        assertEquals(1.0, config.getStatisticsUpdateInterval());
     }
 
     @Test
@@ -43,17 +39,7 @@ class SimulationTest {
         assertEquals("TEST1", vehicle.getId());
         assertNotNull(vehicle.getType());
         assertNotNull(vehicle.getRoute());
-        assertTrue(vehicle.getRoute().size() > 0);
+        assertTrue(!vehicle.getRoute().isEmpty());
-    }
-    
-    @Test
-    void testEventOrdering() {
-        Event e1 = new Event(5.0, EventType.VEHICLE_ARRIVAL, null, "Cr1");
-        Event e2 = new Event(3.0, EventType.VEHICLE_ARRIVAL, null, "Cr2");
-        Event e3 = new Event(7.0, EventType.TRAFFIC_LIGHT_CHANGE, null, "Cr1");
-        
-        assertTrue(e2.compareTo(e1) < 0); // e2 should come before e1
-        assertTrue(e1.compareTo(e3) < 0); // e1 should come before e3
     }
 
     @Test
@@ -90,36 +76,7 @@ class SimulationTest {
         assertEquals(TrafficLightState.RED, light.getState());
     }
 
-    @Test
+    // Removed testSimulationEngineInitialization as SimulationEngine has been
-    void testSimulationEngineInitialization() throws IOException {
+    // removed.
-        SimulationConfig config = new SimulationConfig("src/main/resources/simulation.properties");
-        SimulationEngine engine = new SimulationEngine(config);
 
-        engine.initialize();
-        
-        assertNotNull(engine.getIntersections());
-        assertEquals(5, engine.getIntersections().size());
-        
-        // Check that intersections have traffic lights
-        for (Intersection intersection : engine.getIntersections().values()) {
-            assertEquals(3, intersection.getTrafficLights().size()); // North, South, East, West
-        }
-    }
-    
-    @Test
-    void testStatisticsCollector() throws IOException {
-        SimulationConfig config = new SimulationConfig("src/main/resources/simulation.properties");
-        StatisticsCollector collector = new StatisticsCollector(config);
-        
-        Vehicle v1 = new Vehicle("V1", VehicleType.LIGHT, 0.0, 
-            java.util.Arrays.asList("Cr1", "Cr2", "S"));
-        
-        collector.recordVehicleGeneration(v1, 0.0);
-        assertEquals(1, collector.getTotalVehiclesGenerated());
-        
-        collector.recordVehicleArrival(v1, "Cr1", 1.0);
-        
-        collector.recordVehicleExit(v1, 10.0);
-        assertEquals(1, collector.getTotalVehiclesCompleted());
-    }
 }

main/src/test/java/sd/ExitNodeProcessTest.java

@@ -0,0 +1,327 @@
+package sd;
+
+import java.io.IOException;
+import java.net.Socket;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.jupiter.api.AfterEach;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
+import org.junit.jupiter.api.io.TempDir;
+
+import sd.config.SimulationConfig;
+
+/**
+ * Testes unitários para a classe ExitNodeProcess.
+ * 
+ * Esta classe de testes verifica:
+ * - Construção e inicialização do processo
+ * - Criação e aceitação de conexões do servidor socket
+ * - Gestão do ciclo de vida (start/shutdown)
+ * - Processamento concorrente de múltiplas conexões
+ * - Impressão de estatísticas finais
+ * 
+ * Os testes utilizam configurações temporárias e portas dedicadas (19001)
+ * para evitar conflitos com outros testes ou processos em execução.
+ */
+public class ExitNodeProcessTest {
+
+    @TempDir
+    Path tempDir;
+
+    private Path configFile;
+    private ExitNodeProcess exitNodeProcess;
+    private Thread exitNodeThread;
+
+    /**
+     * Configura o ambiente de teste antes de cada teste.
+     * Cria um ficheiro de configuração temporário com as definições necessárias.
+     */
+    @BeforeEach
+    public void setUp() throws IOException {
+        configFile = tempDir.resolve("test-simulation.properties");
+        
+        String configContent = """
+                # Test Exit Node Configuration
+                
+                # Exit Configuration
+                exit.host=localhost
+                exit.port=19001
+                
+                # Dashboard Configuration (will not be running in tests)
+                dashboard.host=localhost
+                dashboard.port=19000
+                
+                # Vehicle Crossing Times
+                vehicle.bike.crossingTime=2.0
+                vehicle.light.crossingTime=3.0
+                vehicle.heavy.crossingTime=5.0
+                
+                # Simulation Duration
+                simulation.duration=60.0
+                """;
+        
+        Files.writeString(configFile, configContent);
+    }
+
+    /**
+     * Limpa os recursos após cada teste.
+     * Garante que o processo e threads são terminados corretamente.
+     */
+    @AfterEach
+    public void tearDown() {
+        if (exitNodeProcess != null) {
+            exitNodeProcess.shutdown();
+        }
+        if (exitNodeThread != null && exitNodeThread.isAlive()) {
+            exitNodeThread.interrupt();
+            try {
+                exitNodeThread.join(1000);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+            }
+        }
+    }
+
+    /**
+     * Testa a construção bem-sucedida do ExitNodeProcess com configuração válida.
+     */
+    @Test
+    public void testConstructor_Success() throws IOException {
+        SimulationConfig config = new SimulationConfig(configFile.toString());
+        exitNodeProcess = new ExitNodeProcess(config);
+        assertNotNull(exitNodeProcess);
+    }
+
+    /**
+     * Testa que uma exceção é lançada quando a configuração é inválida.
+     */
+    @Test
+    public void testConstructor_InvalidConfig() {
+        Exception exception = assertThrows(IOException.class, () -> {
+            new SimulationConfig("non-existent-config.properties");
+        });
+        assertNotNull(exception);
+    }
+
+    /**
+     * Testa a inicialização sem dashboard disponível.
+     * Verifica que o processo continua a funcionar mesmo sem conexão ao dashboard.
+     */
+    @Test
+    public void testInitialize_WithoutDashboard() throws IOException {
+        SimulationConfig config = new SimulationConfig(configFile.toString());
+        exitNodeProcess = new ExitNodeProcess(config);
+        assertDoesNotThrow(() -> exitNodeProcess.initialize());
+    }
+
+    /**
+     * Testa que o servidor socket é criado corretamente na porta configurada.
+     * Verifica que é possível estabelecer uma conexão ao socket do servidor.
+     */
+    @Test
+    @Timeout(value = 3, unit = TimeUnit.SECONDS)
+    public void testStart_ServerSocketCreated() throws IOException {
+        SimulationConfig config = new SimulationConfig(configFile.toString());
+        exitNodeProcess = new ExitNodeProcess(config);
+        exitNodeProcess.initialize();
+        
+        CountDownLatch latch = new CountDownLatch(1);
+        
+        exitNodeThread = new Thread(() -> {
+            try {
+                latch.countDown();
+                exitNodeProcess.start();
+            } catch (IOException e) {
+                // expected when shutdown
+            }
+        });
+        
+        exitNodeThread.start();
+        
+        try {
+            assertTrue(latch.await(2, TimeUnit.SECONDS), "Exit node should start within timeout");
+            Thread.sleep(100);
+            
+            assertDoesNotThrow(() -> {
+                try (Socket testSocket = new Socket("localhost", 19001)) {
+                    assertTrue(testSocket.isConnected());
+                }
+            });
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+    }
+
+    /**
+     * Testa que o servidor aceita conexões de clientes.
+     */
+    @Test
+    @Timeout(value = 3, unit = TimeUnit.SECONDS)
+    public void testStart_AcceptsConnection() throws IOException, InterruptedException {
+        SimulationConfig config = new SimulationConfig(configFile.toString());
+        exitNodeProcess = new ExitNodeProcess(config);
+        exitNodeProcess.initialize();
+        
+        CountDownLatch latch = new CountDownLatch(1);
+        
+        exitNodeThread = new Thread(() -> {
+            try {
+                latch.countDown();
+                exitNodeProcess.start();
+            } catch (IOException e) {
+                // expected
+            }
+        });
+        
+        exitNodeThread.start();
+        
+        assertTrue(latch.await(2, TimeUnit.SECONDS));
+        Thread.sleep(200);
+        
+        assertDoesNotThrow(() -> {
+            try (Socket socket = new Socket("localhost", 19001)) {
+                assertTrue(socket.isConnected());
+            }
+        });
+    }
+
+    /**
+     * Testa múltiplas inicializações e encerramentos do processo.
+     * Verifica que o processo pode ser iniciado e parado múltiplas vezes,
+     * permitindo reutilização da porta.
+     */
+    @Test
+    @Timeout(value = 3, unit = TimeUnit.SECONDS)
+    public void testMultipleStartStop() throws IOException, InterruptedException {
+        SimulationConfig config = new SimulationConfig(configFile.toString());
+        exitNodeProcess = new ExitNodeProcess(config);
+        exitNodeProcess.initialize();
+        
+        CountDownLatch latch = new CountDownLatch(1);
+        
+        exitNodeThread = new Thread(() -> {
+            try {
+                latch.countDown();
+                exitNodeProcess.start();
+            } catch (IOException e) {
+                // expected
+            }
+        });
+        
+        exitNodeThread.start();
+        assertTrue(latch.await(2, TimeUnit.SECONDS));
+        Thread.sleep(100);
+        
+        exitNodeProcess.shutdown();
+        Thread.sleep(100);
+        
+        assertDoesNotThrow(() -> {
+            SimulationConfig config2 = new SimulationConfig(configFile.toString());
+            ExitNodeProcess exitNode2 = new ExitNodeProcess(config2);
+            exitNode2.initialize();
+            exitNode2.shutdown();
+        });
+    }
+
+    /**
+     * Testa que o shutdown fecha corretamente o servidor socket.
+     * Após o shutdown, novas conexões ao socket devem falhar.
+     */
+    @Test
+    @Timeout(value = 3, unit = TimeUnit.SECONDS)
+    public void testShutdown_ClosesServerSocket() throws IOException, InterruptedException {
+        SimulationConfig config = new SimulationConfig(configFile.toString());
+        exitNodeProcess = new ExitNodeProcess(config);
+        exitNodeProcess.initialize();
+        
+        CountDownLatch startLatch = new CountDownLatch(1);
+        
+        exitNodeThread = new Thread(() -> {
+            try {
+                startLatch.countDown();
+                exitNodeProcess.start();
+            } catch (IOException e) {
+                // expected
+            }
+        });
+        
+        exitNodeThread.start();
+        assertTrue(startLatch.await(2, TimeUnit.SECONDS));
+        Thread.sleep(200);
+        
+        exitNodeProcess.shutdown();
+        Thread.sleep(200);
+        
+        assertThrows(IOException.class, () -> {
+            Socket socket = new Socket("localhost", 19001);
+            socket.close();
+        });
+    }
+
+    /**
+     * Testa que as estatísticas finais são impressas corretamente durante o shutdown.
+     * Verifica que o método não lança exceções mesmo sem dados processados.
+     */
+    @Test
+    public void testPrintFinalStatistics() throws IOException {
+        SimulationConfig config = new SimulationConfig(configFile.toString());
+        exitNodeProcess = new ExitNodeProcess(config);
+        exitNodeProcess.initialize();
+        
+        assertDoesNotThrow(() -> exitNodeProcess.shutdown());
+    }
+
+    /**
+     * Testa o processamento de múltiplas conexões concorrentes.
+     * Verifica que o servidor consegue lidar com vários clientes simultaneamente
+     * usando o pool de threads.
+     */
+    @Test
+    @Timeout(value = 3, unit = TimeUnit.SECONDS)
+    public void testMultipleConcurrentConnections() throws IOException, InterruptedException {
+        SimulationConfig config = new SimulationConfig(configFile.toString());
+        exitNodeProcess = new ExitNodeProcess(config);
+        exitNodeProcess.initialize();
+        
+        CountDownLatch latch = new CountDownLatch(1);
+        
+        exitNodeThread = new Thread(() -> {
+            try {
+                latch.countDown();
+                exitNodeProcess.start();
+            } catch (IOException e) {
+                // expected
+            }
+        });
+        
+        exitNodeThread.start();
+        assertTrue(latch.await(2, TimeUnit.SECONDS));
+        Thread.sleep(200);
+        
+        Thread[] clients = new Thread[3];
+        for (int i = 0; i < 3; i++) {
+            clients[i] = new Thread(() -> {
+                try (Socket socket = new Socket("localhost", 19001)) {
+                    assertTrue(socket.isConnected());
+                    Thread.sleep(100);
+                } catch (IOException | InterruptedException e) {
+                    // ignore
+                }
+            });
+            clients[i].start();
+        }
+        
+        for (Thread client : clients) {
+            client.join(1000);
+        }
+    }
+}

main/src/test/java/sd/TrafficLightCoordinationTest.java

@@ -0,0 +1,207 @@
+package sd;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.junit.jupiter.api.AfterEach;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import sd.model.TrafficLight;
+import sd.model.TrafficLightState;
+
+/**
+ * Test class to verify traffic light coordination within an intersection.
+ * Ensures that only ONE traffic light can be GREEN at any given time.
+ */
+public class TrafficLightCoordinationTest {
+
+    private IntersectionProcess intersectionProcess;
+
+    @BeforeEach
+    public void setUp() throws IOException {
+        // Create an intersection with multiple traffic lights
+        intersectionProcess = new IntersectionProcess("Cr2", "src/main/resources/simulation.properties");
+        intersectionProcess.initialize();
+    }
+
+    @AfterEach
+    public void tearDown() throws InterruptedException {
+        if (intersectionProcess != null) {
+            intersectionProcess.shutdown();
+        }
+    }
+
+    /**
+     * Test that verifies mutual exclusion between traffic lights.
+     * Monitors all traffic lights for 10 seconds and ensures that
+     * at most ONE light is GREEN at any point in time.
+     */
+    @Test
+    public void testOnlyOneGreenLightAtATime() throws InterruptedException {
+        System.out.println("\n=== Testing Traffic Light Mutual Exclusion ===");
+
+        // Start the intersection
+        Thread intersectionThread = new Thread(() -> {
+            try {
+                intersectionProcess.start();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        });
+        intersectionThread.start();
+
+        // Monitor traffic lights for violations
+        AtomicInteger maxGreenSimultaneously = new AtomicInteger(0);
+        AtomicInteger violationCount = new AtomicInteger(0);
+        List<String> violations = new ArrayList<>();
+
+        // Monitor for 10 seconds
+        long endTime = System.currentTimeMillis() + 10000;
+
+        while (System.currentTimeMillis() < endTime) {
+            int greenCount = 0;
+            StringBuilder currentState = new StringBuilder("States: ");
+
+            for (TrafficLight light : intersectionProcess.getIntersection().getTrafficLights()) {
+                TrafficLightState state = light.getState();
+                currentState.append(light.getDirection()).append("=").append(state).append(" ");
+
+                if (state == TrafficLightState.GREEN) {
+                    greenCount++;
+                }
+            }
+
+            // Update maximum simultaneous green lights
+            if (greenCount > maxGreenSimultaneously.get()) {
+                maxGreenSimultaneously.set(greenCount);
+            }
+
+            // Check for violations (more than one green)
+            if (greenCount > 1) {
+                violationCount.incrementAndGet();
+                String violation = String.format("[VIOLATION] %d lights GREEN simultaneously: %s",
+                        greenCount, currentState.toString());
+                violations.add(violation);
+                System.err.println(violation);
+            }
+
+            Thread.sleep(50); // Check every 50ms
+        }
+
+        System.out.println("\n=== Test Results ===");
+        System.out.println("Maximum simultaneous GREEN lights: " + maxGreenSimultaneously.get());
+        System.out.println("Total violations detected: " + violationCount.get());
+
+        if (!violations.isEmpty()) {
+            System.err.println("\nViolation details:");
+            violations.forEach(System.err::println);
+        }
+
+        // Assert that we never had more than one green light
+        assertEquals(0, violationCount.get(),
+                "Traffic light coordination violated! Multiple lights were GREEN simultaneously.");
+        assertTrue(maxGreenSimultaneously.get() <= 1,
+                "At most ONE light should be GREEN at any time. Found: " + maxGreenSimultaneously.get());
+
+        System.out.println("\nTraffic light coordination working correctly!");
+    }
+
+    /**
+     * Test that verifies all traffic lights get a chance to be GREEN.
+     * Ensures fairness in the coordination mechanism.
+     */
+    @Test
+    public void testAllLightsGetGreenTime() throws InterruptedException {
+        System.out.println("\n=== Testing Traffic Light Fairness ===");
+
+        // Start the intersection
+        Thread intersectionThread = new Thread(() -> {
+            try {
+                intersectionProcess.start();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        });
+        intersectionThread.start();
+
+        // Track which lights have been green
+        List<TrafficLight> lights = intersectionProcess.getIntersection().getTrafficLights();
+        boolean[] hasBeenGreen = new boolean[lights.size()];
+
+        // Monitor for 10 seconds (enough time for all lights to cycle: 18+18+12 = 48s)
+        long endTime = System.currentTimeMillis() + 10000;
+
+        while (System.currentTimeMillis() < endTime) {
+            for (int i = 0; i < lights.size(); i++) {
+                if (lights.get(i).getState() == TrafficLightState.GREEN) {
+                    hasBeenGreen[i] = true;
+                    System.out.println("✓ " + lights.get(i).getDirection() + " has been GREEN");
+                }
+            }
+            Thread.sleep(100);
+        }
+
+        // Check if all lights got green time
+        int greenCount = 0;
+        System.out.println("\n=== Fairness Results ===");
+        for (int i = 0; i < lights.size(); i++) {
+            String status = hasBeenGreen[i] ? "✓ YES" : "✗ NO";
+            System.out.println(lights.get(i).getDirection() + " got GREEN time: " + status);
+            if (hasBeenGreen[i])
+                greenCount++;
+        }
+
+        assertTrue(greenCount > 0, "At least one light should have been GREEN during the test");
+        System.out.println("\n" + greenCount + "/" + lights.size() + " lights were GREEN during test period");
+    }
+
+    /**
+     * Test that verifies the state transitions are consistent.
+     */
+    @Test
+    public void testStateTransitionsAreConsistent() throws InterruptedException {
+        System.out.println("\n=== Testing State Transition Consistency ===");
+
+        Thread intersectionThread = new Thread(() -> {
+            try {
+                intersectionProcess.start();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        });
+        intersectionThread.start();
+
+        List<TrafficLight> lights = intersectionProcess.getIntersection().getTrafficLights();
+        TrafficLightState[] previousStates = new TrafficLightState[lights.size()];
+
+        // Initialize previous states
+        for (int i = 0; i < lights.size(); i++) {
+            previousStates[i] = lights.get(i).getState();
+        }
+
+        int transitionCount = 0;
+        long endTime = System.currentTimeMillis() + 8000;
+
+        while (System.currentTimeMillis() < endTime) {
+            for (int i = 0; i < lights.size(); i++) {
+                TrafficLightState currentState = lights.get(i).getState();
+
+                if (currentState != previousStates[i]) {
+                    transitionCount++;
+                    System.out.println(lights.get(i).getDirection() + " transitioned: " +
+                            previousStates[i] + " → " + currentState);
+                    previousStates[i] = currentState;
+                }
+            }
+            Thread.sleep(100);
+        }
+
+        System.out.println("\nTotal state transitions observed: " + transitionCount);
+        assertTrue(transitionCount > 0, "There should be state transitions during the test period");
+    }
+}

main/src/test/java/sd/coordinator/CoordinatorIntegrationTest.java

@@ -0,0 +1,302 @@
+package sd.coordinator;
+
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ConcurrentLinkedQueue;
+
+import org.junit.jupiter.api.AfterEach;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
+
+import sd.model.Message;
+import sd.model.MessageType;
+import sd.model.Vehicle;
+import sd.serialization.MessageSerializer;
+import sd.serialization.SerializerFactory;
+
+/**
+ * Integration tests for the Coordinator-side networking.
+ *
+ * What we’re checking here:
+ *  1. A SocketClient can actually connect to something listening
+ *  2. Messages go over the wire and can be deserialized
+ *  3. Vehicle payloads survive the trip
+ *  4. Shutdown messages can be broadcast to multiple intersections
+ *
+ * We do this by spinning up a tiny mock intersection server in-process.
+ */
+class CoordinatorIntegrationTest {
+    
+    private List<MockIntersectionServer> mockServers;
+    private static final int BASE_PORT = 9001; // keep clear of real ports
+    
+    @BeforeEach
+    void setUp() {
+        mockServers = new ArrayList<>();
+    }
+    
+    @AfterEach
+    void tearDown() {
+        // Stop all mock servers
+        for (MockIntersectionServer server : mockServers) {
+            server.stop();
+        }
+        mockServers.clear();
+    }
+    
+    /**
+     * Can the client open a TCP connection to our fake intersection?
+     */
+    @Test
+    @Timeout(5)
+    void testSocketClientConnection() throws IOException, InterruptedException {
+        MockIntersectionServer server = new MockIntersectionServer("Cr1", BASE_PORT);
+        server.start();
+        mockServers.add(server);
+        
+        // tiny pause to let the server bind
+        Thread.sleep(100);
+        
+        SocketClient client = new SocketClient("Cr1", "localhost", BASE_PORT);
+        client.connect();
+        
+        assertTrue(client.isConnected(), "Client should be connected to mock intersection");
+        
+        client.close();
+    }
+    
+    /**
+     * End-to-end: send a message, make sure the server actually receives it.
+     */
+    @Test
+    @Timeout(5)
+    void testMessageTransmission() throws Exception {
+        MockIntersectionServer server = new MockIntersectionServer("Cr1", BASE_PORT);
+        server.start();
+        mockServers.add(server);
+        
+        Thread.sleep(100);
+        
+        SocketClient client = new SocketClient("Cr1", "localhost", BASE_PORT);
+        client.connect();
+        
+        Message testMessage = new Message(
+            MessageType.VEHICLE_SPAWN,
+            "COORDINATOR",
+            "Cr1",
+            "Test payload"
+        );
+        
+        client.send(testMessage);
+        
+        // give the server a moment to read and deserialize
+        Thread.sleep(200);
+        
+        assertFalse(
+            server.getReceivedMessages().isEmpty(),
+            "Mock server should have received at least one message"
+        );
+        
+        Message receivedMsg = server.getReceivedMessages().poll();
+        assertNotNull(receivedMsg, "Server should have actually received a message");
+        assertEquals(MessageType.VEHICLE_SPAWN, receivedMsg.getType(), "Message type should match what we sent");
+        assertEquals("COORDINATOR", receivedMsg.getSenderId(), "Sender ID should be preserved");
+        assertEquals("Cr1", receivedMsg.getDestinationId(), "Destination ID should be preserved");
+        
+        client.close();
+    }
+    
+    /**
+     * Make sure vehicle payloads survive the trip and arrive non-null.
+     */
+    @Test
+    @Timeout(5)
+    void testVehicleSpawnMessage() throws Exception {
+        MockIntersectionServer server = new MockIntersectionServer("Cr1", BASE_PORT);
+        server.start();
+        mockServers.add(server);
+        
+        Thread.sleep(100);
+        
+        SocketClient client = new SocketClient("Cr1", "localhost", BASE_PORT);
+        client.connect();
+        
+        // fake a vehicle like the coordinator would send
+        List<String> route = List.of("Cr1", "Cr4", "Cr5", "S");
+        Vehicle vehicle = new Vehicle("V1", sd.model.VehicleType.LIGHT, 0.0, route);
+        
+        Message spawnMessage = new Message(
+            MessageType.VEHICLE_SPAWN,
+            "COORDINATOR",
+            "Cr1",
+            vehicle
+        );
+        
+        client.send(spawnMessage);
+        
+        Thread.sleep(200);
+        
+        Message receivedMsg = server.getReceivedMessages().poll();
+        assertNotNull(receivedMsg, "Mock server should receive the spawn message");
+        assertEquals(MessageType.VEHICLE_SPAWN, receivedMsg.getType(), "Message should be of type VEHICLE_SPAWN");
+        assertNotNull(receivedMsg.getPayload(), "Payload should not be null (vehicle must arrive)");
+        
+        client.close();
+    }
+    
+    /**
+     * Broadcast shutdown to multiple mock intersections and see if all of them get it.
+     */
+    @Test
+    @Timeout(5)
+    void testShutdownMessageBroadcast() throws Exception {
+        // Start a couple of fake intersections
+        for (int i = 1; i <= 3; i++) {
+            MockIntersectionServer server = new MockIntersectionServer("Cr" + i, BASE_PORT + i - 1);
+            server.start();
+            mockServers.add(server);
+        }
+        
+        Thread.sleep(200);
+        
+        // Connect to all of them
+        List<SocketClient> clients = new ArrayList<>();
+        for (int i = 1; i <= 3; i++) {
+            SocketClient client = new SocketClient("Cr" + i, "localhost", BASE_PORT + i - 1);
+            client.connect();
+            clients.add(client);
+        }
+        
+        Message shutdownMessage = new Message(
+            MessageType.SHUTDOWN,
+            "COORDINATOR",
+            "ALL",
+            "Simulation complete"
+        );
+        
+        for (SocketClient client : clients) {
+            client.send(shutdownMessage);
+        }
+        
+        Thread.sleep(200);
+        
+        for (MockIntersectionServer server : mockServers) {
+            assertFalse(
+                server.getReceivedMessages().isEmpty(),
+                "Server " + server.getIntersectionId() + " should have received the shutdown message"
+            );
+            
+            Message msg = server.getReceivedMessages().poll();
+            assertEquals(MessageType.SHUTDOWN, msg.getType(), "Server should receive a SHUTDOWN message");
+        }
+        
+        for (SocketClient client : clients) {
+            client.close();
+        }
+    }
+    
+    /**
+     * Tiny TCP server that pretends to be an intersection.
+     * It:
+     *  - listens on a port
+     *  - accepts connections
+     *  - reads length-prefixed messages
+     *  - deserializes them and stores them for the test to inspect
+     */
+    private static class MockIntersectionServer {
+        private final String intersectionId;
+        private final int port;
+        private ServerSocket serverSocket;
+        private Thread serverThread;
+        private volatile boolean running;
+        private final ConcurrentLinkedQueue<Message> receivedMessages;
+        private final MessageSerializer serializer;
+        
+        public MockIntersectionServer(String intersectionId, int port) {
+            this.intersectionId = intersectionId;
+            this.port = port;
+            this.receivedMessages = new ConcurrentLinkedQueue<>();
+            this.serializer = SerializerFactory.createDefault();
+            this.running = false;
+        }
+        
+        public void start() throws IOException {
+            serverSocket = new ServerSocket(port);
+            running = true;
+            
+            System.out.printf("Mock %s listening on port %d%n", intersectionId, port);
+            
+            serverThread = new Thread(() -> {
+                try {
+                    while (running) {
+                        Socket clientSocket = serverSocket.accept();
+                        handleClient(clientSocket);
+                    }
+                } catch (IOException e) {
+                    if (running) {
+                        System.err.println("Mock " + intersectionId + " server error: " + e.getMessage());
+                    }
+                }
+            }, "mock-" + intersectionId + "-listener");
+            
+            serverThread.start();
+        }
+        
+        private void handleClient(Socket clientSocket) {
+            new Thread(() -> {
+                try (DataInputStream input = new DataInputStream(clientSocket.getInputStream())) {
+                    while (running) {
+                        // Read length prefix (4 bytes, big-endian)
+                        int length = input.readInt();
+                        byte[] data = new byte[length];
+                        input.readFully(data);
+                        
+                        Message message = serializer.deserialize(data, Message.class);
+                        receivedMessages.offer(message);
+                        
+                        System.out.println("Mock " + intersectionId + " received: " + message.getType());
+                    }
+                } catch (IOException e) {
+                    if (running) {
+                        System.err.println("Mock " + intersectionId + " client handler error: " + e.getMessage());
+                    }
+                } catch (Exception e) {
+                    System.err.println("Mock " + intersectionId + " deserialization error: " + e.getMessage());
+                }
+            }, "mock-" + intersectionId + "-client").start();
+        }
+        
+        public void stop() {
+            running = false;
+            try {
+                if (serverSocket != null && !serverSocket.isClosed()) {
+                    serverSocket.close();
+                }
+                if (serverThread != null) {
+                    serverThread.interrupt();
+                    serverThread.join(1000);
+                }
+                System.out.printf("Mock %s stopped%n", intersectionId);
+            } catch (IOException | InterruptedException e) {
+                System.err.println("Error stopping mock server " + intersectionId + ": " + e.getMessage());
+            }
+        }
+        
+        public ConcurrentLinkedQueue<Message> getReceivedMessages() {
+            return receivedMessages;
+        }
+        
+        public String getIntersectionId() {
+            return intersectionId;
+        }
+    }
+}

main/src/test/java/sd/coordinator/CoordinatorProcessTest.java

@@ -0,0 +1,194 @@
+package sd.coordinator;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.jupiter.api.AfterEach;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import sd.config.SimulationConfig;
+import sd.model.Vehicle;
+import sd.util.VehicleGenerator;
+
+/**
+ * Tests for the Coordinator/vehicle-generation layer.
+ *
+ * What we’re checking here:
+ *  1. Coordinator can be created with a valid config
+ *  2. Vehicle arrival times are monotonic and sane
+ *  3. Vehicle IDs are created in the format we expect (V1, V2, ...)
+ *  4. Generated vehicles have proper routes (start at CrX, end at S)
+ *  5. Config actually has intersection info
+ *  6. Duration in config is not something crazy
+ */
+class CoordinatorProcessTest {
+    
+    private SimulationConfig config;
+    private static final String TEST_CONFIG = "src/main/resources/simulation.properties";
+    
+    @BeforeEach
+    void setUp() throws IOException {
+        config = new SimulationConfig(TEST_CONFIG);
+    }
+    
+    @AfterEach
+    void tearDown() {
+        config = null;
+    }
+    
+    /**
+     * Basic smoke test: can we build a coordinator with this config?
+     */
+    @Test
+    void testCoordinatorInitialization() {
+        CoordinatorProcess coordinator = new CoordinatorProcess(config);
+        assertNotNull(coordinator, "Coordinator should be created with a valid config");
+    }
+    
+    /**
+     * Make sure the VehicleGenerator is giving us increasing arrival times,
+     * i.e. time doesn’t go backwards and intervals look reasonable.
+     */
+    @Test
+    void testVehicleGenerationTiming() {
+        VehicleGenerator generator = new VehicleGenerator(config);
+        
+        double currentTime = 0.0;
+        List<Double> arrivalTimes = new ArrayList<>();
+        
+        // generate a small batch to inspect
+        for (int i = 0; i < 10; i++) {
+            double nextArrival = generator.getNextArrivalTime(currentTime);
+            arrivalTimes.add(nextArrival);
+            currentTime = nextArrival;
+        }
+        
+        // times should strictly increase
+        for (int i = 1; i < arrivalTimes.size(); i++) {
+            assertTrue(
+                arrivalTimes.get(i) > arrivalTimes.get(i - 1),
+                "Arrival times must increase — got " + arrivalTimes.get(i - 1) + " then " + arrivalTimes.get(i)
+            );
+        }
+        
+        // and they shouldn't be nonsense
+        for (double time : arrivalTimes) {
+            assertTrue(time >= 0, "Arrival time should not be negative (got " + time + ")");
+            assertTrue(time < 1000, "Arrival time looks suspiciously large: " + time);
+        }
+    }
+    
+    /**
+     * We generate V1..V5 manually and make sure the IDs are exactly those.
+     */
+    @Test
+    void testVehicleIdGeneration() {
+        VehicleGenerator generator = new VehicleGenerator(config);
+        
+        List<Vehicle> vehicles = new ArrayList<>();
+        for (int i = 1; i <= 5; i++) {
+            Vehicle v = generator.generateVehicle("V" + i, 0.0);
+            vehicles.add(v);
+            assertEquals("V" + i, v.getId(), "Vehicle ID should be 'V" + i + "' but got " + v.getId());
+        }
+        
+        // just to be safe, no duplicates in that small set
+        long distinctCount = vehicles.stream().map(Vehicle::getId).distinct().count();
+        assertEquals(5, distinctCount, "Vehicle IDs in this batch should all be unique");
+    }
+    
+    /**
+     * A generated vehicle should:
+     *  - have a non-empty route
+     *  - start in a known intersection (Cr1..Cr5)
+     *  - end in S (exit)
+     */
+    @Test
+    void testVehicleRouteValidity() {
+        VehicleGenerator generator = new VehicleGenerator(config);
+        
+        for (int i = 0; i < 20; i++) {
+            Vehicle vehicle = generator.generateVehicle("V" + i, 0.0);
+            
+            assertNotNull(vehicle.getRoute(), "Vehicle route should not be null");
+            assertFalse(vehicle.getRoute().isEmpty(), "Vehicle route should not be empty");
+            
+            String firstHop = vehicle.getRoute().get(0);
+            assertTrue(
+                firstHop.matches("Cr[1-5]"),
+                "First hop should be a valid intersection (Cr1..Cr5), got: " + firstHop
+            );
+            
+            String lastHop = vehicle.getRoute().get(vehicle.getRoute().size() - 1);
+            assertEquals("S", lastHop, "Last hop should be exit 'S' but got: " + lastHop);
+        }
+    }
+    
+    /**
+     * Whatever is in simulation.properties should give us a sane duration.
+     */
+    @Test
+    void testSimulationDuration() {
+        double duration = config.getSimulationDuration();
+        assertTrue(duration > 0, "Simulation duration must be positive");
+        assertTrue(duration >= 1.0, "Simulation should run at least 1 second (got " + duration + ")");
+        assertTrue(duration <= 86400.0, "Simulation should not run more than a day (got " + duration + ")");
+    }
+    
+    /**
+     * Check that the 5 intersections defined in the architecture
+     * actually exist in the config and have valid network data.
+     */
+    @Test
+    void testIntersectionConfiguration() {
+        String[] intersectionIds = {"Cr1", "Cr2", "Cr3", "Cr4", "Cr5"};
+        
+        for (String id : intersectionIds) {
+            String host = config.getIntersectionHost(id);
+            int port = config.getIntersectionPort(id);
+            
+            assertNotNull(host, "Host should not be null for " + id);
+            assertFalse(host.isEmpty(), "Host should not be empty for " + id);
+            assertTrue(port > 0, "Port should be > 0 for " + id + " (got " + port + ")");
+            assertTrue(port < 65536, "Port should be a valid TCP port for " + id + " (got " + port + ")");
+        }
+    }
+    
+    /**
+     * Quick sanity check: over a bunch of generated vehicles,
+     * we should eventually see the different vehicle types appear.
+     *
+     * Note: this is probabilistic, so we're not being super strict.
+     */
+    @Test
+    void testVehicleTypeDistribution() {
+        VehicleGenerator generator = new VehicleGenerator(config);
+        
+        boolean hasBike = false;
+        boolean hasLight = false;
+        boolean hasHeavy = false;
+        
+        // 50 is enough for a "we're probably fine" test
+        for (int i = 0; i < 50; i++) {
+            Vehicle vehicle = generator.generateVehicle("V" + i, 0.0);
+            
+            switch (vehicle.getType()) {
+                case BIKE -> hasBike = true;
+                case LIGHT -> hasLight = true;
+                case HEAVY -> hasHeavy = true;
+            }
+        }
+        
+        // at least one of them should have shown up — if not, RNG is cursed
+        assertTrue(
+            hasBike || hasLight || hasHeavy,
+            "Expected to see at least one vehicle type after 50 generations"
+        );
+    }
+}

main/src/test/java/sd/dashboard/DashboardTest.java

@@ -0,0 +1,164 @@
+package sd.dashboard;
+
+import org.junit.jupiter.api.AfterEach;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import sd.config.SimulationConfig;
+import sd.model.VehicleType;
+
+/**
+ * Unit tests for Dashboard Server components.
+ */
+class DashboardTest {
+    
+    private DashboardStatistics statistics;
+    
+    @BeforeEach
+    void setUp() {
+        statistics = new DashboardStatistics();
+    }
+    
+    @AfterEach
+    void tearDown() {
+        statistics = null;
+    }
+    
+    @Test
+    void testInitialStatistics() {
+        assertEquals(0, statistics.getTotalVehiclesGenerated(), 
+            "Initial vehicles generated should be 0");
+        assertEquals(0, statistics.getTotalVehiclesCompleted(), 
+            "Initial vehicles completed should be 0");
+        assertEquals(0.0, statistics.getAverageSystemTime(), 
+            "Initial average system time should be 0.0");
+        assertEquals(0.0, statistics.getAverageWaitingTime(), 
+            "Initial average waiting time should be 0.0");
+    }
+    
+    @Test
+    void testVehicleCounters() {
+        statistics.incrementVehiclesGenerated();
+        assertEquals(1, statistics.getTotalVehiclesGenerated());
+        
+        statistics.updateVehiclesGenerated(10);
+        assertEquals(10, statistics.getTotalVehiclesGenerated());
+        
+        statistics.incrementVehiclesCompleted();
+        assertEquals(1, statistics.getTotalVehiclesCompleted());
+    }
+    
+    @Test
+    void testAverageCalculations() {
+        // Add 3 completed vehicles with known times
+        statistics.updateVehiclesCompleted(3);
+        statistics.addSystemTime(3000); // 3000ms total
+        statistics.addWaitingTime(1500); // 1500ms total
+        
+        assertEquals(1000.0, statistics.getAverageSystemTime(), 0.01,
+            "Average system time should be 1000ms");
+        assertEquals(500.0, statistics.getAverageWaitingTime(), 0.01,
+            "Average waiting time should be 500ms");
+    }
+    
+    @Test
+    void testVehicleTypeStatistics() {
+        statistics.incrementVehicleType(VehicleType.LIGHT);
+        statistics.incrementVehicleType(VehicleType.LIGHT);
+        statistics.incrementVehicleType(VehicleType.HEAVY);
+        
+        assertEquals(2, statistics.getVehicleTypeCount(VehicleType.LIGHT));
+        assertEquals(1, statistics.getVehicleTypeCount(VehicleType.HEAVY));
+        assertEquals(0, statistics.getVehicleTypeCount(VehicleType.BIKE));
+    }
+    
+    @Test
+    void testIntersectionStatistics() {
+        statistics.updateIntersectionStats("Cr1", 10, 8, 2);
+        
+        DashboardStatistics.IntersectionStats stats = 
+            statistics.getIntersectionStats("Cr1");
+        
+        assertNotNull(stats, "Intersection stats should not be null");
+        assertEquals("Cr1", stats.getIntersectionId());
+        assertEquals(10, stats.getTotalArrivals());
+        assertEquals(8, stats.getTotalDepartures());
+        assertEquals(2, stats.getCurrentQueueSize());
+    }
+    
+    @Test
+    void testMultipleIntersections() {
+        statistics.updateIntersectionStats("Cr1", 10, 8, 2);
+        statistics.updateIntersectionStats("Cr2", 15, 12, 3);
+        statistics.updateIntersectionStats("Cr3", 5, 5, 0);
+        
+        assertEquals(3, statistics.getAllIntersectionStats().size(),
+            "Should have 3 intersections");
+    }
+    
+    @Test
+    void testStatsUpdatePayload() {
+        StatsUpdatePayload payload = new StatsUpdatePayload()
+            .setTotalVehiclesGenerated(50)
+            .setTotalVehiclesCompleted(20)
+            .setIntersectionArrivals(30)
+            .setIntersectionDepartures(25)
+            .setIntersectionQueueSize(5);
+        
+        assertEquals(50, payload.getTotalVehiclesGenerated());
+        assertEquals(20, payload.getTotalVehiclesCompleted());
+        assertEquals(30, payload.getIntersectionArrivals());
+        assertEquals(25, payload.getIntersectionDepartures());
+        assertEquals(5, payload.getIntersectionQueueSize());
+    }
+    
+    @Test
+    void testStatsMessage() {
+        StatsUpdatePayload payload = new StatsUpdatePayload()
+            .setIntersectionArrivals(10);
+        
+        StatsMessage message = new StatsMessage("Cr1", payload);
+        
+        assertEquals("Cr1", message.getSourceNode());
+        assertEquals("DashboardServer", message.getDestinationNode());
+        assertEquals(sd.model.MessageType.STATS_UPDATE, message.getType());
+        assertNotNull(message.getPayload());
+    }
+    
+    @Test
+    void testThreadSafety() throws InterruptedException {
+        // Test concurrent updates
+        Thread t1 = new Thread(() -> {
+            for (int i = 0; i < 100; i++) {
+                statistics.incrementVehiclesGenerated();
+            }
+        });
+        
+        Thread t2 = new Thread(() -> {
+            for (int i = 0; i < 100; i++) {
+                statistics.incrementVehiclesGenerated();
+            }
+        });
+        
+        t1.start();
+        t2.start();
+        t1.join();
+        t2.join();
+        
+        assertEquals(200, statistics.getTotalVehiclesGenerated(),
+            "Concurrent increments should total 200");
+    }
+    
+    @Test
+    void testDashboardServerCreation() throws Exception {
+        SimulationConfig config = new SimulationConfig("simulation.properties");
+        DashboardServer server = new DashboardServer(config);
+        
+        assertNotNull(server, "Server should be created successfully");
+        assertNotNull(server.getStatistics(), "Statistics should be initialized");
+        assertFalse(server.isRunning(), "Server should not be running initially");
+    }
+}

main/start.sh

@@ -0,0 +1,60 @@
+#!/bin/bash
+# Distributed Traffic Simulation Startup Script
+
+# kill java
+echo "-> Cleaning up existing processes..."
+pkill -9 java 2>/dev/null
+sleep 2
+
+# build
+echo "-> Building project..."
+cd "$(dirname "$0")"
+mvn package -DskipTests -q
+if [ $? -ne 0 ]; then
+    echo "XXX Build failed! XXX"
+    exit 1
+fi
+echo "-> Build complete"
+echo ""
+
+# start gui
+echo "-> Starting JavaFX Dashboard..."
+mvn javafx:run &
+DASHBOARD_PID=$!
+sleep 3
+
+# acho que é assim idk
+echo "-> Starting 5 Intersection processes..."
+for id in Cr1 Cr2 Cr3 Cr4 Cr5; do
+    java -cp target/classes:target/main-1.0-SNAPSHOT.jar sd.IntersectionProcess $id > /tmp/$(echo $id | tr '[:upper:]' '[:lower:]').log 2>&1 &
+    echo "[SUCCESS] Started $id"
+done
+sleep 2
+
+# exit
+echo "-> Starting Exit Node..."
+java -cp target/classes:target/main-1.0-SNAPSHOT.jar sd.ExitNodeProcess > /tmp/exit.log 2>&1 &
+sleep 1
+
+# coordinator
+echo "-> Starting Coordinator..."
+java -cp target/classes:target/main-1.0-SNAPSHOT.jar sd.coordinator.CoordinatorProcess > /tmp/coordinator.log 2>&1 &
+sleep 1
+
+echo ""
+echo "-> All processes started!"
+echo ""
+echo "-> System Status:"
+ps aux | grep "java.*sd\." | grep -v grep | wc -l | xargs -I {} echo "   {} Java processes running"
+echo ""
+echo "   IMPORTANT: Keep the JavaFX Dashboard window OPEN for 60+ seconds"
+echo "   to see live updates! The simulation runs for 60 seconds."
+echo ""
+echo "-> Logs available at:"
+echo "   Dashboard: Check JavaFX window (live updates)"
+echo "   Intersections: /tmp/cr*.log"
+echo "   Exit Node: /tmp/exit.log"
+echo "   Coordinator: /tmp/coordinator.log"
+echo ""
+echo "-> To stop all processes: pkill -9 java"
+echo ""