#include "tsn-transmission-selection-algo.h"

#include "ns3/log.h"
#include "ns3/nstime.h"
#include "ns3/packet.h"
#include "ns3/random-variable-stream.h"

namespace ns3
{

NS_LOG_COMPONENT_DEFINE("TsnTransmissionSelectionAlgo");

NS_OBJECT_ENSURE_REGISTERED(TsnTransmissionSelectionAlgo);

TypeId
TsnTransmissionSelectionAlgo::GetTypeId()
{
    static TypeId tid =
        TypeId("ns3::TsnTransmissionSelectionAlgo")
            .SetParent<Object>()
            .SetGroupName("Tsn")
            .AddConstructor<TsnTransmissionSelectionAlgo>()
            .AddAttribute("MultidropMode",
                          "Mode for the 10Base-T1S",
                          BooleanValue(false),
                          MakeBooleanAccessor(&TsnTransmissionSelectionAlgo::m_MultidropMode),
                          MakeBooleanChecker())
            .AddAttribute("MinLatencyOverhead",
                          "The minimum latency overhead cause by the CBS hardware implementation",
                          TimeValue(Seconds(0)),
                          MakeTimeAccessor(&TsnTransmissionSelectionAlgo::m_minLatencyOverhead),
                          MakeTimeChecker())
            .AddAttribute("MaxLatencyOverhead",
                          "The maximun latency overhead cause by the CBS hardware implementation",
                          TimeValue(Seconds(0)),
                          MakeTimeAccessor(&TsnTransmissionSelectionAlgo::m_maxLatencyOverhead),
                          MakeTimeChecker());
    return tid;
}



TsnTransmissionSelectionAlgo::TsnTransmissionSelectionAlgo()
{
  NS_LOG_FUNCTION(this);
}

TsnTransmissionSelectionAlgo::~TsnTransmissionSelectionAlgo()
{
    NS_LOG_FUNCTION(this);
}

void
TsnTransmissionSelectionAlgo::SetTsnNetDevice(Ptr<TsnNetDevice> net)
{
    m_net = net;
    ReadyToTransmitCallback = MakeCallback(&TsnNetDevice::CheckForReadyPacket, m_net);
}

void
TsnTransmissionSelectionAlgo::SetQueue(Ptr<Queue<Packet>> queue)
{
  NS_LOG_FUNCTION(this);
  m_queue = queue;
}

bool
TsnTransmissionSelectionAlgo::IsReadyToTransmit()
{
  NS_LOG_FUNCTION(this);
  return true;
}

void
TsnTransmissionSelectionAlgo::TransmitStart(Ptr<Packet> p, Time txTime)
{
  NS_LOG_FUNCTION(this);
}

void
TsnTransmissionSelectionAlgo::TransmitComplete(Ptr<Packet> p)
{
  NS_LOG_FUNCTION(this);
}

void
TsnTransmissionSelectionAlgo::UpdateTransmissionGate(bool IsOpen)
{
  NS_LOG_FUNCTION(this);
  m_transmissionGateIsOpen = IsOpen;
}

Time
TsnTransmissionSelectionAlgo::GetHardwareLatency()
{
  NS_LOG_FUNCTION(this);
  Ptr<UniformRandomVariable> randVar = CreateObject<UniformRandomVariable>();
  return NanoSeconds(randVar->GetValue(m_minLatencyOverhead.GetNanoSeconds(), m_maxLatencyOverhead.GetNanoSeconds()));

}

};