///|
pub(all) struct TopologyBuilder {
  station : Station
} derive(Debug)

///|
pub fn TopologyBuilder::new(station_name : String) -> TopologyBuilder {
  { station: Station::new(station_name) }
}

///|
pub fn TopologyBuilder::add_track_section(
  self : TopologyBuilder,
  name : String,
  length : Double,
  speed : Double,
  start_name : String,
  end_name : String,
  direction : TrackDirection,
) -> TrackId {
  let start_node = self.station.create_node(start_name, TrackNode)
  let end_node = self.station.create_node(end_name, TrackNode)
  self.station.create_track(
    name, length, speed, start_node, end_node, direction,
  )
}

///|
pub fn TopologyBuilder::add_turnout_node(
  self : TopologyBuilder,
  name : String,
  base_name : String,
  normal_name : String,
  reverse_name : String,
) -> TurnoutId {
  let base_node = self.station.create_node(base_name, TurnoutBaseNode)
  let normal_node = self.station.create_node(normal_name, TurnoutNormalNode)
  let reverse_node = self.station.create_node(reverse_name, TurnoutReverseNode)
  self.station.create_turnout(name, base_node, normal_node, reverse_node)
}

///|
pub fn TopologyBuilder::add_signal_at(
  self : TopologyBuilder,
  name : String,
  signal_type : SignalType,
  node_name : String,
  direction : TrackDirection,
) -> SignalId {
  let node = self.station.create_node(node_name, SignalNode)
  self.station.create_signal(name, signal_type, node, direction)
}

///|
pub fn TopologyBuilder::build(self : TopologyBuilder) -> Station {
  self.station
}