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

#include <ArduinoOcpp/Core/OcppEngine.h>
#include <ArduinoOcpp/SimpleOcppOperationFactory.h>

#include <ArduinoOcpp/Core/OcppSocket.h>
#include <ArduinoOcpp/Core/OcppConnection.h>

#include <ArduinoOcpp/Core/OcppError.h>

#include <Variants.h>

namespace ArduinoOcpp {
namespace OcppEngine {

OcppSocket *ocppSocket;
SmartChargingService *ocppEngine_smartChargingService;
ChargePointStatusService *ocppEngine_chargePointStatusService;
MeteringService *ocppEngine_meteringService;
OcppTime *ocppEngine_ocppTime;

std::vector<OcppOperation*> initiatedOcppOperations;
std::vector<OcppOperation*> receivedOcppOperations;

int JSON_DOC_SIZE;

#define HEAP_GUARD 2000UL //will not accept JSON messages if it will result in less than HEAP_GUARD free bytes in heap

//size_t removePayload(const char *src, size_t src_size, char *dst, size_t dst_size);

OcppSocket *ocppSock;
OcppConnection *mConnection;

} //end namespace OcppEngine

using namespace ArduinoOcpp::OcppEngine;

void ocppEngine_initialize(OcppSocket *ocppSocket){
  ocppSock = ocppSocket;
  mConnection = new OcppConnection(ocppSock);
}

void initiateOcppOperation(OcppOperation *o) {
  mConnection->initiateOcppOperation(o);
}

void ocppEngine_loop() {
  ocppSock->loop();
  mConnection->loop();
}

#if 0
/**
 * Process raw application data coming from the websocket stream
 */
bool processWebSocketEvent(const char* payload, size_t length){

  boolean deserializationSuccess = false;

  DynamicJsonDocument *doc = NULL;
  size_t capacity = length + 100;

  DeserializationError err = DeserializationError::NoMemory;
  while (capacity + HEAP_GUARD < ESP.getFreeHeap() && err == DeserializationError::NoMemory) {
      if (doc){
          delete doc;
          doc = NULL;
      }
      doc = new DynamicJsonDocument(capacity);
      err = deserializeJson(*doc, payload, length);

      capacity /= 2;
      capacity *= 3;
  }

  //TODO insert validateRpcHeader at suitable position

  switch (err.code()) {
    case DeserializationError::Ok:
        if (doc != NULL){
          int messageTypeId = (*doc)[0];
          switch(messageTypeId) {
            case MESSAGE_TYPE_CALL:
              handleReqMessage(doc);      
              deserializationSuccess = true;
              break;
            case MESSAGE_TYPE_CALLRESULT:
              handleConfMessage(doc);
              deserializationSuccess = true;
              break;
            case MESSAGE_TYPE_CALLERROR:
              handleErrMessage(doc);
              deserializationSuccess = true;
              break;
            default:
              Serial.print(F("[OcppEngine] Invalid OCPP message! (though JSON has successfully been deserialized)\n"));
              break;
          }
        } else { //unlikely corner case
            Serial.print(F("[OcppEngine] Deserialization is okay but doc is Null\n"));
        }
        break;
    case DeserializationError::InvalidInput:
        Serial.print(F("[OcppEngine] Invalid input! Not a JSON\n"));
        break;
    case DeserializationError::NoMemory:
        {
          if (DEBUG_OUT) Serial.print(F("[OcppEngine] Error: Not enough memory in heap! Input length = "));
          if (DEBUG_OUT) Serial.print(length);
          if (DEBUG_OUT) Serial.print(F(", free heap = "));
          if (DEBUG_OUT) Serial.println(ESP.getFreeHeap());

          /*
          * If websocket input is of message type MESSAGE_TYPE_CALL, send back a message of type MESSAGE_TYPE_CALLERROR.
          * Then the communication counterpart knows that this operation failed.
          * If the input type is MESSAGE_TYPE_CALLRESULT, it can be ignored. This controller will automatically resend the corresponding requirement message.
          */

          if (doc){
              delete doc;
              doc = NULL;
          }

          doc = new DynamicJsonDocument(200);
          char onlyRpcHeader[200];
          size_t onlyRpcHeader_len = removePayload(payload, length, onlyRpcHeader, 200);
          DeserializationError err2 = deserializeJson(*doc, onlyRpcHeader, onlyRpcHeader_len);
          if (err2.code() == DeserializationError::Ok) {
            int messageTypeId2 = (*doc)[0] | -1;
            if (messageTypeId2 == MESSAGE_TYPE_CALL) {
              deserializationSuccess = true;
              OcppOperation *op = makeOcppOperation(wsocket, new OutOfMemory(ESP.getFreeHeap(), length));
              handleReqMessage(doc, op);
            }
          }
        }
        break;
    default:
        Serial.print(F("[OcppEngine] Deserialization failed: "));
        Serial.println(err.c_str());
        break;
  }

  if (doc) {
    delete doc;
  }

  return deserializationSuccess;
}

/**
 * Send back error code
 */
boolean processWebSocketUnsupportedEvent(const char* payload, size_t length){
  bool deserializationSuccess = false;
  DynamicJsonDocument *doc = new DynamicJsonDocument(200);
  char onlyRpcHeader[200];
  size_t onlyRpcHeader_len = removePayload(payload, length, onlyRpcHeader, 200);
  DeserializationError err = deserializeJson(*doc, onlyRpcHeader, onlyRpcHeader_len);
  if (err.code() == DeserializationError::Ok) {
    int messageTypeId = (*doc)[0];
    if (messageTypeId == MESSAGE_TYPE_CALL) {
      deserializationSuccess = true;
      OcppOperation *op = makeOcppOperation(wsocket, new WebSocketError("This controller does not support WebSocket fragments"));
      handleReqMessage(doc, op);
    }
  } else {
    Serial.print(F("[OcppEngine] Deserialization of unsupported WebSocket event failed: "));
    Serial.println(err.c_str());
  }

  if (doc) delete doc;
  return deserializationSuccess;
}

void handleReqMessage(JsonDocument *json){
  OcppOperation *req = makeFromJson(wsocket, json);
  if (req == NULL) {
    Serial.print(F("[OcppEngine] Couldn't make OppOperation from Request. Ignore request.\n"));
    return;
  }
  handleReqMessage(json, req);
}

void handleReqMessage(JsonDocument *json, OcppOperation *req) {
  if (req == NULL) {
    Serial.print(F("[OcppEngine] handleReqMessage: invalid argument\n"));
    return;
  }
  receivedOcppOperations.push_back(req);; //enqueue so loop() plans conf sending
  req->receiveReq(json); //"fire" the operation
}

/**
   * call conf() on each element of the queue. Start with first element. On successful message delivery,
   * delete the element from the list. Try all the pending OCPP Operations until the right one is found.
   * 
   * This function could result in improper behavior in Charging Stations, because messages are not
   * guaranteed to be received and therefore processed in the right order.
   */
void handleConfMessage(JsonDocument *json){
  #if 0
  for (int i = 0; i < initiatedOcppOperations.size(); i++){
    OcppOperation *el = initiatedOcppOperations.at(i);
    boolean success = el->receiveConf(json); //maybe rename to "consumed"?
    if (success){
      initiatedOcppOperations.(i);
      
      //TODO Review: are all recources freed here?
      delete el;
      return;
    }
  }
  #endif

  for (auto operation = initiatedOcppOperations.begin(); operation != initiatedOcppOperations.end(); ++operation) {
    boolean success = (*operation)->receiveConf(json); //maybe rename to "consumed"?
    if (success) {
      delete *operation;
      initiatedOcppOperations.erase(operation);
      return;
    }
  }

  //didn't find matching OcppOperation
  Serial.print(F("[OcppEngine] Received CALLRESULT doesn't match any pending operation!\n"));
}


void handleErrMessage(JsonDocument *json){
  #if 0
  for (int i = 0; i < initiatedOcppOperations.size(); i++){
    OcppOperation *el = initiatedOcppOperations.get(i);
    boolean discardOperation = el->receiveError(json); //maybe rename to "consumed"?
    if (discardOperation){
      initiatedOcppOperations.remove(i);
      
      //TODO Review: are all recources freed here?
      delete el;
      return;
    }
  }
  #endif

  for (auto operation = initiatedOcppOperations.begin(); operation != initiatedOcppOperations.end(); ++operation){
    boolean discardOperation = (*operation)->receiveError(json); //maybe rename to "consumed"?
    if (discardOperation){
      //TODO Review: are all recources freed here?
      delete *operation;
      initiatedOcppOperations.erase(operation);
      return;
    }
  }

  //No OcppOperation was aborted because of the error message
  if (DEBUG_OUT) Serial.print(F("[OcppEngine] Received CALLERROR did not abort a pending operation\n"));
}


void initiateOcppOperation(OcppOperation *o){
  if (!o->isFullyConfigured()){
    Serial.printf("[OcppEngine] initiateOcppOperation(op) was called without the operation being configured and ready to send. Discard operation!\n");
    delete o;
    return;
  }
  initiatedOcppOperations.push_back(o);
}

void ocppEngine_loop(){

  /**
   * Work through the initiatedOcppOperations queue. Start with the first element by calling req() on it. If
   * the operation is (still) pending, it will return false and therefore each other queued element must
   * wait until this operation is over. If an ocppOperation is finished, it returns true on a req() call, 
   * can be dequeued and the following ocppOperation is processed.
   */
  
  #if 0
  while (initiatedOcppOperations.size() > 0){
    OcppOperation *el = initiatedOcppOperations.get(0);
    boolean timeout = el->sendReq(); //The only reason to dequeue elements here is when a timeout occurs. Normally
    if (timeout){                    //the Conf msg processing routine dequeues finished elements
      initiatedOcppOperations.remove(0);
      
      //TODO Review: are all recources freed here?
      delete el;
      //go on with the next element in the queue, which is now at initiatedOcppOperations[0]
    } else {
      //there is one operation pending right now, so quit this while-loop.
      break;
    }
  }
  #endif

  auto operation = initiatedOcppOperations.begin();
  while (operation != initiatedOcppOperations.end()){
    boolean timeout = (*operation)->sendReq(); //The only reason to dequeue elements here is when a timeout occurs. Normally
    if (timeout){                              //the Conf msg processing routine dequeues finished elements
      delete *operation;
      operation = initiatedOcppOperations.erase(operation);
      
      //TODO Review: are all recources freed here?
      //go on with the next element in the queue, which is now at initiatedOcppOperations[0]
    } else {
      //there is one operation pending right now, so quit this while-loop.
      break;
    }
  }

  /*
   * Activate timeout detection on the msgs other than the first in the queue.
   */

  #if 0
  for (int i = 1; i < initiatedOcppOperations.size(); i++) {
    Timeout *timer = initiatedOcppOperations.get(i)->getTimeout();
    if (timer)
      timer->tick(false); //false: did not send a frame prior to calling tick
      if (timer->isExceeded()) {
        Serial.print(F("[OcppEngine] Discarding operation due to timeout: "));
        initiatedOcppOperations.get(i)->print_debug();
        initiatedOcppOperations.remove(i);
        delete initiatedOcppOperations.get(i);
      }
  }
  #endif

  operation = initiatedOcppOperations.begin();
  while (operation != initiatedOcppOperations.end()) {
    if (operation == initiatedOcppOperations.begin()){ //jump over the first element
      ++operation; 
      continue; 
    } 
    Timeout *timer = (*operation)->getTimeout();
    if (!timer) {
      ++operation; //no timeouts, nothing to do in this iteration
      continue;
    }
    timer->tick(false); //false: did not send a frame prior to calling tick
    if (timer->isExceeded()) {
      Serial.print(F("[OcppEngine] Discarding operation due to timeout: "));
      (*operation)->print_debug();
      delete *operation;
      operation = initiatedOcppOperations.erase(operation);
    } else {
      ++operation;
    }
  }
  
  /**
   * Work through the receivedOcppOperations queue. Start with the first element by calling conf() on it. 
   * If an ocppOperation is finished, it returns true on a conf() call, and is dequeued.
   */
  
  #if 0
  int i = 0;
  while (i < receivedOcppOperations.size()){
    OcppOperation *el = receivedOcppOperations.get(i);
    boolean success = el->sendConf();
    if (success){
      receivedOcppOperations.remove(i);

      //TODO Review: are all recources freed here?
      delete el;
      //go on with the next element in the queue, which is now at receivedOcppOperations[i]
    } else {
      //There will be another attempt to send this conf message in a future loop call.
      //Go on with the next element in the queue, which is now at receivedOcppOperations[i+1]
      i++;
    }
  }
  #endif

  operation = receivedOcppOperations.begin();
  while (operation != receivedOcppOperations.end()){
    boolean success = (*operation)->sendConf();
    if (success){
      delete *operation;
      operation = receivedOcppOperations.erase(operation);

      //TODO Review: are all recources freed here?
      //go on with the next element in the queue, which is now at receivedOcppOperations[i]
    } else {
      //There will be another attempt to send this conf message in a future loop call.
      //Go on with the next element in the queue, which is now at receivedOcppOperations[i+1]
      ++operation; //TODO review: this makes conf's out-of-order. But if the first Op fails because of lacking RAM, this could save the device. 
    }
  }

  
}

#endif

void setSmartChargingService(SmartChargingService *scs) {
  ocppEngine_smartChargingService = scs;
}

SmartChargingService* getSmartChargingService(){
  if (ocppEngine_smartChargingService == NULL) {
    Serial.print(F("[OcppEngine] Error: in OcppEngine, there is no smartChargingService set, but it is accessed!\n"));
    //no error catch 
  }
  return ocppEngine_smartChargingService;
}

void setChargePointStatusService(ChargePointStatusService *cpss){
  ocppEngine_chargePointStatusService = cpss;
}

ChargePointStatusService *getChargePointStatusService(){
  if (ocppEngine_chargePointStatusService == NULL) {
    Serial.print(F("[OcppEngine] Error: in OcppEngine, there is no chargePointStatusService set, but it is accessed!\n"));
    //no error catch 
  }
  return ocppEngine_chargePointStatusService;
}

ConnectorStatus *getConnectorStatus(int connectorId) {
  if (getChargePointStatusService() == NULL) return NULL;

  ConnectorStatus *result = getChargePointStatusService()->getConnector(connectorId);
  if (result == NULL) {
    Serial.print(F("[OcppEngine] Error in getConnectorStatus(): cannot fetch connector with given connectorId!\n"));
    //no error catch 
  }
  return result;
}

void setMeteringSerivce(MeteringService *meteringService) {
ocppEngine_meteringService = meteringService;
}

MeteringService* getMeteringService() {
  if (ocppEngine_meteringService == NULL) {
    Serial.print(F("[OcppEngine] Error: in OcppEngine, there is no ocppEngine_meteringService set, but it is accessed!\n"));
    //no error catch 
  }
  return ocppEngine_meteringService;
}

void ocppEngine_setOcppTime(OcppTime *ocppTime) {
    ocppEngine_ocppTime = ocppTime;
}

OcppTime *getOcppTime() {
    if (ocppEngine_ocppTime == NULL) {
        Serial.print(F("[OcppEngine] Error: in OcppEngine, there is no ocppEngine_ocppTime set, but it is accessed!\n"));
        //no error catch 
    }
    return ocppEngine_ocppTime;
}


#if 0 //moved to OcppConnection
/*
 * Tries to recover the Ocpp-Operation header from a broken message.
 * 
 * Example input: 
 * [2, "75705e50-682d-404e-b400-1bca33d41e19", "ChangeConfiguration", {"key":"now the msg breaks...
 * 
 * The Json library returns an error code when trying to deserialize that broken message. This
 * function searches for the first occurence of the character '{' and writes "}]" after it.
 * 
 * Example output:
 * [2, "75705e50-682d-404e-b400-1bca33d41e19", "ChangeConfiguration", {}]
 *
 */
size_t removePayload(const char *src, size_t src_size, char *dst, size_t dst_size) {
    size_t res_len = 0;
    for (size_t i = 0; i < src_size && i < dst_size-3; i++) {
        if (src[i] == '\0'){
            //no payload found within specified range. Cancel execution
            break;
        }
        dst[i] = src[i];
        if (src[i] == '{') {
            dst[i+1] = '}';
            dst[i+2] = ']';
            res_len = i+3;
            break;
        }
    }
    dst[res_len] = '\0';
    res_len++;
    return res_len;
}

#endif
} //end namespace ArduinoOcpp