refactor: Implement SimulationProcessFactory pattern

Phase 2 complete - Factory abstraction created:
- Add SimulationProcessFactory interface (context package)
- Add DefaultSimulationProcessFactory implementation (sim package)
- Update DefaultContext to use factory instead of direct instantiation
- Remove direct imports of Generator and InOutWorker from DefaultContext
- Update XMLContextFactory to inject factory from Koin
- Configure Koin DI to provide factory singleton
- Change setMainProcess to accept LoopProcess (more general)

Benefits:
- DefaultContext no longer directly depends on concrete simulation classes
- Follows Dependency Inversion Principle
- Easier to test contexts with mock factories
- Prepared for future jDisco→DSOL/Kalasim migration

Co-authored-by: bedaHovorka <5263405+bedaHovorka@users.noreply.github.com>

Author: Copilot

src/main/kotlin/cz/vutbr/fit/interlockSim/context/DefaultContext.kt

@@ -23,10 +23,8 @@ import cz.vutbr.fit.interlockSim.objects.tracks.SimpleTrackBlock
 import cz.vutbr.fit.interlockSim.objects.tracks.Track
 import cz.vutbr.fit.interlockSim.objects.tracks.TrackBlock
 import cz.vutbr.fit.interlockSim.objects.tracks.TrackSection
-import cz.vutbr.fit.interlockSim.sim.Generator
 import cz.vutbr.fit.interlockSim.sim.InOutWorker
 import cz.vutbr.fit.interlockSim.sim.LoopProcess
-import cz.vutbr.fit.interlockSim.sim.ShuntingLoop
 import cz.vutbr.fit.interlockSim.exceptions.SimulationException
 import cz.vutbr.fit.interlockSim.exceptions.requireSimulation
 import cz.vutbr.fit.interlockSim.exceptions.requireSimulationNotNull
@@ -89,7 +87,13 @@ import java.util.TreeMap
  * @see SimulationContext
  * @see javax.annotation.concurrent.NotThreadSafe
  */
-abstract class DefaultContext :
+abstract class DefaultContext(
+	/**
+	 * Factory for creating simulation processes.
+	 * Decouples context from concrete simulation class implementations.
+	 */
+	private val processFactory: SimulationProcessFactory
+) :
 	EditingContext,
 	SimulationContext {
 	/**
@@ -173,7 +177,11 @@ abstract class DefaultContext :
 		const val SQRT2: Double = 1.4142135623730951
 	}
 
-	protected constructor(cols: Int, rows: Int) {
+	protected constructor(
+		cols: Int,
+		rows: Int,
+		processFactory: SimulationProcessFactory
+	) : this(processFactory) {
 		this.railwayNetGrid = DefaultRailWayNetGrid(cols, rows)
 		logger.debug { "Initialized railway network grid: ${cols}x$rows cells" }
 	}
@@ -784,15 +792,19 @@ abstract class DefaultContext :
 			}
 			throw EmptyContextException()
 		}
-		if (mainProcess == null) mainProcess = Generator(this)
+		// Use factory to create main process if not already set
+		if (mainProcess == null) {
+			mainProcess = processFactory.createMainProcess(this)
+		}
 
 		logger.info {
 			"Starting simulation: ${inouts.size} InOut points, ${getGraph().size()} track blocks, " +
 				"main process=${mainProcess!!.javaClass.simpleName}"
 		}
 
+		// Use factory to create worker for each InOut
 		for (i in inouts) {
-			workers[i] = InOutWorker(this, i)
+			workers[i] = processFactory.createInOutWorker(this, i)
 		}
 
 		try {
@@ -802,6 +814,10 @@ abstract class DefaultContext :
 			throw SimulationException(e)
 		}
 	}
+			logger.error(e) { "Failed to activate main simulation process" }
+			throw SimulationException(e)
+		}
+	}
 
 	/**
 	 * Stop the simulation
@@ -959,8 +975,10 @@ abstract class DefaultContext :
 	/**
 	 * Set the main process for the simulation
 	 * (for examples where the main process is not a generator)
+	 *
+	 * @param process The custom main process (e.g., ShuntingLoop)
 	 */
-	fun setMainProcess(loop: ShuntingLoop) {
-		mainProcess = loop
+	fun setMainProcess(process: LoopProcess) {
+		mainProcess = process
 	}
 }

src/main/kotlin/cz/vutbr/fit/interlockSim/context/SimulationProcessFactory.kt

@@ -0,0 +1,68 @@
+/* Brno University of Technology
+ * Faculty of Information Technology
+ *
+ * BSc Thesis  2006/2007
+ *
+ * Railway Interlocking Simulator
+ *
+ * Bedrich Hovorka
+ */
+package cz.vutbr.fit.interlockSim.context
+
+import cz.vutbr.fit.interlockSim.objects.cells.InOut
+import cz.vutbr.fit.interlockSim.sim.InOutWorker
+import cz.vutbr.fit.interlockSim.sim.LoopProcess
+
+/**
+ * Factory interface for creating simulation processes.
+ *
+ * Decouples context from concrete simulation class implementations by using
+ * the Factory pattern. This allows:
+ * - Different simulation engines to be plugged in
+ * - Testing without concrete simulation dependencies
+ * - Future migration from jDisco to DSOL/Kalasim
+ *
+ * ## Design Decision
+ *
+ * This interface is placed in the context package (not sim/) because:
+ * - It's an abstraction used by contexts
+ * - Only the implementation needs knowledge of concrete sim/ classes
+ * - Follows Dependency Inversion Principle
+ *
+ * ## Future Migration
+ *
+ * When migrating from jDisco to DSOL/Kalasim:
+ * 1. Create new factory implementation with DSOL/Kalasim classes
+ * 2. Update DI configuration to use new factory
+ * 3. All context code continues to work unchanged
+ *
+ * @see DefaultSimulationContext
+ * @see SimulationContext
+ */
+interface SimulationProcessFactory {
+	/**
+	 * Create the main simulation process.
+	 *
+	 * The main process is responsible for generating trains and managing
+	 * the overall simulation flow. Default implementation creates a Generator.
+	 *
+	 * @param context The simulation context
+	 * @return Main process for the simulation (e.g., Generator)
+	 */
+	fun createMainProcess(context: SimulationContext): LoopProcess
+
+	/**
+	 * Create worker process for an InOut point.
+	 *
+	 * Each InOut (entry/exit point) needs a worker process to handle
+	 * trains entering and leaving the railway network.
+	 *
+	 * @param context The simulation context
+	 * @param inOut The InOut point to create worker for
+	 * @return Worker process for the InOut
+	 */
+	fun createInOutWorker(
+		context: SimulationContext,
+		inOut: InOut
+	): InOutWorker
+}

src/main/kotlin/cz/vutbr/fit/interlockSim/di/InterlockSimModule.kt

@@ -14,7 +14,9 @@ import cz.vutbr.fit.interlockSim.MyResourceBundle
 import cz.vutbr.fit.interlockSim.ExampleRegistry
 import cz.vutbr.fit.interlockSim.context.EditingContextFactory
 import cz.vutbr.fit.interlockSim.context.SimulationContextFactory
+import cz.vutbr.fit.interlockSim.context.SimulationProcessFactory
 import cz.vutbr.fit.interlockSim.gui.Frame
+import cz.vutbr.fit.interlockSim.sim.DefaultSimulationProcessFactory
 import cz.vutbr.fit.interlockSim.xml.XMLContextFactory
 import org.koin.core.module.Module
 import org.koin.dsl.module
@@ -76,11 +78,20 @@ val editingModule: Module = module {
 /**
  * Simulation module
  *
+ * Provides simulation-related dependencies:
+ * - SimulationProcessFactory for creating simulation processes
+ * - SimulationContextFactory for creating simulation contexts
+ * - ExampleRegistry for managing simulation examples
  *
  * @see SimulationContextFactory
+ * @see SimulationProcessFactory
  * @see XMLContextFactory
  */
 val simulationModule: Module = module {
+	// Factory for creating simulation processes (Generator, InOutWorker)
+	// Singleton as factory is stateless
+	single<SimulationProcessFactory> { DefaultSimulationProcessFactory() }
+
 	// XMLContextFactory is now defined in xmlModule as a singleton, but not in future
 	// Bind factory interfaces to the singleton XMLContextFactory instance
 	single<SimulationContextFactory> { get<XMLContextFactory>() }

src/main/kotlin/cz/vutbr/fit/interlockSim/sim/DefaultSimulationProcessFactory.kt

@@ -0,0 +1,83 @@
+/* Brno University of Technology
+ * Faculty of Information Technology
+ *
+ * BSc Thesis  2006/2007
+ *
+ * Railway Interlocking Simulator
+ *
+ * Bedrich Hovorka
+ */
+package cz.vutbr.fit.interlockSim.sim
+
+import cz.vutbr.fit.interlockSim.context.SimulationContext
+import cz.vutbr.fit.interlockSim.context.SimulationProcessFactory
+import cz.vutbr.fit.interlockSim.objects.cells.InOut
+import io.github.oshai.kotlinlogging.KotlinLogging
+
+/**
+ * Default implementation of SimulationProcessFactory using jDisco-based classes.
+ *
+ * This factory creates concrete simulation process instances:
+ * - Generator: Main process for generating trains
+ * - InOutWorker: Worker processes for InOut points
+ *
+ * ## Implementation Note
+ *
+ * This class is intentionally placed in the sim/ package because:
+ * - It has direct dependencies on concrete simulation classes
+ * - It's the only place that needs to know about Generator and InOutWorker
+ * - Keeps simulation implementation details in sim/ package
+ *
+ * ## Future Migration
+ *
+ * When migrating from jDisco to DSOL/Kalasim:
+ * 1. Create DSOLSimulationProcessFactory (or similar)
+ * 2. Update Koin DI configuration to use new factory
+ * 3. All context code continues to work unchanged
+ * 4. This class can be deprecated or kept for backwards compatibility
+ *
+ * @see SimulationProcessFactory
+ * @see Generator
+ * @see InOutWorker
+ */
+class DefaultSimulationProcessFactory : SimulationProcessFactory {
+	companion object {
+		private val logger = KotlinLogging.logger {}
+	}
+
+	/**
+	 * Create main simulation process (Generator).
+	 *
+	 * Generator is responsible for:
+	 * - Creating trains according to schedules
+	 * - Managing simulation timing
+	 * - Coordinating overall simulation flow
+	 *
+	 * @param context The simulation context
+	 * @return Generator process instance
+	 */
+	override fun createMainProcess(context: SimulationContext): LoopProcess {
+		logger.debug { "Creating main Generator process for simulation" }
+		return Generator(context)
+	}
+
+	/**
+	 * Create worker process for an InOut point.
+	 *
+	 * InOutWorker is responsible for:
+	 * - Managing trains entering/exiting at this InOut
+	 * - Waiting for path availability
+	 * - Coordinating with interlocking system
+	 *
+	 * @param context The simulation context
+	 * @param inOut The InOut point to create worker for
+	 * @return InOutWorker process instance
+	 */
+	override fun createInOutWorker(
+		context: SimulationContext,
+		inOut: InOut
+	): InOutWorker {
+		logger.debug { "Creating InOutWorker for InOut: ${inOut.getName()}" }
+		return InOutWorker(context, inOut)
+	}
+}

src/main/kotlin/cz/vutbr/fit/interlockSim/xml/XMLContextFactory.kt

@@ -16,6 +16,7 @@ import cz.vutbr.fit.interlockSim.context.DefaultContext
 import cz.vutbr.fit.interlockSim.context.EditingContext
 import cz.vutbr.fit.interlockSim.context.EditingContextFactory
 import cz.vutbr.fit.interlockSim.context.SimulationContextFactory
+import cz.vutbr.fit.interlockSim.context.SimulationProcessFactory
 import cz.vutbr.fit.interlockSim.objects.cells.Cell
 import cz.vutbr.fit.interlockSim.objects.cells.Cell.Segment
 import cz.vutbr.fit.interlockSim.objects.cells.Cell.SpatialType
@@ -64,13 +65,14 @@ class XMLContextFactory :
 	SimulationContextFactory {
 
 	private val myResourceBundle: MyResourceBundle by getKoin().inject()
+	private val processFactory: SimulationProcessFactory by getKoin().inject()
 
 	// TODO: Validate track length >= train length - see issue #60 (relates to Goals 3 & 4)
 
 	private inner class XMLContext(
 		cols: Int,
 		rows: Int
-	) : DefaultContext(cols, rows) {
+	) : DefaultContext(cols, rows, processFactory) {
 		// No additional implementation needed
 	}