#ifndef RS232NET_HH

#define RS232NET_HH

#include "RS232Device.hh"

#include "BooleanSetting.hh"

#include "EventListener.hh"

#include "Socket.hh"

#include "StringSetting.hh"

#include "Poller.hh"

#include "circular_buffer.hh"

#include <atomic>

#include <cstdint>

#include <mutex>

#include <optional>

#include <span>

#include <thread>

namespace openmsx {

class EventDistributor;

class Scheduler;

class CommandController;

class RS232Net final : public RS232Device, private EventListener

{

public:

	// opaque structure describing an address for use with socket functions

	struct NetworkSocketAddress {

		int domain; // the address family (AF_INET, ...)

		socklen_t len; // the length of the socket address

		union {

			struct sockaddr generic;  // the generic type needed for calling the socket API

			struct sockaddr_in ipv4;  // an IPv4 socket address

			struct sockaddr_in6 ipv6; // an IPv6 socket address

		} address;

	};

public:

	RS232Net(EventDistributor& eventDistributor, Scheduler& scheduler,

	         CommandController& commandController);

	~RS232Net() override;

	// Pluggable

	void plugHelper(Connector& connector, EmuTime time) override;

	void unplugHelper(EmuTime time) override;

	[[nodiscard]] zstring_view getName() const override;

	[[nodiscard]] zstring_view getDescription() const override;

	// input

	void signal(EmuTime time) override;

	// output

	void recvByte(uint8_t value, EmuTime time) override;

	[[nodiscard]] std::optional<bool> getDSR(EmuTime time) const override;

	[[nodiscard]] std::optional<bool> getCTS(EmuTime time) const override;

	[[nodiscard]] std::optional<bool> getDCD(EmuTime time) const override;

	[[nodiscard]] std::optional<bool> getRI(EmuTime time) const override;

	void setDTR(bool status, EmuTime time) override;

	void setRTS(bool status, EmuTime time) override;

	template<typename Archive>

	void serialize(Archive& ar, unsigned version);

private:

	void run(); // loop of helper thread that reads from 'sockfd'

	// EventListener

	bool signalEvent(const Event& event) override;

	bool net_put(std::span<const char> buf);

	void open_socket(const NetworkSocketAddress& socket_address);

private:

	[[no_unique_address]] SocketActivator socketActivator;

	EventDistributor& eventDistributor;

	Scheduler& scheduler;

	// The value of these settings only matters at the time this device gets plugged in.

	// In other words: changing these settings only takes effect the next time the device gets plugged in.

	StringSetting rs232NetAddressSetting;

	BooleanSetting rs232NetUseIP232;

	std::thread thread; // receiving thread (reads from 'sockfd')

	std::mutex mutex; // to protect shared data between emulation and receiving thread

	std::optional<Poller> poller; // safe to use from main and receiver thread without extra locking

	cb_queue<char> queue; // read/written by both the main and the receiver thread. Must hold 'mutex' while doing so.

	std::atomic<SOCKET> sockfd; // read/written by both threads (use std::atomic as an alternative for locking)

	// These are written by the receiver thread and read by the main thread (use std::atomic as an alternative for locking)

	std::atomic<bool> DCD; // Data Carrier Detect input status

	std::atomic<bool> RI;  // Ring Indicator input status    TODO not yet used (write-only)

	// These are only accessed by the main thread (no need for locking)

	bool DTR; // Data Terminal Ready output status

	bool RTS; // Request To Send output status

	// This does not change while the receiving thread is running (no need for locking)

	bool IP232; // snapshot of 'rs232NetUseIP232' at the moment of plugging

};

} // namespace openmsx

#endif