#!/usr/bin/env python3
"""Execute the real native-USB role output pumps with small host stubs."""

from pathlib import Path
import os
import shutil
import subprocess
import tempfile
import unittest


ROOT = Path(__file__).resolve().parents[1]

HARNESS = r'''
#include <algorithm>
#include <cstdarg>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>
#include <cstdint>
#include <helpers/FileRead.h>
@USB_CONFIG@
#define MESH_ESP32_USB_CONSOLE_COOPERATIVE 1
#define MESH_USB_CONSOLE_COOPERATIVE 1
#define PUB_KEY_SIZE 32
#define MAX_ROUTE_HASH_BYTES 3
#define PACKET_LOG_FILE "/packet_log"
static void require(bool ok, const char* what) {
  if (!ok) throw std::runtime_error(what);
}
struct FileData { std::string text; size_t reads = 0; bool exists = true; };
struct File {
  std::shared_ptr<FileData> data;
  size_t pos = 0;
  bool closed = false;
  bool directory = false;
  explicit operator bool() const { return data && (data->exists || directory) && !closed; }
  bool isDirectory() const { return directory; }
  size_t size() const { return data ? data->text.size() : 0; }
  int read() {
    if (!static_cast<bool>(*this) || pos >= data->text.size()) return -1;
    ++data->reads;
    return static_cast<unsigned char>(data->text[pos++]);
  }
  void close() { closed = true; }
};
struct FakeFS {
  std::shared_ptr<FileData> data = std::make_shared<FileData>();
  bool exists(const char*) const { return data->exists; }
  // ESP32 SPIFFS can return a truthy directory for a missing regular file.
  File open(const char*) { return File{data, 0, false, !data->exists}; }
} fs;
struct Stream {
  std::string output;
  std::vector<std::string> records;
  size_t capacity = 4096;
  size_t short_limit = 0;
  bool fail_once = false;
  int availableForWrite() const { return static_cast<int>(capacity); }
  size_t write(const uint8_t* data, size_t len) {
    if (fail_once) { fail_once = false; return 0; }
    if (len > capacity) return 0;
    if (short_limit != 0) len = std::min(len, short_limit);
    output.append(reinterpret_cast<const char*>(data), len);
    records.emplace_back(reinterpret_cast<const char*>(data), len);
    capacity -= len;
    return len;
  }
  size_t printf(const char* format, ...) {
    char record[1024];
    va_list args;
    va_start(args, format);
    int len = vsnprintf(record, sizeof(record), format, args);
    va_end(args);
    return len > 0 ? write(reinterpret_cast<const uint8_t*>(record), len) : 0;
  }
} console;
namespace mesh {
Stream& usbConsolePort() { return console; }
namespace Utils {
void toHex(char* dest, const uint8_t* src, size_t len) {
  static const char digits[] = "0123456789ABCDEF";
  for (size_t i = 0; i < len; ++i) {
    *dest++ = digits[src[i] >> 4];
    *dest++ = digits[src[i] & 15];
  }
  *dest = 0;
}
}
}
struct SimpleMeshTables {
  struct RecentRepeaterInfo {
    uint8_t prefix[3];
    uint8_t prefix_len;
    int8_t snr_x4;
  };
  std::vector<RecentRepeaterInfo> rows;
  static void copyRecentRepeaterInfo(RecentRepeaterInfo& out,
                                     const RecentRepeaterInfo& in) { out = in; }
  static void copyRecentRepeaterPrefix(uint8_t* out,
                                       const RecentRepeaterInfo& in) {
    memcpy(out, in.prefix, sizeof(in.prefix));
  }
  int getRecentRepeaterCount() const { return static_cast<int>(rows.size()); }
  const RecentRepeaterInfo* getNextRecentRepeaterBySortKey(
      const RecentRepeaterInfo*, int previous, int& result) const {
    result = previous + 1;
    return result < static_cast<int>(rows.size()) ? &rows[result] : nullptr;
  }
};
struct FakeAcl {
  struct Client {
    struct { uint8_t pub_key[PUB_KEY_SIZE]; } id{};
    uint8_t permissions = 3;
  };
  std::vector<Client> clients;
  int getNumClients() const { return static_cast<int>(clients.size()); }
  Client* getClientByIdx(int index) { return &clients.at(index); }
};
class MyMesh {
 public:
  FakeFS* _fs = &fs;
  File serial_log_dump;
  size_t serial_log_remaining = 0;
  size_t serial_log_pending_size = 0;
  char serial_log_pending[640];
  bool serial_log_active = false;
  bool serial_log_eof_pending = false;
  bool serial_log_skip_line = false;
  int serial_acl_next = -1;
  int serial_acl_count = 0;
  bool serial_acl_header = false;
  int serial_recent_next = -1;
  int serial_recent_count = 0;
  bool serial_recent_header = false;
  bool serial_recent_has_cursor = false;
  SimpleMeshTables::RecentRepeaterInfo serial_recent_cursor{};
  int serial_recent_cursor_index = -1;
  SimpleMeshTables tables;
  FakeAcl acl;
  const SimpleMeshTables* getTables() const { return &tables; }
  void dumpLogFile();
  void printAclSerial();
  bool hasPendingSerialOutput() const;
  void servicePendingSerialOutput();
  void cancelPendingSerialOutput();
  void printRecentRepeatersSerial();
};
@METHODS@
static void setupFile(const std::string& text, bool exists = true) {
  fs.data = std::make_shared<FileData>();
  fs.data->text = text;
  fs.data->exists = exists;
  console = Stream();
}
static void drain(MyMesh& radio, size_t capacity = 4096) {
  int passes = 0;
  while (radio.hasPendingSerialOutput() && passes++ < 10000) {
    console.capacity = capacity;
    const size_t reads = fs.data->reads;
    radio.servicePendingSerialOutput();
    require(fs.data->reads - reads <= 640, "unbounded file read pass");
  }
  require(!radio.hasPendingSerialOutput(), "output pump failed to finish");
}
int main() {
  try {
    const std::string eof = "  ->    EOF\r\n";
    for (bool exists : {false, true}) {
      setupFile("", exists);
      MyMesh radio;
      radio.dumpLogFile();
      require(exists || !radio.serial_log_active, "missing log accepted as a directory");
      require(console.output.empty(), "synchronous premature EOF");
      drain(radio);
      require(console.output == eof, "missing or duplicate empty-file EOF");
    }
    setupFile("hello\nworld\n");
    {
      MyMesh radio;
      radio.dumpLogFile();
      console.capacity = 0;
      radio.servicePendingSerialOutput();
      const size_t reads = fs.data->reads;
      radio.servicePendingSerialOutput();
      require(reads == fs.data->reads, "backpressure lost pending line");
      require(console.output.empty(), "wrote without capacity");
      console.short_limit = 3;
      console.capacity = 4096;
      radio.servicePendingSerialOutput();
      console.short_limit = 0;
      drain(radio);
      require(console.output == "hello\nworld\n" + eof, "short-write suffix lost");
    }
    std::string large;
    for (int i = 0; i < 1000; ++i) large += "stored packet\n";
    setupFile(large);
    {
      MyMesh radio;
      radio.dumpLogFile();
      fs.data->text += "arrived later\n";
      drain(radio);
      require(console.output == large + eof, "large dump lost bytes or ignored snapshot");
      for (const auto& record : console.records)
        require(!record.empty() && record.back() == '\n', "split stored record");
    }
    const std::string boundary(639, 'a');
    const std::string too_long(640, 'b');
    setupFile(boundary + "\n" + too_long + "\nend\ntail");
    {
      MyMesh radio;
      radio.dumpLogFile();
      drain(radio);
      require(console.output == boundary + "\n"
          "[USB log line omitted: exceeds 640 bytes]\r\nend\ntail\n" + eof,
          "long line boundary or final partial line is wrong");
    }
    setupFile(std::string(2000, 'x') + "\n");
    {
      MyMesh radio;
      radio.dumpLogFile();
      radio.servicePendingSerialOutput();
      require(radio.hasPendingSerialOutput(), "overlong line not pending");
      radio.cancelPendingSerialOutput();
      drain(radio);
      require(console.output.empty(), "canceled old-session output leaked");
    }
    // The real HWCDC setup falls back to these ring sizes after allocation
    // failure. A stored row larger than the ring must finish without omission.
    for (size_t capacity : {256u, 512u}) {
      const std::string stored = std::string(639, 's') + "\nnext\n";
      setupFile(stored);
      MyMesh radio;
      radio.dumpLogFile();
      console.capacity = 0;
      radio.servicePendingSerialOutput();
      require(console.output.empty(), "fallback dump wrote to a stalled host");
      drain(radio, capacity);
      require(console.output == stored + eof, "small TX ring wedged or truncated a stored line");
    }
    setupFile("short\n");
    {
      MyMesh radio;
      radio.dumpLogFile();
      console.short_limit = 3;
      drain(radio, 7);
      require(console.output == "short\n" + eof, "short-write EOF was duplicated or truncated");
    }
    setupFile("");
    {
      MyMesh radio;
      std::string expected = "ACL:\r\n";
      for (int i = 0; i < 32; ++i) {
        FakeAcl::Client client;
        std::fill(std::begin(client.id.pub_key), std::end(client.id.pub_key), i);
        radio.acl.clients.push_back(client);
        char key[PUB_KEY_SIZE * 2 + 1], line[80];
        mesh::Utils::toHex(key, client.id.pub_key, PUB_KEY_SIZE);
        snprintf(line, sizeof(line), "%02X %s\n", client.permissions, key);
        expected += line;
      }
      require(expected.size() > 2048, "ACL test does not exceed admission reserve");
      console.capacity = 256;  // Accepted with a nearly-full HWCDC/logging FIFO.
      radio.printAclSerial();
      require(console.output.empty(), "ACL is still emitted synchronously");
      radio.acl.clients.emplace_back();  // New arrivals must not extend the snapshot.
      console.capacity = 0;
      for (int i = 0; i < 1000; ++i) radio.servicePendingSerialOutput();
      require(console.output.empty(), "ACL wrote into a stalled host");
      require(radio.serial_acl_next == 0, "stalled header skipped an ACL row");
      console.fail_once = true;
      console.short_limit = 17;
      drain(radio, 73);
      require(console.output == expected, "full ACL lost or duplicated short-write bytes");
      require(!radio.hasPendingSerialOutput(), "ACL blocks the next command after completion");
    }
    setupFile("");
    {
      MyMesh radio;
      radio.acl.clients.resize(32);
      for (auto& client : radio.acl.clients) client.permissions = 0;
      radio.printAclSerial();
      drain(radio, 73);
      require(console.output == "ACL:\r\n", "deleted ACL clients were printed");
    }
    setupFile("");
    {
      MyMesh radio;
      radio.acl.clients.resize(1);
      std::fill(std::begin(radio.acl.clients[0].id.pub_key),
                std::end(radio.acl.clients[0].id.pub_key), 0xAA);
      radio.printAclSerial();
      radio.servicePendingSerialOutput();
      console.short_limit = 7;
      radio.servicePendingSerialOutput();
      require(radio.serial_log_pending_size > 0, "ACL short-write suffix was not retained");
      radio.cancelPendingSerialOutput();
      require(!radio.hasPendingSerialOutput(), "ACL cancellation leaves a pending job");
      console.output.clear();
      console.records.clear();
      console.short_limit = 0;
      radio.acl.clients.clear();
      radio.printAclSerial();
      drain(radio, 73);
      require(console.output == "ACL:\r\n", "old ACL row leaked after reconnect cancellation");
    }
    setupFile("existing file dump\n");
    {
      MyMesh radio;
      radio.dumpLogFile();
      console.capacity = 0;
      radio.servicePendingSerialOutput();
      const size_t pending = radio.serial_log_pending_size;
      radio.printAclSerial();
      require(radio.serial_log_pending_size == pending && radio.serial_acl_next == -1,
          "overlapping ACL command overwrote a pending file record");
      drain(radio);
      require(console.output == "existing file dump\n" + eof,
          "overlapping ACL command corrupted an existing output job");
    }
    @RECENT_TEST@
    std::cout << "cooperative output checks passed\n";
    return 0;
  } catch (const std::exception& error) {
    std::cerr << error.what() << "\n";
    return 1;
  }
}
'''

RECENT_TEST = r'''
    setupFile("");
    {
      MyMesh radio;
      radio.tables.rows.push_back({{0, 0, 1}, 3, -127});
      radio.tables.rows.push_back({{0, 0, 2}, 3, -127});
      console.short_limit = 3;
      radio.printRecentRepeatersSerial();
      require(radio.serial_recent_header, "partial header advanced cursor");
      drain(radio, 7);
      require(console.output == "Recent repeaters (2):\n000001,-31.75\n000002,-31.75\n",
          "short-write recent listing duplicated or lost a prefix");
    }
    setupFile("");
    {
      MyMesh radio;
      radio.tables.rows.push_back({{0, 0, 1}, 3, -127});
      radio.printRecentRepeatersSerial();
      console.short_limit = 3;
      radio.servicePendingSerialOutput();
      require(radio.serial_log_pending_size > 0, "partial recent row was not retained");
      radio.tables.rows[0] = {{0, 0, 9}, 3, 0};
      console.short_limit = 0;
      drain(radio, 64);
      require(console.output == "Recent repeaters (1):\n000001,-31.75\n",
          "live table update changed a partially emitted recent row");
    }
    setupFile("");
    {
      MyMesh radio;
      radio.tables.rows.push_back({{0, 0, 1}, 3, -127});
      console.short_limit = 3;
      radio.printRecentRepeatersSerial();
      radio.cancelPendingSerialOutput();
      console.output.clear();
      console.short_limit = 0;
      radio.tables.rows.clear();
      radio.printRecentRepeatersSerial();
      drain(radio, 64);
      require(console.output == "Recent repeaters (0):\n-none-\r\n",
          "canceled recent suffix leaked into the next session");
    }
    setupFile("");
    {
      MyMesh radio;
      for (int i = 0; i < 2048; ++i) {
        radio.tables.rows.push_back({{0, static_cast<uint8_t>(i >> 8),
            static_cast<uint8_t>(i)}, 3, -127});
      }
      console.fail_once = true;
      radio.printRecentRepeatersSerial();
      require(radio.serial_recent_header, "failed header write advanced cursor");
      drain(radio, 64);
      require(console.output.find("Recent repeaters (2048):\n") == 0, "missing header");
      require(std::count(console.output.begin(), console.output.end(), '\n') == 2049,
          "2048-row listing truncated");
      require(console.output.substr(console.output.size() - 14) == "0007FF,-31.75\n",
          "last recent repeater missing");
      for (const auto& record : console.records)
        require(!record.empty() && record.back() == '\n', "split recent row");
    }
'''


class CooperativeOutputTest(unittest.TestCase):
    def test_usb_acl_commands_route_to_the_cooperative_pump(self):
        for role in ("simple_repeater", "simple_room_server"):
            with self.subTest(role=role):
                text = (ROOT / f"examples/{role}/MyMesh.cpp").read_text()
                start = text.index('strcmp(command, "get acl") == 0) {')
                end = text.index("reply[0] = 0;", text.index("#endif", start))
                self.assertIn("printAclSerial();", text[start:end])
                self.assertNotIn("mesh::usbConsolePort().printf", text[start:end])

    def test_real_role_pumps(self):
        compiler = shutil.which("g++") or shutil.which("clang++")
        if not compiler:
            self.skipTest("A host C++ compiler is required for pump execution")
        for role, config in ((role, config)
                for role in ("simple_repeater", "simple_room_server")
                for config in ("MESH_ESP32_TINYUSB_NONBLOCKING", "MESH_ESP32_HWCDC_SESSION_GUARD")):
            with self.subTest(role=role, transport=config), tempfile.TemporaryDirectory() as temporary:
                text = (ROOT / f"examples/{role}/MyMesh.cpp").read_text()
                dump_start = text.index("void MyMesh::dumpLogFile()")
                dump_end = text.index("\n#if MESH_USB_CONSOLE_COOPERATIVE\nbool MyMesh::hasPendingSerialOutput", dump_start)
                pump_start = text.index("bool MyMesh::hasPendingSerialOutput()", dump_end)
                pump_end = text.index("\n#endif", pump_start)
                methods = text[dump_start:dump_end] + "\n" + text[pump_start:pump_end]
                if role == "simple_repeater":
                    format_start = text.index("static void formatLocalSnrX4(")
                    format_end = text.index("\nvoid MyMesh::formatRecentRepeatersReply", format_start)
                    recent_start = text.index("void MyMesh::printRecentRepeatersSerial()")
                    recent_end = text.index("\nbool MyMesh::setRecentRepeater(", recent_start)
                    methods = text[format_start:format_end] + "\n" + text[recent_start:recent_end] + "\n" + methods
                program = HARNESS.replace("@METHODS@", methods).replace(
                    "@RECENT_TEST@", RECENT_TEST if role == "simple_repeater" else ""
                ).replace("@USB_CONFIG@", f"#define {config} 1")
                executable = Path(temporary) / ("pump.exe" if os.name == "nt" else "pump")
                build = subprocess.run(
                    [compiler, "-std=c++17", "-O0", "-I", str(ROOT / "src"),
                     "-x", "c++", "-", "-o", str(executable)],
                    input=program, text=True, capture_output=True, timeout=60,
                )
                self.assertEqual(build.returncode, 0, build.stdout + build.stderr)
                run = subprocess.run(
                    [str(executable)], text=True, capture_output=True, timeout=30,
                )
                self.assertEqual(run.returncode, 0, run.stdout + run.stderr)


if __name__ == "__main__":
    unittest.main()