export module mcpplibs.tinyhttps:sse;

import std;

namespace mcpplibs::tinyhttps {

export struct SseEvent {

std::string event; // event type (default "message")

std::string data; // event data

std::string id; // event id (optional)

};

export class SseParser {

std::string buffer_;

std::string currentEvent_;

std::string currentData_;

std::string currentId_;

std::vector<SseEvent> feed(std::string_view chunk) {

buffer_.append(chunk);

std::vector<SseEvent> events;

// Scan for event boundaries: \n\n or \r\n\r\n

while (true) {

// Find double newline (event boundary)

auto pos = find_event_boundary_();

if (pos == std::string::npos) {

break;

}

// Extract the event block

std::string_view block(buffer_.data(), pos);

// Determine how many chars to skip past the boundary

std::size_t skip = 0;

if (pos + 1 < buffer_.size() && buffer_[pos] == '\n' && buffer_[pos + 1] == '\n') {

skip = pos + 2;

} else if (pos + 3 < buffer_.size() &&

buffer_[pos] == '\r' && buffer_[pos + 1] == '\n' &&

buffer_[pos + 2] == '\r' && buffer_[pos + 3] == '\n') {

skip = pos + 4;

} else {

skip = pos + 2; // fallback for \n\n

}

// Process each line in the block

process_block_(block);

dispatch_event_(events);

buffer_.erase(0, skip);

}

return events;

}

void reset() {

}

std::size_t find_event_boundary_() const {

for (std::size_t i = 0; i < buffer_.size(); ++i) {

if (buffer_[i] == '\n' && i + 1 < buffer_.size() && buffer_[i + 1] == '\n') {

return i;

}

if (buffer_[i] == '\r' && i + 3 < buffer_.size() &&

buffer_[i + 1] == '\n' && buffer_[i + 2] == '\r' && buffer_[i + 3] == '\n') {

return i;

}

}

return std::string::npos;

}

void process_block_(std::string_view block) {

while (!block.empty()) {

// Find end of line

std::size_t lineEnd = 0;

std::size_t skip = 0;

bool found = false;

for (std::size_t i = 0; i < block.size(); ++i) {

if (block[i] == '\r' && i + 1 < block.size() && block[i + 1] == '\n') {

lineEnd = i;

skip = i + 2;

found = true;

break;

}

if (block[i] == '\n') {

lineEnd = i;

skip = i + 1;

found = true;

break;

}

}

if (!found) {

lineEnd = block.size();

skip = block.size();

}

process_line_(block.substr(0, lineEnd));

block = block.substr(skip);

}

}

void process_line_(std::string_view line) {

if (line.empty()) {

return;

}

// Comment line

if (line[0] == ':') {

return;

}

// Find colon

auto colonPos = line.find(':');

if (colonPos == std::string_view::npos) {

// Field with no value — treat field name as the whole line, value as empty

return;

}

auto field = line.substr(0, colonPos);

auto value = line.substr(colonPos + 1);

// Strip single leading space from value if present

if (!value.empty() && value[0] == ' ') {

value = value.substr(1);

}

if (field == "data") {

if (!currentData_.empty()) {

currentData_ += '\n';

}

currentData_.append(value);

} else if (field == "event") {

currentEvent_ = std::string(value);

} else if (field == "id") {

currentId_ = std::string(value);

}

// Other fields ignored

}

void dispatch_event_(std::vector<SseEvent>& events) {

}

};

} // namespace mcpplibs::tinyhttps