ocpp_model

defmodule OcppModel.V20.Behaviours.ChargeSystem do
  @moduledoc """
    Behaviour of a ChargeSystem, allowing the module assuming the behaviour to be able to respond to messages send to it


  """
  alias OcppModel.V20.Messages, as: M

  @callback authorize(req :: %M.AuthorizeRequest{})
    :: {:ok, %M.AuthorizeResponse{}}| {:error, :authorize, String.t()}

  @callback boot_notification(req :: %M.BootNotificationRequest{})
    :: {:ok, %M.BootNotificationResponse{}} | {:error, :boot_notification, String.t()}

  @callback cleared_charging_limit(req :: %M.ClearedChargingLimitRequest{})
    :: {:ok, %M.ClearedChargingLimitResponse{}} | {:error, :cleared_charging_limit, String.t()}

  @callback data_transfer(req :: %M.DataTransferRequest{})
    :: {:ok, %M.DataTransferResponse{}} | {:error, :data_transfer, String.t()}

  @callback firmware_status_notification(req :: %M.FirmwareStatusNotificationRequest{})
    :: {:ok, %M.FirmwareStatusNotificationResponse{}} | {:error, :firmware_status_notification, String.t()}

  @callback get_15118_ev_certificate(req :: %M.Get15118EVCertificateRequest{})
    :: {:ok, %M.Get15118EVCertificateResponse{}} | {:error, :get_15118_ev_certificate, String.t()}

  @callback get_certificate_status(req :: %M.GetCertificateStatusRequest{})
    :: {:ok, %M.GetCertificateStatusResponse{}} | {:error, :get_certificate_status, String.t()}

  @callback heartbeat(req :: %M.HeartbeatRequest{})
    :: {:ok, %M.HeartbeatResponse{}} | {:error, :heartbeat, String.t()}

  @callback log_status_notification(req :: %M.LogStatusNotificationRequest{})
    :: {:ok, %M.LogStatusNotificationResponse{}} | {:error, :log_status_notification, String.t()}

  @callback notify_charging_limit(req :: %M.NotifyChargingLimitRequest{})
    :: {:ok, %M.NotifyChargingLimitResponse{}} | {:error, :notify_charging_limit, String.t()}

  @callback notify_customer_information(req :: %M.NotifyCustomerInformationRequest{})
    :: {:ok, %M.NotifyCustomerInformationResponse{}} | {:error, :notify_customer_information, String.t()}

  @callback notify_display_messages(req :: %M.NotifyDisplayMessagesRequest{})
    :: {:ok, %M.NotifyDisplayMessagesResponse{}} | {:error, :notify_display_messages, String.t()}

  @callback notify_ev_charging_needs(req :: %M.NotifyEVChargingNeedsRequest{})
    :: {:ok, %M.NotifyEVChargingNeedsResponse{}} | {:error, :notify_ev_charging_needs, String.t()}

  @callback notify_ev_charging_schedule(req :: %M.NotifyEVChargingScheduleRequest{})
    :: {:ok, %M.NotifyEVChargingScheduleResponse{}} | {:error, :notify_ev_charging_needs, String.t()}

  @callback notify_event(req :: %M.NotifyEventRequest{})
    :: {:ok, %M.NotifyEventResponse{}} | {:error, :notify_event, String.t()}

  @callback notify_monitoring_report(req :: %M.NotifyMonitoringReportRequest{})
    :: {:ok, %M.NotifyMonitoringReportResponse{}} | {:error, :notify_monitoring_report, String.t()}

  @callback notify_report(req :: %M.NotifyReportRequest{})
    :: {:ok, %M.NotifyReportResponse{}} | {:error, :notify_report, String.t()}

  @callback meter_values(req :: %M.MeterValuesRequest{})
    :: {:ok, %M.MeterValuesResponse{}} | {:error, :meter_values, String.t()}

  @callback publish_firmware_status_notification(req :: %M.PublishFirmwareStatusNotificationRequest{})
    :: {:ok, %M.PublishFirmwareStatusNotificationResponse{}}
     | {:error, :publish_firmware_status_notification, String.t()}

  @callback report_charging_profiles(req :: %M.ReportChargingProfilesRequest{})
    :: {:ok, %M.ReportChargingProfilesResponse{}} | {:error, :report_charging_profiles, String.t()}

  @callback reservation_status_update(req :: %M.ReservationStatusUpdateRequest{})
    :: {:ok, %M.ReservationStatusUpdateResponse{}} | {:error, :reservation_status_update, String.t()}

  @callback security_event_notification(req :: %M.SecurityEventNotificationRequest{})
    :: {:ok, %M.SecurityEventNotificationResponse{}} | {:error, :security_event_notification, String.t()}

  @callback status_notification(req :: %M.StatusNotificationRequest{})
    :: {:ok, %M.StatusNotificationResponse{}} | {:error, :status_notification, String.t()}

  @callback transaction_event(req :: %M.TransactionEventRequest{})
    :: {:ok, %M.TransactionEventResponse{}} | {:error, :transaction_event, String.t()}

  @spec handle(atom(), String.t(), map()) :: {:ok, map()} | {:error, atom(), String.t()}
  @doc """
    Main entrypoint, based on the action parameter, this function will call one of the callback functions with the payload
  """

  def handle(impl, action, payload) when action == "Authorize" do
    payload |> OcppModel.to_struct(M.AuthorizeRequest) |> impl.authorize |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "BootNotification" do
    payload |> OcppModel.to_struct(M.BootNotificationRequest) |> impl.boot_notification |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "ClearedChargingLimit" do
    payload |> OcppModel.to_struct(M.ClearedChargingLimitRequest) |> impl.cleared_charging_limit |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "DataTransfer" do
    payload |> OcppModel.to_struct(M.DataTransferRequest) |> impl.data_transfer |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "FirmwareStatusNotification" do
    payload |> OcppModel.to_struct(M.FirmwareStatusNotificationRequest)
      |> impl.firmware_status_notification |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "Get15118EVCertificate" do
    payload |> OcppModel.to_struct(M.Get15118EVCertificateRequest)
      |> impl.get_15118_ev_certificate |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "GetCertificateStatus" do
    payload |> OcppModel.to_struct(M.GetCertificateStatusRequest) |> impl.get_certificate_status |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "Heartbeat" do
    payload |> OcppModel.to_struct(M.HeartbeatRequest) |> impl.heartbeat |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "LogStatusNotification" do
    payload |> OcppModel.to_struct(M.LogStatusNotificationRequest) |> impl.log_status_notification |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "MeterValues" do
    payload |> OcppModel.to_struct(M.MeterValuesRequest) |> impl.meter_values |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "NotifyChargingLimit" do
    payload |> OcppModel.to_struct(M.NotifyChargingLimitRequest) |> impl.notify_charging_limit |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "NotifyCustomerInformation" do
    payload |> OcppModel.to_struct(M.NotifyCustomerInformationRequest) |> impl.meter_values |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "NotifyDisplayMessages" do
    payload |> OcppModel.to_struct(M.NotifyDisplayMessagesRequest) |> impl.notify_display_messages |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "NotifyEVChargingNeeds" do
    payload |> OcppModel.to_struct(M.NotifyEVChargingNeedsRequest)
      |> impl.notify_ev_charging_needs |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "NotifyEVChargingSchedule" do
    payload |> OcppModel.to_struct(M.NotifyEVChargingScheduleRequest)
      |> impl.notify_ev_charging_schedule |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "NotifyEvent" do
    payload |> OcppModel.to_struct(M.NotifyEventRequest) |> impl.notify_event |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "NotifyMonitoringReport" do
    payload |> OcppModel.to_struct(M.NotifyMonitoringReportRequest)
      |> impl.notify_monitoring_report |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "NotifyReport" do
    payload |> OcppModel.to_struct(M.NotifyReportRequest) |> impl.notify_report |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "PublishFirmwareStatusNotification" do
    payload |> OcppModel.to_struct(M.PublishFirmwareStatusNotificationRequest)
      |> impl.status_notification |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "ReportChargingProfiles" do
    payload |> OcppModel.to_struct(M.ReportChargingProfilesRequest)
      |> impl.report_charging_profiles |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "ReservationStatusUpdate" do
    payload |> OcppModel.to_struct(M.ReservationStatusUpdateRequest)
      |> impl.reservation_status_update |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "SecurityEventNotification" do
    payload |> OcppModel.to_struct(M.SecurityEventNotificationRequest)
      |> impl.security_event_notification |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "StatusNotification" do
    payload |> OcppModel.to_struct(M.StatusNotificationRequest) |> impl.status_notification |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "TransactionEvent" do
    payload |> OcppModel.to_struct(M.TransactionEventRequest) |> impl.transaction_event |> OcppModel.to_map()
  end

  def handle(_impl, action, _payload), do: {:error, :unknown_action, "Action #{action} is unknown"}

end