///|
pub(all) struct ChargingTransaction {
  transaction_id : Int32
  id_tag : String
  meter_start : Int32
  start_timestamp : String
  meter_stop : Int32?
  stop_timestamp : String?
  stop_reason : StopReason?
} derive(Eq, @debug.Debug)

///|
pub(all) struct ConnectorSession {
  connector_id : Int32
  status : ChargePointStatus
  transaction : ChargingTransaction?
} derive(Eq, @debug.Debug)

///|
pub(all) enum SessionError {
  InvalidConnectorId(Int32)
  TransactionAlreadyActive(Int32)
  NoActiveTransaction(Int32)
  TransactionMismatch(Int32, Int32)
  TransactionIdAlreadyUsed(Int32)
  MeterRegression(Int32, Int32)
  InvalidIdTag
} derive(Eq, @debug.Debug)

///|
pub fn ConnectorSession::new(
  connector_id : Int32,
) -> Result[ConnectorSession, SessionError] {
  if connector_id < 0 {
    Err(InvalidConnectorId(connector_id))
  } else {
    Ok({ connector_id, status: Available, transaction: None, })
  }
}

///|
pub fn ConnectorSession::apply_status(
  self : ConnectorSession,
  status : ChargePointStatus,
) -> ConnectorSession {
  { ..self, status, }
}

///|
pub fn ConnectorSession::begin_transaction(
  self : ConnectorSession,
  transaction_id : Int32,
  id_tag : String,
  meter_start : Int32,
  timestamp : String,
) -> Result[ConnectorSession, SessionError] {
  if id_tag.is_empty() {
    return Err(InvalidIdTag)
  }
  if transaction_id < 0 || meter_start < 0 {
    return Err(TransactionAlreadyActive(transaction_id))
  }
  match self.transaction {
    Some(active) => Err(TransactionAlreadyActive(active.transaction_id))
    None => {
      let transaction = {
        transaction_id,
        id_tag,
        meter_start,
        start_timestamp: timestamp,
        meter_stop: None,
        stop_timestamp: None,
        stop_reason: None,
      }
      Ok({ ..self, status: Preparing, transaction: Some(transaction), })
    }
  }
}

///|
pub fn ConnectorSession::begin_charging(
  self : ConnectorSession,
) -> Result[ConnectorSession, SessionError] {
  match self.transaction {
    Some(_) => Ok({ ..self, status: Charging, })
    None => Err(NoActiveTransaction(self.connector_id))
  }
}

///|
pub fn ConnectorSession::finish_transaction(
  self : ConnectorSession,
  transaction_id : Int32,
  meter_stop : Int32,
  timestamp : String,
  reason : StopReason?,
) -> Result[ConnectorSession, SessionError] {
  let active = match self.transaction {
    Some(active) => active
    None => return Err(NoActiveTransaction(self.connector_id))
  }
  if active.transaction_id != transaction_id {
    return Err(TransactionMismatch(active.transaction_id, transaction_id))
  }
  if meter_stop < active.meter_start {
    return Err(MeterRegression(active.meter_start, meter_stop))
  }
  let completed = {
    ..active,
    meter_stop: Some(meter_stop),
    stop_timestamp: Some(timestamp),
    stop_reason: reason,
  }
  Ok({ ..self, status: Finishing, transaction: Some(completed), })
}

///|
pub fn ConnectorSession::release_transaction(
  self : ConnectorSession,
  transaction_id : Int32,
) -> Result[ConnectorSession, SessionError] {
  let active = match self.transaction {
    Some(active) => active
    None => return Err(NoActiveTransaction(self.connector_id))
  }
  if active.transaction_id != transaction_id {
    return Err(TransactionMismatch(active.transaction_id, transaction_id))
  }
  Ok({ ..self, status: Available, transaction: None, })
}

///|
pub fn ConnectorSession::mark_faulted(
  self : ConnectorSession,
) -> ConnectorSession {
  { ..self, status: Faulted, }
}