// matth-x/ArduinoOcpp
// Copyright Matthias Akstaller 2019 - 2022
// MIT License

#ifndef ARDUINOOCPP_H
#define ARDUINOOCPP_H

#include <ArduinoJson.h>
#include <memory>
#include <functional>

#include <ArduinoOcpp/Core/ConfigurationOptions.h>
#include <ArduinoOcpp/Core/OcppTime.h>
#include <ArduinoOcpp/Core/OcppOperationCallbacks.h>
#include <ArduinoOcpp/Core/OcppOperationTimeout.h>
#include <ArduinoOcpp/Core/OcppSocket.h>
#include <ArduinoOcpp/Core/PollResult.h>
#include <ArduinoOcpp/Tasks/ChargePointStatus/TransactionPrerequisites.h>
#include <ArduinoOcpp/Tasks/Metering/SampledValue.h>

using ArduinoOcpp::OnReceiveConfListener;
using ArduinoOcpp::OnReceiveReqListener;
using ArduinoOcpp::OnSendConfListener;
using ArduinoOcpp::OnAbortListener;
using ArduinoOcpp::OnTimeoutListener;
using ArduinoOcpp::OnReceiveErrorListener;

using ArduinoOcpp::Timeout;

#ifndef AO_CUSTOM_WS
//uses links2004/WebSockets library
void OCPP_initialize(const char *CS_hostname, uint16_t CS_port, const char *CS_url, float V_eff = 230.f /*German grid*/, ArduinoOcpp::FilesystemOpt fsOpt = ArduinoOcpp::FilesystemOpt::Use_Mount_FormatOnFail, ArduinoOcpp::OcppClock system_time = ArduinoOcpp::Clocks::DEFAULT_CLOCK);
#endif

//Lets you use your own WebSocket implementation
void OCPP_initialize(ArduinoOcpp::OcppSocket& ocppSocket, float V_eff = 230.f /*European grid*/, ArduinoOcpp::FilesystemOpt fsOpt = ArduinoOcpp::FilesystemOpt::Use_Mount_FormatOnFail, ArduinoOcpp::OcppClock system_time = ArduinoOcpp::Clocks::DEFAULT_CLOCK);

//experimental; More testing required (help needed: it would be awesome if you can you publish your evaluation results on the GitHub page)
void OCPP_deinitialize();

void OCPP_loop();

/*
 * Provide hardware-related information to the library
 * 
 * The library needs a way to obtain information from your charger that changes over time. The
 * library calls following callbacks regularily (if they were set) to refresh its internal
 * status.
 * 
 * Set the callbacks once in your setup() function.
 */

void setPowerActiveImportSampler(std::function<float()> power);

void setEnergyActiveImportSampler(std::function<float()> energy);

void addMeterValueSampler(std::unique_ptr<ArduinoOcpp::SampledValueSampler> meterValueSampler);

void setEvRequestsEnergySampler(std::function<bool()> evRequestsEnergy);

void setConnectorEnergizedSampler(std::function<bool()> connectorEnergized);

void setConnectorPluggedSampler(std::function<bool()> connectorPlugged);

//void setConnectorFaultedSampler(std::function<bool()> connectorFailed);

void addConnectorErrorCodeSampler(std::function<const char *()> connectorErrorCode);

/*
 * React on calls by the library's internal functions
 * 
 * The library needs to set parameters on your charger on a regular basis or perform
 * functions triggered by the central system. The library uses the following callbacks
 * (if they were set) to perform updates or functions on your charger.
 * 
 * Set the callbacks once in your setup() function.
 */

void setOnChargingRateLimitChange(std::function<void(float)> chargingRateChanged);

//Set a Cb to mechanically unlock the connector. Called for the OCPP operation "UnlockConnector"
//Return values: true on success, false on failure, PollResult::Await if not known yet
//Continues to call the Cb as long as it returns PollResult::Await
void setOnUnlockConnector(std::function<ArduinoOcpp::PollResult<bool>()> unlockConnector);

//Set a Cb for setting the state of the connector lock. Called in the course of normal transactions
//Return values: - TxEnableState::Active if connector is locked and ready for transaction
//               - TxEnableState::Inactive if connector lock is released
//               - TxEnableState::Pending otherwise, e.g. if transitioning between the states
//Called periodically
void setConnectorLock(std::function<ArduinoOcpp::TxEnableState(ArduinoOcpp::TxCondition)> lockConnector);

//Set a Cb to update transaction-based energy measurements with the most recent transaction state.
//This allows energy meters (e.g. based on OCMF) to take their measruements right before and after a transaction
//Return values: - TxEnableState::Active if the energy meter confirmed to be in the transaction-state
//               - TxEnableState::Inactive if the energy meter has transitioned into a non-transaction-state
//               - TxEnableState::Pending otherwise, e.g. if transitioning between the states
//Called periodically
void setTxBasedMeterUpdate(std::function<ArduinoOcpp::TxEnableState(ArduinoOcpp::TxCondition)> updateTxState);

/*
 * React on CS-initiated operations
 * 
 * You can define custom behaviour in your integration which is executed every time the library
 * receives a CS-initiated operation. The following functions set a callback function for the
 * respective event. The library executes the callbacks always after its internal routines.
 * 
 * Set the callbacks once in your setup() function.
 */

void setOnSetChargingProfileRequest(OnReceiveReqListener onReceiveReq); //optional

void setOnRemoteStartTransactionSendConf(OnSendConfListener onSendConf); //important, energize the power plug here and capture the idTag

void setOnRemoteStopTransactionSendConf(OnSendConfListener onSendConf); //important, de-energize the power plug here
void setOnRemoteStopTransactionReceiveReq(OnReceiveReqListener onReceiveReq); //optional, to de-energize the power plug immediately

void setOnResetSendConf(OnSendConfListener onSendConf); //important, reset your device here (i.e. call ESP.reset();)
void setOnResetReceiveReq(OnReceiveReqListener onReceiveReq); //alternative: start reset timer here

/*
 * Perform CP-initiated operations
 * 
 * Use following functions to send OCPP messages. Each function will adapt the library's
 * internal state appropriatley (e.g. after a successful StartTransaction request the library
 * will store the transactionId and send a StatusNotification).
 * 
 * On receipt of the .conf() response the library calls the callback function
 * "OnReceiveConfListener onConf" and passes the OCPP payload to it. The following functions
 * are non-blocking. Your application code will immediately resume with the subsequent code
 * in any case.
 * 
 * For your first EVSE integration, the `onReceiveConfListener` is probably sufficient. For
 * advanced EVSE projects, the other listeners likely become relevant:
 * - `onAbortListener`: will be called whenever the engine stops trying to finish an operation
 *           normally which was initiated by this device.
 * - `onTimeoutListener`: will be executed when the operation is not answered until the timeout
 *           expires. Note that timeouts also trigger the `onAbortListener`.
 * - `onReceiveErrorListener`: will be called when the Central System returns a CallError.
 *           Again, each error also triggers the `onAbortListener`.
 */

void authorize(const char *idTag, OnReceiveConfListener onConf = nullptr, OnAbortListener onAbort = nullptr, OnTimeoutListener onTimeout = nullptr, OnReceiveErrorListener onError = nullptr, std::unique_ptr<Timeout> timeout = nullptr);

void bootNotification(const char *chargePointModel, const char *chargePointVendor, OnReceiveConfListener onConf = nullptr, OnAbortListener onAbort = nullptr, OnTimeoutListener onTimeout = nullptr, OnReceiveErrorListener onError = nullptr, std::unique_ptr<Timeout> timeout = nullptr);

//The OCPP operation will include the given payload without modifying it. The library will delete the payload object after successful transmission.
void bootNotification(std::unique_ptr<DynamicJsonDocument> payload, OnReceiveConfListener onConf = nullptr, OnAbortListener onAbort = nullptr, OnTimeoutListener onTimeout = nullptr, OnReceiveErrorListener onError = nullptr, std::unique_ptr<Timeout> timeout = nullptr);

void startTransaction(const char *idTag, OnReceiveConfListener onConf = nullptr, OnAbortListener onAbort = nullptr, OnTimeoutListener onTimeout = nullptr, OnReceiveErrorListener onError = nullptr, std::unique_ptr<Timeout> timeout = nullptr);

void stopTransaction(OnReceiveConfListener onConf = nullptr, OnAbortListener onAbort = nullptr, OnTimeoutListener onTimeout = nullptr, OnReceiveErrorListener onError = nullptr, std::unique_ptr<Timeout> timeout = nullptr);

/*
 * Access information about the internal state of the library
 */

int getTransactionId(); //returns the ID of the current transaction. Returns -1 if called before or after an transaction

bool ocppPermitsCharge();

bool isAvailable(); //if the charge point is operative or inoperative

/*
 * Session management
 *
 * A session begins when the EV user is authenticated against the OCPP system and intends to start the charging process.
 * The session ends as soon as the authentication expires or as soon as the EV user does not intend to charge anymore.
 * 
 * A session means that the EVSE does not need further input from the EV user or OCPP backend to start a transaction.
 */

void beginSession(const char *idTag);

void endSession();

bool isInSession();

const char *getSessionIdTag();

/*
 * Configure the device management
 */

#if defined(AO_CUSTOM_UPDATER) || defined(AO_CUSTOM_WS)
#include <ArduinoOcpp/Tasks/FirmwareManagement/FirmwareService.h>
// You need to configure this object if FW updates are relevant for you. This project already
// brings a simple configuration for the ESP32 and ESP8266 for prototyping purposes, however
// for the productive system you will have to develop a configuration targeting the specific
// OCPP backend.
// See  ArduinoOcpp/Tasks/FirmwareManagement/FirmwareService.h 
ArduinoOcpp::FirmwareService *getFirmwareService();
#endif

#if defined(AO_CUSTOM_DIAGNOSTICS) || defined(AO_CUSTOM_WS)
#include <ArduinoOcpp/Tasks/Diagnostics/DiagnosticsService.h>
// This library implements the OCPP messaging side of Diagnostics, but no logging or the
// log upload to your backend.
// To integrate Diagnostics, see ArduinoOcpp/Tasks/Diagnostics/DiagnosticsService.h
ArduinoOcpp::DiagnosticsService *getDiagnosticsService();
#endif

#endif