///|
/// Internal typed parsing failure used to keep payload codec code linear.
pub(all) suberror ProtocolFailure {
  Failure(ProtocolError)
}

///|
fn[T] result_of(
  parse : () -> T raise ProtocolFailure,
) -> Result[T, ProtocolError] {
  Ok(parse()) catch {
    Failure(error) => Err(error)
  }
}

///|
fn[T] refuse(error : ProtocolError) -> T raise ProtocolFailure {
  raise Failure(error)
}

///|
fn object_field(value : Json, name : String) -> Json raise ProtocolFailure {
  let fields = match value {
    Json::Object(fields) => fields
    _ => refuse(InvalidPayload)
  }
  match fields.get(name) {
    Some(field) => field
    None => refuse(MissingField(name))
  }
}

///|
fn required_string(value : Json, name : String) -> String raise ProtocolFailure {
  match object_field(value, name) {
    Json::String(text) => text
    _ => refuse(InvalidField(name))
  }
}

///|
fn optional_string(
  value : Json,
  name : String,
) -> String? raise ProtocolFailure {
  let fields = match value {
    Json::Object(fields) => fields
    _ => refuse(InvalidPayload)
  }
  match fields.get(name) {
    None | Some(Json::Null) => None
    Some(Json::String(text)) => Some(text)
    Some(_) => refuse(InvalidField(name))
  }
}

///|
fn required_array(
  value : Json,
  name : String,
) -> Array[Json] raise ProtocolFailure {
  match object_field(value, name) {
    Json::Array(items) => items
    _ => refuse(InvalidField(name))
  }
}

///|
fn required_object(value : Json, name : String) -> Json raise ProtocolFailure {
  let field = object_field(value, name)
  match field {
    Json::Object(_) => field
    _ => refuse(InvalidField(name))
  }
}

///|
fn json_int(field : Json, name : String) -> Int32 raise ProtocolFailure {
  match field {
    Json::Number(number, ..) => {
      let int = number.to_int()
      if int >= 0 && int.to_double() == number {
        int
      } else {
        refuse(InvalidField(name))
      }
    }
    _ => refuse(InvalidField(name))
  }
}

///|
fn required_nonnegative_int(
  value : Json,
  name : String,
) -> Int32 raise ProtocolFailure {
  json_int(object_field(value, name), name)
}

///|
fn optional_nonnegative_int(
  value : Json,
  name : String,
) -> Int32? raise ProtocolFailure {
  let fields = match value {
    Json::Object(fields) => fields
    _ => refuse(InvalidPayload)
  }
  match fields.get(name) {
    None | Some(Json::Null) => None
    Some(field) => Some(json_int(field, name))
  }
}

///|
fn int_json(value : Int32) -> Json {
  Json::number(value.to_double(), repr=value.to_string())
}

///|
fn set_optional_string(
  fields : Map[String, Json],
  name : String,
  value : String?,
) -> Unit {
  match value {
    Some(value) => fields.set(name, Json::string(value))
    None => ()
  }
}

///|
pub(all) enum RegistrationStatus {
  Accepted
  Pending
  Rejected
} derive(Eq, @debug.Debug)

///|
fn registration_status(
  value : String,
) -> RegistrationStatus raise ProtocolFailure {
  match value {
    "Accepted" => Accepted
    "Pending" => Pending
    "Rejected" => Rejected
    _ => refuse(UnsupportedValue("status", value))
  }
}

///|
fn registration_status_name(value : RegistrationStatus) -> String {
  match value {
    Accepted => "Accepted"
    Pending => "Pending"
    Rejected => "Rejected"
  }
}

///|
pub(all) enum AuthorizationStatus {
  Accepted
  Blocked
  Expired
  Invalid
  ConcurrentTx
} derive(Eq, @debug.Debug)

///|
fn authorization_status(
  field : String,
  value : String,
) -> AuthorizationStatus raise ProtocolFailure {
  match value {
    "Accepted" => Accepted
    "Blocked" => Blocked
    "Expired" => Expired
    "Invalid" => Invalid
    "ConcurrentTx" => ConcurrentTx
    _ => refuse(UnsupportedValue(field, value))
  }
}

///|
fn authorization_status_name(value : AuthorizationStatus) -> String {
  match value {
    Accepted => "Accepted"
    Blocked => "Blocked"
    Expired => "Expired"
    Invalid => "Invalid"
    ConcurrentTx => "ConcurrentTx"
  }
}

///|
pub(all) enum ChargePointStatus {
  Available
  Preparing
  Charging
  SuspendedEV
  SuspendedEVSE
  Finishing
  Reserved
  Unavailable
  Faulted
} derive(Eq, @debug.Debug)

///|
pub fn ChargePointStatus::parse(value : String) -> ChargePointStatus? {
  match value {
    "Available" => Some(Available)
    "Preparing" => Some(Preparing)
    "Charging" => Some(Charging)
    "SuspendedEV" => Some(SuspendedEV)
    "SuspendedEVSE" => Some(SuspendedEVSE)
    "Finishing" => Some(Finishing)
    "Reserved" => Some(Reserved)
    "Unavailable" => Some(Unavailable)
    "Faulted" => Some(Faulted)
    _ => None
  }
}

///|
pub fn ChargePointStatus::name(self : ChargePointStatus) -> String {
  match self {
    Available => "Available"
    Preparing => "Preparing"
    Charging => "Charging"
    SuspendedEV => "SuspendedEV"
    SuspendedEVSE => "SuspendedEVSE"
    Finishing => "Finishing"
    Reserved => "Reserved"
    Unavailable => "Unavailable"
    Faulted => "Faulted"
  }
}

///|
pub(all) enum ChargePointErrorCode {
  NoError
  ConnectorLockFailure
  EVCommunicationError
  GroundFailure
  HighTemperature
  InternalError
  LocalListConflict
  OtherError
  OverCurrentFailure
  PowerMeterFailure
  PowerSwitchFailure
  ReaderFailure
  ResetFailure
  UnderVoltage
  WeakSignal
} derive(Eq, @debug.Debug)

///|
fn error_code(value : String) -> ChargePointErrorCode raise ProtocolFailure {
  match value {
    "NoError" => NoError
    "ConnectorLockFailure" => ConnectorLockFailure
    "EVCommunicationError" => EVCommunicationError
    "GroundFailure" => GroundFailure
    "HighTemperature" => HighTemperature
    "InternalError" => InternalError
    "LocalListConflict" => LocalListConflict
    "OtherError" => OtherError
    "OverCurrentFailure" => OverCurrentFailure
    "PowerMeterFailure" => PowerMeterFailure
    "PowerSwitchFailure" => PowerSwitchFailure
    "ReaderFailure" => ReaderFailure
    "ResetFailure" => ResetFailure
    "UnderVoltage" => UnderVoltage
    "WeakSignal" => WeakSignal
    _ => refuse(UnsupportedValue("errorCode", value))
  }
}

///|
fn error_code_name(value : ChargePointErrorCode) -> String {
  match value {
    NoError => "NoError"
    ConnectorLockFailure => "ConnectorLockFailure"
    EVCommunicationError => "EVCommunicationError"
    GroundFailure => "GroundFailure"
    HighTemperature => "HighTemperature"
    InternalError => "InternalError"
    LocalListConflict => "LocalListConflict"
    OtherError => "OtherError"
    OverCurrentFailure => "OverCurrentFailure"
    PowerMeterFailure => "PowerMeterFailure"
    PowerSwitchFailure => "PowerSwitchFailure"
    ReaderFailure => "ReaderFailure"
    ResetFailure => "ResetFailure"
    UnderVoltage => "UnderVoltage"
    WeakSignal => "WeakSignal"
  }
}

///|
pub(all) enum StopReason {
  EmergencyStop
  EVDisconnected
  HardReset
  Local
  Other
  PowerLoss
  Reboot
  Remote
  SoftReset
  UnlockCommand
  DeAuthorized
} derive(Eq, @debug.Debug)

///|
fn stop_reason(value : String) -> StopReason raise ProtocolFailure {
  match value {
    "EmergencyStop" => EmergencyStop
    "EVDisconnected" => EVDisconnected
    "HardReset" => HardReset
    "Local" => Local
    "Other" => Other
    "PowerLoss" => PowerLoss
    "Reboot" => Reboot
    "Remote" => Remote
    "SoftReset" => SoftReset
    "UnlockCommand" => UnlockCommand
    "DeAuthorized" => DeAuthorized
    _ => refuse(UnsupportedValue("reason", value))
  }
}

///|
fn stop_reason_name(value : StopReason) -> String {
  match value {
    EmergencyStop => "EmergencyStop"
    EVDisconnected => "EVDisconnected"
    HardReset => "HardReset"
    Local => "Local"
    Other => "Other"
    PowerLoss => "PowerLoss"
    Reboot => "Reboot"
    Remote => "Remote"
    SoftReset => "SoftReset"
    UnlockCommand => "UnlockCommand"
    DeAuthorized => "DeAuthorized"
  }
}

///|
pub(all) struct IdTagInfo {
  status : AuthorizationStatus
  expiry_date : String?
  parent_id_tag : String?
} derive(Eq, @debug.Debug)

///|
fn parse_id_tag_info(value : Json) -> IdTagInfo raise ProtocolFailure {
  {
    status: authorization_status("status", required_string(value, "status")),
    expiry_date: optional_string(value, "expiryDate"),
    parent_id_tag: optional_string(value, "parentIdTag"),
  }
}

///|
pub fn IdTagInfo::from_json(value : Json) -> Result[IdTagInfo, ProtocolError] {
  result_of(() => parse_id_tag_info(value))
}

///|
pub fn IdTagInfo::to_json(self : IdTagInfo) -> Json {
  let fields : Map[String, Json] = {
    "status": Json::string(authorization_status_name(self.status)),
  }
  set_optional_string(fields, "expiryDate", self.expiry_date)
  set_optional_string(fields, "parentIdTag", self.parent_id_tag)
  Json::object(fields)
}

///|
pub(all) struct BootNotificationRequest {
  charge_point_vendor : String
  charge_point_model : String
  charge_point_serial_number : String?
  charge_point_firmware_version : String?
  meter_type : String?
  meter_serial_number : String?
  iccid : String?
  imsi : String?
} derive(Eq, @debug.Debug)

///|
fn parse_boot_notification_request(
  value : Json,
) -> BootNotificationRequest raise ProtocolFailure {
  {
    charge_point_vendor: required_string(value, "chargePointVendor"),
    charge_point_model: required_string(value, "chargePointModel"),
    charge_point_serial_number: optional_string(
      value, "chargePointSerialNumber",
    ),
    charge_point_firmware_version: optional_string(
      value, "chargePointFirmwareVersion",
    ),
    meter_type: optional_string(value, "meterType"),
    meter_serial_number: optional_string(value, "meterSerialNumber"),
    iccid: optional_string(value, "iccid"),
    imsi: optional_string(value, "imsi"),
  }
}

///|
pub fn BootNotificationRequest::from_json(
  value : Json,
) -> Result[BootNotificationRequest, ProtocolError] {
  result_of(() => parse_boot_notification_request(value))
}

///|
pub fn BootNotificationRequest::to_json(self : BootNotificationRequest) -> Json {
  let fields : Map[String, Json] = {
    "chargePointVendor": Json::string(self.charge_point_vendor),
    "chargePointModel": Json::string(self.charge_point_model),
  }
  set_optional_string(
    fields,
    "chargePointSerialNumber",
    self.charge_point_serial_number,
  )
  set_optional_string(
    fields,
    "chargePointFirmwareVersion",
    self.charge_point_firmware_version,
  )
  set_optional_string(fields, "meterType", self.meter_type)
  set_optional_string(fields, "meterSerialNumber", self.meter_serial_number)
  set_optional_string(fields, "iccid", self.iccid)
  set_optional_string(fields, "imsi", self.imsi)
  Json::object(fields)
}

///|
pub(all) struct BootNotificationResponse {
  status : RegistrationStatus
  current_time : String
  heartbeat_interval : Int32
} derive(Eq, @debug.Debug)

///|
fn parse_boot_notification_response(
  value : Json,
) -> BootNotificationResponse raise ProtocolFailure {
  {
    status: registration_status(required_string(value, "status")),
    current_time: required_string(value, "currentTime"),
    heartbeat_interval: required_nonnegative_int(value, "heartbeatInterval"),
  }
}

///|
pub fn BootNotificationResponse::from_json(
  value : Json,
) -> Result[BootNotificationResponse, ProtocolError] {
  result_of(() => parse_boot_notification_response(value))
}

///|
pub fn BootNotificationResponse::to_json(
  self : BootNotificationResponse,
) -> Json {
  Json::object({
    "status": Json::string(registration_status_name(self.status)),
    "currentTime": Json::string(self.current_time),
    "heartbeatInterval": int_json(self.heartbeat_interval),
  })
}

///|
pub(all) struct HeartbeatResponse {
  current_time : String
} derive(Eq, @debug.Debug)

///|
fn parse_heartbeat_response(
  value : Json,
) -> HeartbeatResponse raise ProtocolFailure {
  { current_time: required_string(value, "currentTime"), }
}

///|
pub fn HeartbeatResponse::from_json(
  value : Json,
) -> Result[HeartbeatResponse, ProtocolError] {
  result_of(() => parse_heartbeat_response(value))
}

///|
pub fn HeartbeatResponse::to_json(self : HeartbeatResponse) -> Json {
  Json::object({ "currentTime": Json::string(self.current_time) })
}

///|
pub(all) struct StatusNotificationRequest {
  connector_id : Int32
  error_code : ChargePointErrorCode
  status : ChargePointStatus
  timestamp : String?
  info : String?
  vendor_id : String?
  vendor_error_code : String?
} derive(Eq, @debug.Debug)

///|
fn parse_status_notification_request(
  value : Json,
) -> StatusNotificationRequest raise ProtocolFailure {
  let status_text = required_string(value, "status")
  let status = match ChargePointStatus::parse(status_text) {
    Some(status) => status
    None => refuse(UnsupportedValue("status", status_text))
  }
  {
    connector_id: required_nonnegative_int(value, "connectorId"),
    error_code: error_code(required_string(value, "errorCode")),
    status,
    timestamp: optional_string(value, "timestamp"),
    info: optional_string(value, "info"),
    vendor_id: optional_string(value, "vendorId"),
    vendor_error_code: optional_string(value, "vendorErrorCode"),
  }
}

///|
pub fn StatusNotificationRequest::from_json(
  value : Json,
) -> Result[StatusNotificationRequest, ProtocolError] {
  result_of(() => parse_status_notification_request(value))
}

///|
pub fn StatusNotificationRequest::to_json(
  self : StatusNotificationRequest,
) -> Json {
  let fields : Map[String, Json] = {
    "connectorId": int_json(self.connector_id),
    "errorCode": Json::string(error_code_name(self.error_code)),
    "status": Json::string(self.status.name()),
  }
  set_optional_string(fields, "timestamp", self.timestamp)
  set_optional_string(fields, "info", self.info)
  set_optional_string(fields, "vendorId", self.vendor_id)
  set_optional_string(fields, "vendorErrorCode", self.vendor_error_code)
  Json::object(fields)
}

///|
pub(all) struct AuthorizeRequest {
  id_tag : String
} derive(Eq, @debug.Debug)

///|
fn parse_authorize_request(
  value : Json,
) -> AuthorizeRequest raise ProtocolFailure {
  let id_tag = required_string(value, "idTag")
  if id_tag.is_empty() {
    refuse(InvalidField("idTag"))
  }
  { id_tag, }
}

///|
pub fn AuthorizeRequest::from_json(
  value : Json,
) -> Result[AuthorizeRequest, ProtocolError] {
  result_of(() => parse_authorize_request(value))
}

///|
pub fn AuthorizeRequest::to_json(self : AuthorizeRequest) -> Json {
  Json::object({ "idTag": Json::string(self.id_tag) })
}

///|
pub(all) struct AuthorizeResponse {
  id_tag_info : IdTagInfo
} derive(Eq, @debug.Debug)

///|
fn parse_authorize_response(
  value : Json,
) -> AuthorizeResponse raise ProtocolFailure {
  { id_tag_info: parse_id_tag_info(required_object(value, "idTagInfo")), }
}

///|
pub fn AuthorizeResponse::from_json(
  value : Json,
) -> Result[AuthorizeResponse, ProtocolError] {
  result_of(() => parse_authorize_response(value))
}

///|
pub fn AuthorizeResponse::to_json(self : AuthorizeResponse) -> Json {
  Json::object({ "idTagInfo": self.id_tag_info.to_json() })
}

///|
pub(all) struct StartTransactionRequest {
  connector_id : Int32
  id_tag : String
  meter_start : Int32
  reservation_id : Int32?
  timestamp : String
} derive(Eq, @debug.Debug)

///|
fn parse_start_transaction_request(
  value : Json,
) -> StartTransactionRequest raise ProtocolFailure {
  let id_tag = required_string(value, "idTag")
  if id_tag.is_empty() {
    refuse(InvalidField("idTag"))
  }
  {
    connector_id: required_nonnegative_int(value, "connectorId"),
    id_tag,
    meter_start: required_nonnegative_int(value, "meterStart"),
    reservation_id: optional_nonnegative_int(value, "reservationId"),
    timestamp: required_string(value, "timestamp"),
  }
}

///|
pub fn StartTransactionRequest::from_json(
  value : Json,
) -> Result[StartTransactionRequest, ProtocolError] {
  result_of(() => parse_start_transaction_request(value))
}

///|
pub fn StartTransactionRequest::to_json(self : StartTransactionRequest) -> Json {
  let fields : Map[String, Json] = {
    "connectorId": int_json(self.connector_id),
    "idTag": Json::string(self.id_tag),
    "meterStart": int_json(self.meter_start),
    "timestamp": Json::string(self.timestamp),
  }
  match self.reservation_id {
    Some(value) => fields.set("reservationId", int_json(value))
    None => ()
  }
  Json::object(fields)
}

///|
pub(all) struct StartTransactionResponse {
  transaction_id : Int32
  id_tag_info : IdTagInfo
} derive(Eq, @debug.Debug)

///|
fn parse_start_transaction_response(
  value : Json,
) -> StartTransactionResponse raise ProtocolFailure {
  {
    transaction_id: required_nonnegative_int(value, "transactionId"),
    id_tag_info: parse_id_tag_info(required_object(value, "idTagInfo")),
  }
}

///|
pub fn StartTransactionResponse::from_json(
  value : Json,
) -> Result[StartTransactionResponse, ProtocolError] {
  result_of(() => parse_start_transaction_response(value))
}

///|
pub fn StartTransactionResponse::to_json(
  self : StartTransactionResponse,
) -> Json {
  Json::object({
    "transactionId": int_json(self.transaction_id),
    "idTagInfo": self.id_tag_info.to_json(),
  })
}

///|
pub(all) struct StopTransactionRequest {
  transaction_id : Int32
  meter_stop : Int32
  timestamp : String
  reason : StopReason?
  id_tag : String?
} derive(Eq, @debug.Debug)

///|
fn parse_stop_transaction_request(
  value : Json,
) -> StopTransactionRequest raise ProtocolFailure {
  let reason = match optional_string(value, "reason") {
    None => None
    Some(text) => Some(stop_reason(text))
  }
  {
    transaction_id: required_nonnegative_int(value, "transactionId"),
    meter_stop: required_nonnegative_int(value, "meterStop"),
    timestamp: required_string(value, "timestamp"),
    reason,
    id_tag: optional_string(value, "idTag"),
  }
}

///|
pub fn StopTransactionRequest::from_json(
  value : Json,
) -> Result[StopTransactionRequest, ProtocolError] {
  result_of(() => parse_stop_transaction_request(value))
}

///|
pub fn StopTransactionRequest::to_json(self : StopTransactionRequest) -> Json {
  let fields : Map[String, Json] = {
    "transactionId": int_json(self.transaction_id),
    "meterStop": int_json(self.meter_stop),
    "timestamp": Json::string(self.timestamp),
  }
  match self.reason {
    Some(reason) => fields.set("reason", Json::string(stop_reason_name(reason)))
    None => ()
  }
  set_optional_string(fields, "idTag", self.id_tag)
  Json::object(fields)
}

///|
pub(all) struct SampledValue {
  value : String
  context : String?
  format : String?
  measurand : String?
  phase : String?
  location : String?
  unit : String?
} derive(Eq, @debug.Debug)

///|
fn parse_sampled_value(value : Json) -> SampledValue raise ProtocolFailure {
  let sampled = required_string(value, "value")
  if sampled.is_empty() {
    refuse(InvalidField("value"))
  }
  {
    value: sampled,
    context: optional_string(value, "context"),
    format: optional_string(value, "format"),
    measurand: optional_string(value, "measurand"),
    phase: optional_string(value, "phase"),
    location: optional_string(value, "location"),
    unit: optional_string(value, "unit"),
  }
}

///|
pub fn SampledValue::from_json(
  value : Json,
) -> Result[SampledValue, ProtocolError] {
  result_of(() => parse_sampled_value(value))
}

///|
pub fn SampledValue::to_json(self : SampledValue) -> Json {
  let fields : Map[String, Json] = { "value": Json::string(self.value) }
  set_optional_string(fields, "context", self.context)
  set_optional_string(fields, "format", self.format)
  set_optional_string(fields, "measurand", self.measurand)
  set_optional_string(fields, "phase", self.phase)
  set_optional_string(fields, "location", self.location)
  set_optional_string(fields, "unit", self.unit)
  Json::object(fields)
}

///|
pub(all) struct MeterValue {
  timestamp : String
  sampled_value : Array[SampledValue]
} derive(Eq, @debug.Debug)

///|
fn parse_meter_value(value : Json) -> MeterValue raise ProtocolFailure {
  let items = required_array(value, "sampledValue")
  if items.is_empty() {
    refuse(InvalidField("sampledValue"))
  }
  let sampled_value = []
  for item in items {
    sampled_value.push(parse_sampled_value(item))
  }
  { timestamp: required_string(value, "timestamp"), sampled_value, }
}

///|
pub fn MeterValue::from_json(value : Json) -> Result[MeterValue, ProtocolError] {
  result_of(() => parse_meter_value(value))
}

///|
pub fn MeterValue::to_json(self : MeterValue) -> Json {
  Json::object({
    "timestamp": Json::string(self.timestamp),
    "sampledValue": Json::array(
      self.sampled_value.map(fn(value) { value.to_json() }),
    ),
  })
}

///|
pub(all) struct MeterValuesRequest {
  connector_id : Int32
  transaction_id : Int32?
  meter_value : Array[MeterValue]
} derive(Eq, @debug.Debug)

///|
fn parse_meter_values_request(
  value : Json,
) -> MeterValuesRequest raise ProtocolFailure {
  let items = required_array(value, "meterValue")
  if items.is_empty() {
    refuse(InvalidField("meterValue"))
  }
  let meter_value = []
  for item in items {
    meter_value.push(parse_meter_value(item))
  }
  {
    connector_id: required_nonnegative_int(value, "connectorId"),
    transaction_id: optional_nonnegative_int(value, "transactionId"),
    meter_value,
  }
}

///|
pub fn MeterValuesRequest::from_json(
  value : Json,
) -> Result[MeterValuesRequest, ProtocolError] {
  result_of(() => parse_meter_values_request(value))
}

///|
pub fn MeterValuesRequest::to_json(self : MeterValuesRequest) -> Json {
  let fields : Map[String, Json] = {
    "connectorId": int_json(self.connector_id),
    "meterValue": Json::array(
      self.meter_value.map(fn(value) { value.to_json() }),
    ),
  }
  match self.transaction_id {
    Some(value) => fields.set("transactionId", int_json(value))
    None => ()
  }
  Json::object(fields)
}