// matth-x/ArduinoOcpp

// Copyright Matthias Akstaller 2019 - 2022

// MIT License

#include <ArduinoOcpp/Core/OcppOperation.h>

#include <ArduinoOcpp/Core/OcppMessage.h>

#include <ArduinoOcpp/Core/OcppModel.h>

#include <ArduinoOcpp/Core/OcppSocket.h>

#include <ArduinoOcpp/Platform.h>

#include <ArduinoOcpp/Debug.h>

int unique_id_counter = 1000000;

using namespace ArduinoOcpp;

OcppOperation::OcppOperation(std::unique_ptr<OcppMessage> msg) : ocppMessage(std::move(msg)) {

}

OcppOperation::OcppOperation() {

}

OcppOperation::~OcppOperation(){

}

void OcppOperation::setOcppMessage(std::unique_ptr<OcppMessage> msg){

ocppMessage = std::move(msg);

}

void OcppOperation::setOcppModel(std::shared_ptr<OcppModel> oModel) {

if (!ocppMessage) {

AO_DBG_ERR("Must be called after setOcppMessage(). Abort");

return;

}

if (!oModel) {

AO_DBG_ERR("Passed nullptr. Ignore");

return;

}

ocppMessage->setOcppModel(oModel);

}

void OcppOperation::setTimeout(std::unique_ptr<Timeout> to){

if (!to){

AO_DBG_ERR("Passed nullptr! Ignore");

return;

}

timeout = std::move(to);

timeout->setOnTimeoutListener(onTimeoutListener);

timeout->setOnAbortListener(onAbortListener);

}

Timeout *OcppOperation::getTimeout() {

return timeout.get();

}

void OcppOperation::setMessageID(const std::string &id){

if (!messageID.empty()){

AO_DBG_WARN("MessageID is set twice or is set after first usage!");

}

messageID = id;

}

const std::string *OcppOperation::getMessageID() {

if (messageID.empty()) {

char id_str [16] = {'\0'};

sprintf(id_str, "%d", unique_id_counter++);

messageID = std::string {id_str};

//messageID = std::to_string(unique_id_counter++);

}

return &messageID;

}

boolean OcppOperation::sendReq(OcppSocket& ocppSocket){

/*

* timeout behaviour

*

* if timeout, print out error message and treat this operation as completed (-> return true)

*/

if (timeout->isExceeded()) {

//cancel this operation

AO_DBG_INFO("%s has timed out! Discard operation", ocppMessage->getOcppOperationType());

return true;

}

/*

* retry behaviour

*

* if retry, run the rest of this function, i.e. resend the message. If not, just return false

*/

if (ao_tick_ms() <= retry_start + RETRY_INTERVAL * retry_interval_mult) {

//NO retry

return false;

}

// Do retry. Increase timer by factor 2

if (RETRY_INTERVAL * retry_interval_mult * 2 <= RETRY_INTERVAL_MAX)

retry_interval_mult *= 2;

/*

* Create the OCPP message

*/

auto requestPayload = ocppMessage->createReq();

if (!requestPayload) {

onAbortListener();

return true;

}

/*

* Create OCPP-J Remote Procedure Call header

*/

size_t json_buffsize = JSON_ARRAY_SIZE(4) + (getMessageID()->length() + 1) + requestPayload->capacity();

DynamicJsonDocument requestJson(json_buffsize);

requestJson.add(MESSAGE_TYPE_CALL); //MessageType

requestJson.add(*getMessageID()); //Unique message ID

requestJson.add(ocppMessage->getOcppOperationType()); //Action

requestJson.add(*requestPayload); //Payload

/*

* Serialize and send. Destroy serialization and JSON object.

*

* If sending was successful, start timer

*

* Return that this function must be called again (-> false)

*/

std::string out {};

serializeJson(requestJson, out);

if (printReqCounter > 5000) {

printReqCounter = 0;

AO_DBG_DEBUG("Try to send request: %s", out.c_str());

}

printReqCounter++;

bool success = ocppSocket.sendTXT(out);

timeout->tick(success);

if (success) {

AO_DBG_TRAFFIC_OUT(out.c_str());

retry_start = ao_tick_ms();

} else {

//ocppSocket is not able to put any data on TCP stack. Maybe because we're offline

retry_start = 0;

retry_interval_mult = 1;

}

return false;

}

boolean OcppOperation::receiveConf(JsonDocument& confJson){

/*

* check if messageIDs match. If yes, continue with this function. If not, return false for message not consumed

*/

if (*getMessageID() != confJson[1].as<std::string>()){

return false;

}

/*

* Hand the payload over to the OcppMessage object

*/

JsonObject payload = confJson[2];

ocppMessage->processConf(payload);

/*

* Hand the payload over to the onReceiveConf Callback

*/

onReceiveConfListener(payload);

/*

* return true as this message has been consumed

*/

return true;

}

boolean OcppOperation::receiveError(JsonDocument& confJson){

/*

* check if messageIDs match. If yes, continue with this function. If not, return false for message not consumed

*/

if (*getMessageID() != confJson[1].as<std::string>()){

return false;

}

/*

* Hand the error over to the OcppMessage object

*/

const char *errorCode = confJson[2];

const char *errorDescription = confJson[3];

JsonObject errorDetails = confJson[4];

bool abortOperation = ocppMessage->processErr(errorCode, errorDescription, errorDetails);

if (abortOperation) {

onReceiveErrorListener(errorCode, errorDescription, errorDetails);

onAbortListener();

} else {

//restart operation

timeout->restart();

retry_start = 0;

retry_interval_mult = 1;

}

return abortOperation;

}

boolean OcppOperation::receiveReq(JsonDocument& reqJson){

std::string reqId = reqJson[1];

setMessageID(reqId);

//TODO What if client receives requests two times? Can happen if previous conf is lost. In the Smart Charging Profile

// it probably doesn't matter to repeat an operation on the EVSE. Change in future?

/*

* Hand the payload over to the OcppOperation object

*/

JsonObject payload = reqJson[3];

ocppMessage->processReq(payload);

/*

* Hand the payload over to the first Callback. It is a callback that notifies the client that request has been processed in the OCPP-library

*/

onReceiveReqListener(payload);

reqExecuted = true; //ensure that the conf is only sent after the req has been executed

return true; //true because everything was successful. If there will be an error check in future, this value becomes more reasonable

}

boolean OcppOperation::sendConf(OcppSocket& ocppSocket){

if (!reqExecuted) {

//wait until req has been executed

return false;

}

/*

* Create the OCPP message

*/

std::unique_ptr<DynamicJsonDocument> confJson = nullptr;

std::unique_ptr<DynamicJsonDocument> confPayload = std::unique_ptr<DynamicJsonDocument>(ocppMessage->createConf());

std::unique_ptr<DynamicJsonDocument> errorDetails = nullptr;

bool operationSuccess = ocppMessage->getErrorCode() == nullptr && confPayload != nullptr;

if (operationSuccess) {

/*

* Create OCPP-J Remote Procedure Call header

*/

size_t json_buffsize = JSON_ARRAY_SIZE(3) + (getMessageID()->length() + 1) + confPayload->capacity();

confJson = std::unique_ptr<DynamicJsonDocument>(new DynamicJsonDocument(json_buffsize));

confJson->add(MESSAGE_TYPE_CALLRESULT); //MessageType

confJson->add(*getMessageID()); //Unique message ID

confJson->add(*confPayload); //Payload

} else {

//operation failure. Send error message instead

const char *errorCode = ocppMessage->getErrorCode();

const char *errorDescription = ocppMessage->getErrorDescription();

errorDetails = std::unique_ptr<DynamicJsonDocument>(ocppMessage->getErrorDetails());

if (!errorCode) { //catch corner case when payload is null but errorCode is not set too!

errorCode = "GenericError";

errorDescription = "Could not create payload (createConf() returns Null)";

errorDetails = std::unique_ptr<DynamicJsonDocument>(createEmptyDocument());

}

/*

* Create OCPP-J Remote Procedure Call header

*/

size_t json_buffsize = JSON_ARRAY_SIZE(5)

+ (getMessageID()->length() + 1)

+ strlen(errorCode) + 1

+ strlen(errorDescription) + 1

+ errorDetails->capacity();

confJson = std::unique_ptr<DynamicJsonDocument>(new DynamicJsonDocument(json_buffsize));

confJson->add(MESSAGE_TYPE_CALLERROR); //MessageType

confJson->add(*getMessageID()); //Unique message ID

confJson->add(errorCode);

confJson->add(errorDescription);

confJson->add(*errorDetails); //Error description

}

/*

* Serialize and send. Destroy serialization and JSON object.

*/

std::string out {};

serializeJson(*confJson, out);

boolean wsSuccess = ocppSocket.sendTXT(out);

if (wsSuccess) {

if (operationSuccess) {

AO_DBG_TRAFFIC_OUT(out.c_str());

onSendConfListener(confPayload->as<JsonObject>());

} else {

AO_DBG_WARN("Operation failed. JSON CallError message: %s", out.c_str());

onAbortListener();

}

}

return wsSuccess;

}

void OcppOperation::setInitiated() {

if (ocppMessage) {

ocppMessage->initiate();

} else {

AO_DBG_ERR("Missing ocppMessage instance");

}

}

void OcppOperation::setOnReceiveConfListener(OnReceiveConfListener onReceiveConf){

if (onReceiveConf)

onReceiveConfListener = onReceiveConf;

}

/**

* Sets a Listener that is called after this machine processed a request by the communication counterpart

*/

void OcppOperation::setOnReceiveReqListener(OnReceiveReqListener onReceiveReq){

if (onReceiveReq)

onReceiveReqListener = onReceiveReq;

}

void OcppOperation::setOnSendConfListener(OnSendConfListener onSendConf){

if (onSendConf)

onSendConfListener = onSendConf;

}

void OcppOperation::setOnTimeoutListener(OnTimeoutListener onTimeout) {

if (onTimeout)

onTimeoutListener = onTimeout;

}

void OcppOperation::setOnReceiveErrorListener(OnReceiveErrorListener onReceiveError) {

if (onReceiveError)

onReceiveErrorListener = onReceiveError;

}

void OcppOperation::setOnAbortListener(OnAbortListener onAbort) {

if (onAbort)

onAbortListener = onAbort;

}

boolean OcppOperation::isFullyConfigured(){

return ocppMessage != nullptr;

}

void OcppOperation::print_debug() {

if (ocppMessage) {

AO_CONSOLE_PRINTF("OcppOperation of type %s\n", ocppMessage->getOcppOperationType());

} else {

AO_CONSOLE_PRINTF("OcppOperation (no type)\n");

}

}