1 files changed, 24 insertions, 43 deletions

diff --git a/ttwhy/io.cppm b/ttwhy/io.cppm
index 230f180..fd84dfd 100644
--- a/ttwhy/io.cppm
+++ b/ttwhy/io.cppm
@@ -2,11 +2,15 @@ module;
 
 #include <asio.hpp>
 
-#include <expected>
 #include <format>
+#include <span>
+#include <vector>
 
 export module ttwhy:io;
 
+import :event;
+import :scanner;
+
 namespace ttwhy::io
 {
 
@@ -25,58 +29,35 @@ namespace ttwhy::io
     co_return error;
   }
 
-  export template<typename InputStream, typename ErrorStream>
-  auto read(std::span<char> data, InputStream & input_stream, ErrorStream & error_stream)
-      -> asio::awaitable<std::expected<std::size_t, asio::error_code>>
-  {
-    auto [error, read] = co_await input_stream.async_read_some(asio::buffer(data), asio::as_tuple(asio::use_awaitable));
-
-    if (error)
-    {
-      auto message = std::format("{}, exiting ...\n", error.message());
-      co_await asio::async_write(error_stream, asio::buffer(message), asio::use_awaitable);
-      co_return std::unexpected{error};
-    }
-
-    co_return read;
-  }
-
-  export template<typename OutputStream, typename ErrorStream>
-  auto write(std::span<char const> string, OutputStream & output_stream, ErrorStream & error_stream)
-      -> asio::awaitable<asio::error_code>
+  export template<typename InputStream, typename AppRouter>
+  auto read_events(InputStream & stream, AppRouter & router) -> asio::awaitable<void>
   {
-    auto [error, written] =
-        co_await asio::async_write(output_stream, asio::buffer(string), asio::as_tuple(asio::use_awaitable));
+    auto queue = std::vector<input_event>{};
+    queue.reserve(16);
 
-    if (error)
-    {
-      auto message = std::format("{}, exiting ...\n", error.message());
-      co_await asio::async_write(error_stream, asio::buffer(message), asio::use_awaitable);
-    }
-
-    co_return error;
-  }
-
-  export template<typename InputStream, typename OutputStream, typename ErrorStream>
-  auto echo(InputStream & input_stream, OutputStream & output_stream, ErrorStream & error_stream)
-      -> asio::awaitable<asio::error_code>
-  {
-    auto input = std::array<char, 16>{};
+    auto scanner = ansi_scanner{queue};
+    auto raw_buffer = std::array<char, 64>{};
 
     while (true)
     {
-      auto read_result = co_await read(input, input_stream, error_stream);
-      if (!read_result.has_value())
+      auto [error, bytes_read] =
+          co_await stream.async_read_some(asio::buffer(raw_buffer), asio::as_tuple(asio::use_awaitable));
+
+      if (error)
       {
-        co_return read_result.error();
+        co_return;
       }
 
-      auto to_write = std::span{input.data(), read_result.value()};
-      auto write_error = co_await write(to_write, output_stream, error_stream);
-      if (write_error)
+      auto const byte_span = std::span<char const>{raw_buffer.data(), bytes_read};
+
+      scanner.process(byte_span);
+
+      for (auto const & event : queue)
       {
-        co_return write_error;
+        co_await router.process(event);
       }
+
+      queue.clear();
     }
   }