class NetworkInterface
{
private:
  class ArpTableEntry
  {
  public:
    // The time ticks
    uint64_t time_ticks_;
    EthernetAddress ethernet_address_;
  };

  class ArpWaitingEntry
  {
  public:
    uint64_t time_ticks_;
    std::shared_ptr<EthernetFrame> frame_;
  };

  // Ethernet (known as hardware, network-access, or link-layer) address of the interface
  EthernetAddress ethernet_address_;

  // IP (known as Internet-layer or network-layer) address of the interface
  Address ip_address_;

  // The ARP table maps IP addresses to Ethernet addresses
  std::unordered_map<uint32_t, ArpTableEntry> arp_table_;

  // The ARP queue maps IP addresses to a queue of Ethernet frames awaiting resolution of the
  // corresponding Ethernet address
  std::unordered_map<uint32_t, std::queue<std::shared_ptr<EthernetFrame>>> waiting_for_arp_queue_;

  std::unordered_map<uint32_t, std::shared_ptr<ArpWaitingEntry>> waiting_for_ack_arp_;

  // The Ethernet queue is a queue of Ethernet frames awaiting transmission
  std::queue<std::shared_ptr<EthernetFrame>> ethernet_queue_;

  // The time ticks for ARP
  uint64_t arp_entry_timeout_ = 30000;

  uint64_t arp_request_timeout_ = 5000;

  void check_arp_send_frame( EthernetAddress& ethernet_address, uint32_t& ip_address );

public:
  // Construct a network interface with given Ethernet (network-access-layer) and IP (internet-layer)
  // addresses
  NetworkInterface( const EthernetAddress& ethernet_address, const Address& ip_address );

  // Access queue of Ethernet frames awaiting transmission
  std::optional<EthernetFrame> maybe_send();

  // Sends an IPv4 datagram, encapsulated in an Ethernet frame (if it knows the Ethernet destination
  // address). Will need to use [ARP](\ref rfc::rfc826) to look up the Ethernet destination address
  // for the next hop.
  // ("Sending" is accomplished by making sure maybe_send() will release the frame when next called,
  // but please consider the frame sent as soon as it is generated.)
  void send_datagram( const InternetDatagram& dgram, const Address& next_hop );

  // Receives an Ethernet frame and responds appropriately.
  // If type is IPv4, returns the datagram.
  // If type is ARP request, learn a mapping from the "sender" fields, and send an ARP reply.
  // If type is ARP reply, learn a mapping from the "sender" fields.
  std::optional<InternetDatagram> recv_frame( const EthernetFrame& frame );

  // Called periodically when time elapses
  void tick( size_t ms_since_last_tick );
};