#ifndef TSN_NODE_H
#define TSN_NODE_H

#include "ns3/node.h"

#include "ns3/traced-callback.h"

#include "ns3/clock.h"
#include "ns3/tsn-net-device.h"
#include "ns3/switch-net-device.h"

#include "stream-identity-entry.h"
#include "stream-identification-function.h"
#include "frer-sequence-generation-function.h"
#include "frer-sequence-encode-decode-function.h"
#include "frer-sequence-recovery-function.h"
#include "psfp-stream-filter-instance.h"
#include "psfp-flow-meter-instance.h"


namespace ns3
{

class TsnNetDevice;
class TsnAggregatedNetDevice;
class TsnMultidropNetDevice;
class SwitchNetDevice;
class StreamIdEntry;
class SequenceGenerationFunction;
class SequenceEncodeDecodeFunction;
class SequenceRecoveryFunction;
  /**
   * \ingroup tsn
   *
   * \brief A network tsn Node.
   *
   * It add clocks to the ns3 vanilla Node
   */
class TsnNode: public Node
{
  public:
    /**
     * \brief Get the TypeId
     *
     * \return The TypeId for this class
     */
    static TypeId GetTypeId();

    /**
     * \brief Create a TsnNode
     */
    TsnNode();

    /**
     * \param systemId a unique integer used for parallel simulations.
     */
    TsnNode(uint32_t systemId);

    uint32_t AddDevice(Ptr<TsnNetDevice> device);
    uint32_t AddDevice(Ptr<TsnAggregatedNetDevice> device);
    uint32_t AddDevice(Ptr<TsnMultidropNetDevice> device);
    uint32_t AddDevice(Ptr<SwitchNetDevice> device);

    Ptr<Clock> GetActiveClock();
    Time GetTime() const;
    Time GetTime(uint32_t clockId) const;


    /**
     * Destroy a TsnNode
     *
     * This is the destructor for the TsnNode.
     */
    ~TsnNode();

    // Delete copy constructor and assignment operator to avoid misuse
    TsnNode& operator=(const TsnNode&) = delete;
    TsnNode(const TsnNode&) = delete;

    void SetMainClock(Ptr<Clock> clock);
    void AddClock(Ptr<Clock> clock);
    void setActiveClock(uint32_t activeClockId);

    //Stream identification
    void AddStreamIdentificationFunction(
      uint32_t streamHandle,
      Ptr<StreamIdentificationFunction> streamIdentificationFunction,
      std::vector<Ptr<TsnNetDevice>> outFacInputPortList,
      std::vector<Ptr<TsnNetDevice>> inFacInputPortList,
      std::vector<Ptr<TsnNetDevice>> inFacOutputPortList,
      std::vector<Ptr<TsnNetDevice>> outFacOutputPortList);
    std::vector<Ptr<StreamIdEntry>> GetStreamIdentityTable();

    //FRER
    void AddSequenceGenerationFunction(Ptr<SequenceGenerationFunction> entry);
    std::vector<Ptr<SequenceGenerationFunction>> GetSequenceGenerationTable();

    void AddSequenceRecoveryFunction(Ptr<SequenceRecoveryFunction> entry);
    std::vector<Ptr<SequenceRecoveryFunction>> GetSequenceRecoveryTable();

    void AddSequenceEncodeDecodeFunction(Ptr<SequenceEncodeDecodeFunction> entry);
    std::vector<Ptr<SequenceEncodeDecodeFunction>> GetSequenceEncodeDecodeTable();

    //PSFP
    void AddStreamFilter(Ptr<StreamFilterInstance> streamFilterInstance);
    uint16_t AddFlowMeter(Ptr<FlowMeterInstance> flowMeterInstance);
    std::vector<Ptr<StreamFilterInstance>> GetStreamFilterInstanceTable();
    std::vector<Ptr<FlowMeterInstance>> GetFlowMeterInstanceTable();

    void CallBackClockUpdate();

  protected:

  private:
    Ptr<Clock> m_mainClock = nullptr;
    uint32_t m_activeClockId = 0;
    /**
    * The Clocks which this TsnNode uses
    */
    std::vector<Ptr<Clock>> m_clocks;

    //StreamIdenty
    uint16_t m_maxSidEntryNumber;
    std::vector<Ptr<StreamIdEntry>> m_streamIdentityTable;

    //FRER
    uint16_t m_maxFrerSeqGenEntryNumber;
    uint16_t m_maxFrerSeqRcvyEntryNumber;
    uint16_t m_maxFrerSeqEncEntryNumber;
    std::vector<Ptr<SequenceGenerationFunction>> m_frerSeqGenTable;
    std::vector<Ptr<SequenceRecoveryFunction>> m_frerSeqRcvyTable;
    std::vector<Ptr<SequenceEncodeDecodeFunction>> m_frerSeqEncTable;
    // std::vector<Ptr<frerSplitEntry>> m_frerSplitTable;


    //PSFP
    uint16_t m_maxPsfpFilterEntryNumber;
    uint16_t m_maxPsfpStreamGateEntryNumber;
    uint16_t m_maxPsfpFlowMeterEntryNumber;
    std::vector<Ptr<StreamFilterInstance>> m_streamFilterInstanceTable;
    // std::vector<Ptr<StreamGateInstance>> m_streamGateInstanceTable;
    std::vector<Ptr<FlowMeterInstance>> m_flowMeterInstanceTable;




};

}
#endif /* TSN_NODE_H */