ocpp_model

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

  alias OcppModel.V20.Messages, as: M

  @callback cancel_reservation(req :: %M.CancelReservationRequest{})
              :: {:ok, %M.CancelReservationResponse{}} | {:error, :cancel_reservation, String.t()}

  @callback certificate_signed(req :: %M.CertificateSignedRequest{})
              :: {:ok, %M.CertificateSignedResponse{}} | {:error, :certificate_signed, String.t()}

  @callback change_availability(req :: %M.ChangeAvailabilityRequest{})
              :: {:ok, %M.ChangeAvailabilityResponse{}} | {:error, :change_availability, String.t()}

  @callback clear_cache(req :: %M.ClearCacheRequest{})
              :: {:ok, %M.ClearCacheResponse{}} | {:error, :clear_cache, String.t()}

  @callback clear_charging_profile(req :: %M.ClearChargingProfileRequest{})
              :: {:ok, %M.ClearChargingProfileResponse{}} | {:error, :clear_charging_profile, String.t()}

  @callback clear_display_message(req :: %M.ClearDisplayMessageRequest{})
              :: {:ok, %M.ClearDisplayMessageResponse{}} | {:error, :clear_display_message, String.t()}

  @callback clear_variable_monitoring(req :: %M.ClearVariableMonitoringRequest{})
              :: {:ok, %M.ClearVariableMonitoringResponse{}}  | {:error, :clear_variable_monitoring, String.t()}

  @callback cost_updated(req :: %M.CostUpdatedRequest{})
              :: {:ok, %M.CostUpdatedResponse{}} | {:error, :cost_updated, String.t()}

  @callback customer_information(req :: %M.CustomerInformationRequest{})
              :: {:ok, %M.CustomerInformationResponse{}} | {:error, :customer_information, String.t()}

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

  @callback delete_certificate(req :: %M.DeleteCertificateRequest{})
              :: {:ok, %M.DeleteCertificateResponse{}} | {:error, :delete_certificate, String.t()}

  @callback get_base_report(req:: %M.GetBaseReportRequest{})
              :: {:ok, %M.GetBaseReportResponse{}} | {:error, :get_base_report, String.t()}

  @callback get_charging_profiles(req :: %M.GetChargingProfilesRequest{})
              :: {:ok, %M.GetChargingProfilesResponse{}} | {:error, :get_charging_profiles, String.t()}

  @callback get_composite_schedule(req :: %M.GetCompositeScheduleRequest{})
              :: {:ok, %M.GetCompositeScheduleResponse{}} | {:error, :get_composite_schedule, String.t()}

  @callback get_display_messages(req :: %M.GetDisplayMessagesRequest{})
              :: {:ok, %M.GetDisplayMessagesResponse{}} | {:error, :get_display_messages, String.t()}

  @callback get_installed_certificate_ids(req :: %M.GetInstalledCertificateIdsRequest{})
              :: {:ok, %M.GetInstalledCertificateIdsResponse{}}

  @callback get_local_list_version(req :: %M.GetLocalListVersionRequest{})
              :: {:ok, %M.GetLocalListVersionResponse{}} | {:error, :get_local_list_version, String.t()}

  @callback get_log(req :: %M.GetLogRequest{})
              :: {:ok, %M.GetLogResponse{}} | {:error, :get_log, String.t()}

  @callback get_monitoring_report(req :: %M.GetMonitoringReportRequest{})
              :: {:ok, %M.GetMonitoringReportResponse{}} | {:error, :get_monitoring_report, String.t()}

  @callback get_report(req :: %M.GetReportRequest{})
              :: {:ok, %M.GetReportResponse{}} | {:error, :get_report, String.t()}

  @callback get_transaction_status(req :: %M.GetTransactionStatusRequest{})
              :: {:ok, %M.GetTransactionStatusResponse{}} | {:error, :get_transaction_status, String.t()}

  @callback get_variables(req :: %M.GetVariablesRequest{})
              :: {:ok, %M.GetVariablesResponse{}} | {:error, :get_variables, String.t()}

  @callback install_certificate(req :: %M.InstallCertificateRequest{})
              :: {:ok, %M.InstallCertificateResponse{}} | {:error, :install_certificate, String.t()}

  @callback reset(req :: %M.ResetRequest{})
              :: {:ok, %M.ResetResponse{}} | {:error, :reset, String.t()}

  @callback send_local_list(req :: %M.SendLocalListRequest{})
              :: {:ok, %M.SendLocalListResponse{}} | {:error, :send_local_list, String.t()}

  @callback set_charging_profile(req :: %M.SetChargingProfileRequest{})
              :: {:ok, %M.SetChargingProfileResponse{}} | {:error, :set_charging_profile, String.t()}

  @callback trigger_message(req :: %M.TriggerMessageRequest{})
              :: {:ok, %M.TriggerMessageResponse{}} | {:error, :trigger_message, String.t()}

  @callback unlock_connector(req :: %M.UnlockConnectorRequest{})
  :: {:ok, %M.UnlockConnectorResponse{}} | {:error, :unlock_connector, 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
  """
  def handle(impl, action, payload) when action == "CancelReservation" do
    payload |> OcppModel.to_struct(M.CancelReservationRequest) |> impl.cancel_reservation |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "CertificateSigned" do
    payload |> OcppModel.to_struct(M.CertificateSignedRequest) |> impl.certificate_signed |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "ChangeAvailability" do
    payload |> OcppModel.to_struct(M.ChangeAvailabilityRequest) |> impl.change_availability |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "ClearCache" do
    payload |> OcppModel.to_struct(M.ClearCacheRequest) |> impl.clear_cache |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "ClearChargingProfile" do
    payload |> OcppModel.to_struct(M.ClearChargingProfileRequest) |> impl.clear_charging_profile |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "ClearDisplayMessage" do
    payload |> OcppModel.to_struct(M.ClearDisplayMessageRequest) |> impl.clear_display_message |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "ClearVariableMonitoring" do
    payload |> OcppModel.to_struct(M.ClearVariableMonitoringRequest) |> impl.clear_variable_monitoring
      |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "CostUpdated" do
    payload |> OcppModel.to_struct(M.CostUpdatedRequest) |> impl.cost_updated |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "CustomerInformation" do
    payload |> OcppModel.to_struct(M.CostUpdatedRequest) |> impl.customer_information |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "DeleteCertificate" do
    payload |> OcppModel.to_struct(M.DeleteCertificateRequest) |> impl.delete_certificate |> 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 == "GetBaseReport" do
    payload |> OcppModel.to_struct(M.GetBaseReportRequest) |> impl.get_base_report |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "GetChargingProfiles" do
    payload |> OcppModel.to_struct(M.GetChargingProfilesRequest) |> impl.get_charging_profiles |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "GetCompositeSchedule" do
    payload |> OcppModel.to_struct(M.GetCompositeScheduleRequest) |> impl.get_composite_schedule |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "GetDisplayMessages" do
    payload |> OcppModel.to_struct(M.GetDisplayMessagesRequest) |> impl.get_display_messages |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "GetInstalledCertificateIds" do
    payload |> OcppModel.to_struct(M.GetDisplayMessagesRequest)
      |> impl.get_installed_certificate_ids |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "GetLocalListVersion" do
    payload |> OcppModel.to_struct(M.GetLocalListVersionRequest) |> impl.get_local_list_version |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "GetLog" do
    payload |> OcppModel.to_struct(M.GetLogRequest) |> impl.get_log |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "GetMonitoringReport" do
    payload |> OcppModel.to_struct(M.GetMonitoringReportRequest) |> impl.get_monitoring_report |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "GetReport" do
    payload |> OcppModel.to_struct(M.GetReportRequest) |> impl.get_report |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "GetTransactionStatus" do
    payload |> OcppModel.to_struct(M.GetTransactionStatusRequest) |> impl.get_transaction_status |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "GetVariables" do
    payload |> OcppModel.to_struct(M.GetVariablesRequest) |> impl.get_variables |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "InstallCertificate" do
    payload |> OcppModel.to_struct(M.InstallCertificateRequest) |> impl.install_certificate |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "Reset" do
    payload |> OcppModel.to_struct(M.ResetRequest) |> impl.reset |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "SendLocalList" do
    payload |> OcppModel.to_struct(M.SendLocalListRequest) |> impl.send_local_list |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "SetChargingProfile" do
    payload |> OcppModel.to_struct(M.SetChargingProfileRequest) |> impl.set_charging_profile |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "TriggerMessage" do
    payload |> OcppModel.to_struct(M.TriggerMessageRequest) |> impl.trigger_message |> OcppModel.to_map()
  end

  def handle(impl, action, payload) when action == "UnlockConnector" do
    payload |> OcppModel.to_struct(M.UnlockConnectorRequest) |> impl.unlock_connector |> OcppModel.to_map()
  end

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