fsfw/src/fsfw/cfdp/handler/SourceHandler.h

#ifndef FSFW_CFDP_CFDPSOURCEHANDLER_H
#define FSFW_CFDP_CFDPSOURCEHANDLER_H

#include <cstdint>
#include <vector>

#include "UserBase.h"
#include "defs.h"
#include "fsfw/cfdp/Fss.h"
#include "fsfw/cfdp/handler/PutRequest.h"
#include "fsfw/cfdp/handler/mib.h"
#include "fsfw/events/EventReportingProxyIF.h"
#include "fsfw/storagemanager/StorageManagerIF.h"
#include "fsfw/tmtcservices/AcceptsTelemetryIF.h"
#include "fsfw/util/ProvidesSeqCountIF.h"

namespace cfdp {

struct SourceHandlerParams {
  SourceHandlerParams(LocalEntityCfg cfg, UserBase& user, ProvidesSeqCountIF& seqCountProvider)
      : cfg(std::move(cfg)), user(user), seqCountProvider(seqCountProvider) {}

  LocalEntityCfg cfg;
  UserBase& user;
  ProvidesSeqCountIF& seqCountProvider;
};

class SourceHandler {
 public:
  enum class TransactionStep : uint8_t {
    IDLE = 0,
    TRANSACTION_START = 1,
    SENDING_METADATA = 3,
    SENDING_FILE_DATA = 4,
    SENDING_EOF = 5,
    WAIT_FOR_ACK = 6,
    WAIT_FOR_FINISH = 7,
    NOTICE_OF_COMPLETION = 8
  };
  struct FsmResult {
   public:
    ReturnValue_t result = returnvalue::OK;
    CallStatus callStatus = CallStatus::CALL_AFTER_DELAY;
    CfdpState state = CfdpState::IDLE;
    uint32_t packetsSent = 0;
    uint8_t errors = 0;
    std::array<ReturnValue_t, 3> errorCodes = {};
  };

  SourceHandler(SourceHandlerParams params, FsfwParams fsfwParams);

  [[nodiscard]] CfdpState getState() const;
  [[nodiscard]] TransactionStep getStep() const;

  /**
   * Pass a put request to the source handler, which might initiate a CFDP transaction and start
   * the state machine
   * @return
   */
  ReturnValue_t transactionStart(PutRequest& putRequest, RemoteEntityCfg& cfg);
  const FsmResult& stateMachine();

  ReturnValue_t initialize();

 private:
  struct TransactionParams {
    uint32_t crc{};
    std::array<char, UINT8_MAX + 1> sourceName{};
    size_t sourceNameSize = 0;
    std::array<char, UINT8_MAX + 1> destName{};
    size_t destNameSize = 0;
    cfdp::Fss fileSize;
    size_t progress = 0;
    bool closureRequested = false;
    ChecksumType checksumType = ChecksumType::NULL_CHECKSUM;
    RemoteEntityCfg remoteCfg;
    PduConfig pduConf;
    cfdp::TransactionId id{};

    void reset() {
      sourceNameSize = 0;
      destNameSize = 0;
      fileSize.setFileSize(0, false);
      progress = 0;
      closureRequested = false;
    }
  } transactionParams;

  cfdp::CfdpState state = cfdp::CfdpState::IDLE;
  TransactionStep step = TransactionStep::IDLE;
  std::array<uint8_t, 4096> fileBuf{};
  SourceHandlerParams sourceParams;
  cfdp::FsfwParams fsfwParams;
  FsmResult fsmResult;

  FsmResult& fsmNacked();
  ReturnValue_t checksumGeneration();
  ReturnValue_t prepareAndSendMetadataPdu();
  ReturnValue_t prepareAndSendNextFileDataPdu(bool& noFileDataPdu);
  ReturnValue_t prepareAndSendEofPdu();
  ReturnValue_t noticeOfCompletion();
  ReturnValue_t reset();

  [[nodiscard]] ReturnValue_t sendGenericPdu(const SerializeIF& pdu);
  void addError(ReturnValue_t error);
};

}  // namespace cfdp

#endif  // FSFW_CFDP_CFDPSOURCEHANDLER_H