RawTerminal.mpp

module;

#include <CppUtils/System/Windows.hpp>

#if defined(OS_LINUX) or defined(OS_MACOS)
#	include <unistd.h>
#	include <termios.h>
#	include <poll.h>
#endif

export module CppUtils.Terminal.RawTerminal;

import std;

export namespace CppUtils::Terminal
{
#if defined(OS_LINUX) or defined(OS_MACOS)
	class RawTerminal final
	{
	public:
		inline RawTerminal()
		{
			if (tcgetattr(STDIN_FILENO, std::addressof(m_oldTerminalState)))
				return;
			m_initialized = true;

			auto rawTerminal = m_oldTerminalState;
			rawTerminal.c_lflag &= static_cast<tcflag_t>(~(ICANON | ECHO));
			tcsetattr(STDIN_FILENO, TCSANOW, std::addressof(rawTerminal));
		}

		RawTerminal(const RawTerminal&) = delete;
		RawTerminal(RawTerminal&& other) noexcept:
			m_oldTerminalState{other.m_oldTerminalState},
			m_initialized{std::exchange(other.m_initialized, false)}
		{}

		RawTerminal& operator=(const RawTerminal&) = delete;
		RawTerminal& operator=(RawTerminal&& rhs) noexcept
		{
			if (this != std::addressof(rhs))
			{
				m_oldTerminalState = rhs.m_oldTerminalState;
				m_initialized = std::exchange(rhs.m_initialized, false);
			}
			return *this;
		}

		inline ~RawTerminal()
		{
			if (m_initialized)
				tcsetattr(STDIN_FILENO, TCSANOW, std::addressof(m_oldTerminalState));
		}

		[[nodiscard]] static inline auto isInputAvailable() -> bool
		{
			auto pfd = pollfd{STDIN_FILENO, POLLIN, 0};
			return ::poll(std::addressof(pfd), 1, 0) > 0;
		}

		[[nodiscard]] inline auto readChar() const -> char
		{
			auto c = char{};
			if (::read(STDIN_FILENO, std::addressof(c), 1) == 1)
				return c;
			return '\0';
		}

		[[nodiscard]] inline auto read(char sentinel) const -> std::string
		{
			using namespace std::literals;

			auto string = ""s;
			auto c = readChar();
			while (c != '\0' and c != sentinel)
			{
				string += c;
				c = readChar();
			}
			return string;
		}

	private:
		termios m_oldTerminalState;
		bool m_initialized = false;
	};
#endif
}