// Определение пакета Meshtastic (protobuf)
message MeshPacket {
    // Уникальный ID отправителя (4 байта)
    uint32 from = 1;

    // ID получателя (0 = broadcast)
    uint32 to = 2;

    // Индекс канала (для мультиканальности)
    uint32 channel = 3;

    // Зашифрованные данные или plaintext
    oneof payload_variant {
        Data decoded = 4;
        bytes encrypted = 5;
    }

    // Счётчик прыжков (TTL)
    uint32 hop_limit = 6;
    uint32 hop_start = 7;

    // ID пакета для дедупликации
    uint32 id = 8;

    // Время отправки (Unix timestamp)
    uint32 rx_time = 9;

    // RSSI и SNR последнего приёма
    float rx_rssi = 10;
    float rx_snr = 11;

    // Приоритет пакета
    enum Priority {
        UNSET = 0;
        MIN = 1;
        BACKGROUND = 10;
        DEFAULT = 64;
        RELIABLE = 100;
        ACK = 120;
        MAX = 255;
    }
    Priority priority = 12;
}

// Полезная нагрузка данных
message Data {
    enum PortNum {
        UNKNOWN_APP = 0;
        TEXT_MESSAGE_APP = 1;
        POSITION_APP = 3;
        NODEINFO_APP = 4;
        ROUTING_APP = 5;
        TELEMETRY_APP = 67;
        NEIGHBORINFO_APP = 70;
        ATAK_PLUGIN = 71;
        PRIVATE_APP = 256;
    }
    PortNum portnum = 1;
    bytes payload = 2;
    bool want_response = 3;
    uint32 request_id = 4;
}

import math

def calculate_lora_datarate(sf, bw, cr, de=False, n_crc=True, ih=False):
    """
    Расчёт скорости передачи данных LoRa.

    Параметры:
        sf  : Spreading Factor (7-12)
        bw  : Bandwidth в кГц (125, 250, 500)
        cr  : Coding Rate (1-4, соответствует 4/5-4/8)
        de  : Low Data Rate Optimization
        n_crc: Наличие CRC
        ih  : Implicit Header mode

    Возвращает:
        Скорость в бит/с
    """
    # Symbol rate (символов в секунду)
    rs = (bw * 1000) / (2 ** sf)

    # Полезная нагрузка на символ
    cr_fraction = 4 / (cr + 4)

    # Расчёт скорости
    if sf <= 6:
        # SF6 использует другой режим
        datarate = rs * sf * cr_fraction
    else:
        # Стандартный режим SF7-SF12
        de_factor = 1 if de else 0
        sf_effective = sf - 2 * de_factor
        datarate = rs * sf_effective * cr_fraction

    return round(datarate, 2)


# Примеры расчётов для разных конфигураций
configs = [
    ("Fast (SF7, BW250)",    7,  250, 1),
    ("Default (SF11, BW125)", 11, 125, 1),
    ("Long Range (SF12, BW125)", 12, 125, 2),
    ("Medium (SF9, BW125)",  9,  125, 1),
]

for name, sf, bw, cr in configs:
    rate = calculate_lora_datarate(sf, bw, cr)
    print(f"{name:35}: {rate:8} бит/с")

# Вывод:
# Fast (SF7, BW250)                 : 13671.88 бит/с
# Default (SF11, BW125)             :   537.11 бит/с
# Long Range (SF12, BW125)          :   268.55 бит/с
# Medium (SF9, BW125)               :  2148.44 бит/с


def calculate_time_on_air(payload_len, sf, bw, cr=1,
                          de=False, n_crc=True, ih=False):
    """
    Расчёт времени передачи пакета (Time on Air).

    Параметры:
        payload_len : длина полезной нагрузки в байтах
        sf, bw, cr  : параметры LoRa
        de          : Low Data Rate Optimization
        n_crc       : наличие CRC
        ih          : Implicit Header

    Возвращает:
        Время передачи в миллисекундах
    """
    # Количество символов преамбулы
    n_preamble = 8  # стандартное значение

    # Длительность символа
    t_sym = (2 ** sf) / (bw * 1000)  # в секундах

    # Время преамбулы
    t_preamble = (n_preamble + 4.25) * t_sym

    # Расчёт количества символов полезной нагрузки
    de_flag = 1 if de else 0
    ih_flag = 1 if ih else 0
    crc_flag = 1 if n_crc else 0

    numerator = 8 * payload_len - 4 * sf + 28 + 16 * crc_flag - 20 * ih_flag
    denominator = 4 * (sf - 2 * de_flag)
    n_payload = 8 + max(math.ceil(numerator / denominator) * (cr + 4), 0)

    # Общее время
    t_total = t_preamble + n_payload * t_sym

    return t_total * 1000  # в мс


# Пример: время передачи 50-байтового сообщения
toa = calculate_time_on_air(50, 11, 125)
print(f"Time on Air: {toa:.1f} мс")
# Time on Air: 1152.0 мс

# Установка meshtastic CLI через pip
$ pip install meshtastic

# Проверка версии
$ meshtastic --version
# meshtastic 2.3.2

# Подключение к устройству через serial
$ meshtastic --port /dev/ttyUSB0 --info

# Подключение через WiFi (если устройство в сети)
$ meshtastic --host 192.168.1.100 --info

# Подключение через BLE
$ meshtastic --ble "Meshtastic_XXXX" --info

# Установка региона (EU_868 для Европы)
$ meshtastic --set lora.region EU_868

# Установка модемной конфигурации
# Варианты: LONG_FAST, LONG_SLOW, LONG_MODERATE, SHORT_FAST, MEDIUM_SLOW и др.
$ meshtastic --set lora.modem_preset LONG_FAST

# Установка hop_limit (максимальное количество прыжков)
$ meshtastic --set lora.hop_limit 3

# Включение/выключение TX (для приёмников-ретрансляторов)
$ meshtastic --set lora.tx_enabled true

# Установка мощности передатчика (dBm)
$ meshtastic --set lora.tx_power 20

# Настройка канала (шифрование)
$ meshtastic --set lora.use_psk true

# Установка имени узла
$ meshtastic --set owner "MyMeshNode-01"

# Установка короткого имени (4 символа)
$ meshtastic --set owner_short "M001"

# Включение позиционного вещания
$ meshtastic --set position.position_broadcast_secs 900

# Настройка интервала телеметрии
$ meshtastic --set device.telemetry_interval_secs 1800

# Показать текущую конфигурацию
$ meshtastic --info

# Перезагрузка устройства
$ meshtastic --reboot

# Сброс к заводским настройкам
$ meshtastic --reset

import meshtastic
import meshtastic.serial_interface
import time


class MeshtasticNode:
    """
    Класс для управления узлом Meshtastic через Python API.
    Поддерживает отправку/приём сообщений, чтение телеметрии
    и управление конфигурацией.
    """

    def __init__(self, port="/dev/ttyUSB0"):
        """Инициализация подключения к узлу."""
        self.interface = None
        self.port = port
        self.messages = []
        self.nodes = {}

    def connect(self):
        """Подключение к устройству через serial."""
        try:
            self.interface = meshtastic.serial_interface.SerialInterface(
                devPath=self.port
            )
            print(f"✅ Подключено к {self.port}")

            # Получение информации об узле
            my_info = self.interface.getMyNodeInfo()
            print(f"📡 Мой узел: {my_info.get('user', {}).get('longName', 'Unknown')}")
            print(f"🆔 Node ID: !{my_info.get('num', 0):08x}")

            return True
        except Exception as e:
            print(f"❌ Ошибка подключения: {e}")
            return False

    def send_text(self, text, destination="^all"):
        """
        Отправка текстового сообщения.

        Args:
            text: Текст сообщения
            destination: ID получателя или "^all" для broadcast
        """
        if not self.interface:
            print("❌ Не подключено")
            return False

        try:
            self.interface.sendText(
                text=text,
                destinationId=destination,
                wantAck=True,
                wantResponse=False
            )
            print(f"📤 Отправлено: {text}")
            return True
        except Exception as e:
            print(f"❌ Ошибка отправки: {e}")
            return False

    def send_position(self, lat, lon, alt=0):
        """Отправка GPS-позиции."""
        if not self.interface:
            return False

        self.interface.sendPosition(
            latitude=lat,
            longitude=lon,
            altitude=alt
        )
        print(f"📍 Позиция отправлена: {lat}, {lon}, {alt}м")

    def get_nodes(self):
        """Получение списка всех известных узлов."""
        if not self.interface:
            return {}

        self.nodes = self.interface.nodes
        return self.nodes

    def print_node_list(self):
        """Вывод списка узлов в красивом формате."""
        nodes = self.get_nodes()

        print("\n📡 Известные узлы:")
        print("=" * 70)
        print(f"{'ID':12} {'Имя':20} {'Батарея':10} {'Последний':15}")
        print("=" * 70)

        for node_id, node in nodes.items():
            user = node.get('user', {})
            name = user.get('longName', 'Unknown')
            metrics = node.get('deviceMetrics', {})
            battery = metrics.get('batteryLevel', 0)
            last_seen = node.get('lastHeard', 0)

            if last_seen > 0:
                time_diff = time.time() - last_seen
                if time_diff < 60:
                    last_str = f"{int(time_diff)}с назад"
                elif time_diff < 3600:
                    last_str = f"{int(time_diff/60)}м назад"
                else:
                    last_str = f"{int(time_diff/3600)}ч назад"
            else:
                last_str = "Никогда"

            battery_str = f"{battery}%" if battery > 0 else "N/A"
            print(f"{node_id:12} {name:20} {battery_str:10} {last_str:15}")

    def on_receive(self, packet, interface):
        """Обработчик входящих сообщений."""
        decoded = packet.get('decoded', {})
        msg_type = decoded.get('portnum', '')

        if msg_type == 'TEXT_MESSAGE_APP':
            text = decoded.get('payload', b'').decode('utf-8')
            sender = packet.get('fromId', 'Unknown')
            print(f"\n💬 Сообщение от {sender}: {text}")
            self.messages.append({
                'from': sender,
                'text': text,
                'time': time.time()
            })

        elif msg_type == 'POSITION_APP':
            pos = decoded.get('position', {})
            print(f"\n📍 Позиция от {packet.get('fromId', '?')}")

        elif msg_type == 'TELEMETRY_APP':
            telemetry = decoded.get('telemetry', {})
            print(f"\n📊 Телеметрия от {packet.get('fromId', '?')}")

    def disconnect(self):
        """Закрытие подключения."""
        if self.interface:
            self.interface.close()
            print("🔌 Отключено")


# === Пример использования ===
if __name__ == "__main__":
    node = MeshtasticNode(port="/dev/ttyUSB0")

    if node.connect():
        # Отправка broadcast-сообщения
        node.send_text("Привет, mesh-сеть! 📡")

        # Отправка позиции
        node.send_position(55.7558, 37.6173, 150)

        # Вывод списка узлов
        node.print_node_list()

        # Ожидание сообщений (30 секунд)
        print("\n⏳ Ожидание сообщений...")
        time.sleep(30)

        # Отключение
        node.disconnect()

# Показать текущие каналы
$ meshtastic --get channels

# Добавить новый канал с именем "Team-Alpha"
$ meshtastic --ch-add Team-Alpha

# Установить PSK (Pre-Shared Key) для канала
$ meshtastic --ch-set psk "1PG7OiApB1nwvP+rz05pAQ==" --ch-index 1

# Установить канал как UPLINK (передача в интернет)
$ meshtastic --ch-set uplink_enabled true --ch-index 1

# Установить канал как DOWNLINK (приём из интернета)
$ meshtastic --ch-set downlink_enabled true --ch-index 1

# Удалить канал
$ meshtastic --ch-del --ch-index 1

# Переключиться на канал по умолчанию
$ meshtastic --set lora.region EU_868

# Генерация случайного PSK
$ meshtastic --ch-set psk random --ch-index 1

# Экспорт URL канала для шаринга
$ meshtastic --ch-url --ch-index 0
# https://meshtastic.org/e/... (длинная ссылка с настройками канала)

# Включение MQTT
$ meshtastic --set mqtt.enabled true

# Установка адреса MQTT-брокера
$ meshtastic --set mqtt.address "mqtt.meshtastic.org"

# Установка имени пользователя и пароля
$ meshtastic --set mqtt.username "meshdev"
$ meshtastic --set mqtt.password "large4cats"

# Корневой топик
$ meshtastic --set mqtt.root "msh"

# Включение шифрования MQTT
$ meshtastic --set mqtt.encryption_enabled true

# Включение JSON-вывода
$ meshtastic --set mqtt.json_enabled true

# Включение TLS
$ meshtastic --set mqtt.tls_enabled true

# Карта (Map reporting)
$ meshtastic --set mqtt.map_reporting_enabled true
$ meshtastic --set mqtt.map_report_settings.publish_interval_secs 900
$ meshtastic --set mqtt.map_report_settings.position_precision 13

# Установка роли ROUTER (ретранслятор)
$ meshtastic --set device.role ROUTER

# Установка роли CLIENT (обычный клиент)
$ meshtastic --set device.role CLIENT

# Установка роли TRACKER (GPS-трекер)
$ meshtastic --set device.role TRACKER

# Установка роли SENSOR (датчик)
$ meshtastic --set device.role SENSOR

# Установка роли TAK (для ATAK)
$ meshtastic --set device.role TAK

/*
 * MeshCore — Базовый пример узла mesh-сети
 *
 * Этот пример демонстрирует создание простого узла MeshCore,
 * который может отправлять и получать сообщения в mesh-сети.
 *
 * Требуемое оборудование:
 *   - ESP32 (любая модель с WiFi)
 *   - USB-кабель для прошивки
 *
 * Библиотеки:
 *   - MeshCore (https://github.com/...)
 *   - WiFi
 */

#include <WiFi.h>
#include <esp_wifi.h>
#include <esp_mesh.h>
#include <esp_mesh_internal.h>
#include <MeshCore.h>

// === Конфигурация сети ===
#define MESH_SSID       "MeshCore_Network"
#define MESH_PASSWORD   "mesh_secure_pass"
#define MESH_PORT       5555
#define MESH_CHANNEL    6
#define MESH_MAX_LAYER  6     // Максимальная глубина дерева

// === Глобальные переменные ===
MeshCore mesh;
bool isRoot = false;
int nodeLayer = 0;
uint32_t lastSendTime = 0;
const uint32_t SEND_INTERVAL = 5000; // 5 секунд

// === Callback-функции ===

// Вызывается при получении сообщения
void onReceive(const uint8_t* data, size_t len, const mesh_addr_t& from) {
    char message[256] = {0};
    memcpy(message, data, min(len, sizeof(message) - 1));

    Serial.printf(
        "📨 Получено от " MACSTR ": %s\n",
        MAC2STR(from.addr), message
    );

    // Обработка специальных команд
    if (strcmp(message, "STATUS") == 0) {
        char response[128];
        snprintf(response, sizeof(response),
            "Node: %s, Layer: %d, RSSI: %d",
            WiFi.macAddress().c_str(),
            nodeLayer,
            WiFi.RSSI()
        );
        mesh.send((const uint8_t*)response, strlen(response));
    }
}

// Вызывается при изменении состояния mesh
void onMeshEvent(mesh_event_t* event) {
    switch (event->id) {
        case MESH_EVENT_STARTED:
            Serial.println("🟢 Mesh-сеть запущена");
            break;

        case MESH_EVENT_CONNECTED:
            Serial.println("🔗 Подключено к mesh-сети");
            break;

        case MESH_EVENT_ROOT_ADDRESS:
            Serial.println("👑 Этот узел стал ROOT");
            isRoot = true;
            break;

        case MESH_EVENT_PARENT_CONNECTED:
            Serial.println("📡 Подключено к родительскому узлу");
            nodeLayer = event->info.parent_connected.self_layer;
            Serial.printf("   Уровень в дереве: %d\n", nodeLayer);
            break;

        case MESH_EVENT_PARENT_DISCONNECTED:
            Serial.println("❌ Потеряна связь с родителем");
            break;

        case MESH_EVENT_NO_PARENT_FOUND:
            Serial.println("⚠️ Родительский узел не найден");
            break;

        case MESH_EVENT_CHILD_CONNECTED:
            Serial.printf("👶 Новый дочерний узел подключён\n");
            break;

        case MESH_EVENT_CHILD_DISCONNECTED:
            Serial.printf("👋 Дочерний узел отключился\n");
            break;

        case MESH_EVENT_ROUTING_TABLE_CHANGE:
            Serial.println("🗺️ Таблица маршрутизации обновлена");
            break;

        default:
            break;
    }
}

void setup() {
    Serial.begin(115200);
    Serial.println("\n=== MeshCore Node ===");

    // Инициализация WiFi в режиме mesh
    WiFi.mode(WIFI_MODE_APSTA);

    // Конфигурация mesh-сети
    mesh_cfg_t cfg = {0};
    cfg.channel = MESH_CHANNEL;
    cfg.router.ssid = MESH_SSID;
    cfg.router.password = MESH_PASSWORD;
    cfg.mesh_id = {0x77, 0x77, 0x77, 0x77, 0x77, 0x77};
    cfg.mesh_ap.max_connection = 6;
    cfg.crypto_funcs = &g_wifi_default_mesh_crypto_funcs;

    // Инициализация MeshCore
    if (mesh.init(&cfg)) {
        Serial.println("✅ MeshCore инициализирован");
    } else {
        Serial.println("❌ Ошибка инициализации MeshCore");
        return;
    }

    // Установка callback-функций
    mesh.onReceive(onReceive);
    mesh.onEvent(onMeshEvent);

    // Запуск mesh-сети
    mesh.start();

    Serial.println("🚀 Mesh-сеть запущена, ожидание подключения...");
}

void loop() {
    // Обработка mesh-событий
    mesh.loop();

    // Периодическая отправка статуса
    uint32_t now = millis();
    if (now - lastSendTime > SEND_INTERVAL) {
        lastSendTime = now;

        char status[128];
        snprintf(status, sizeof(status),
            "Heartbeat from %s | Layer: %d | RSSI: %d dBm | FreeMem: %d",
            WiFi.macAddress().c_str(),
            nodeLayer,
            WiFi.RSSI(),
            ESP.getFreeHeap()
        );

        if (mesh.send((const uint8_t*)status, strlen(status))) {
            Serial.printf("📤 Отправлен heartbeat\n");
        }
    }

    delay(100);
}

/*
 * ESP-MESH — Продвинутый пример с ESP-IDF
 *
 * Демонстрирует:
 *   - Создание mesh-сети с ESP-MESH
 *   - Обработку событий сети
 *   - Передачу данных между узлами
 *   - OTA-обновления через mesh
 *   - Мониторинг состояния сети
 */

#include <string.h>
#include <esp_log.h>
#include <esp_wifi.h>
#include <esp_event.h>
#include <esp_mesh.h>
#include <esp_mesh_internal.h>
#include <nvs_flash.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <freertos/queue.h>

static const char* TAG = "mesh_main";

// Конфигурация
#define MESH_SSID      "ESP-MESH-NET"
#define MESH_PASSWD    "meshpassword"
#define MESH_PORT      5555
#define RX_SIZE        1500
#define TX_SIZE        1500
#define MESH_CHANNEL   6

// Глобальные переменные
static bool is_mesh_connected = false;
static mesh_addr_t mesh_parent_addr;
static int mesh_layer = -1;
static esp_netif_t* netif_sta = NULL;
static esp_netif_t* netif_ap = NULL;

// Очередь сообщений
static QueueHandle_t mesh_msg_queue;

// Структура сообщения
typedef struct {
    mesh_addr_t from;
    uint8_t data[RX_SIZE];
    int len;
    mesh_data_t mesh_data;
} mesh_message_t;

// ============================================
// WiFi Event Handler
// ============================================
static void wifi_event_handler(void* arg,
    esp_event_base_t event_base,
    int32_t event_id,
    void* event_data)
{
    if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {
        ESP_LOGI(TAG, "WiFi STA started");
    } else if (event_base == WIFI_EVENT &&
               event_id == WIFI_EVENT_STA_DISCONNECTED) {
        ESP_LOGI(TAG, "WiFi STA disconnected");
        is_mesh_connected = false;
    }
}

// ============================================
// IP Event Handler
// ============================================
static void ip_event_handler(void* arg,
    esp_event_base_t event_base,
    int32_t event_id,
    void* event_data)
{
    if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
        ip_event_got_ip_t* event = (ip_event_got_ip_t*)event_data;
        ESP_LOGI(TAG, "Got IP: " IPSTR,
            IP2STR(&event->ip_info.ip));
    }
}

// ============================================
// Mesh Event Handler
// ============================================
static void mesh_event_handler(void* arg,
    esp_event_base_t event_base,
    int32_t event_id,
    void* event_data)
{
    mesh_event_t* event = (mesh_event_t*)event_data;

    switch (event_id) {
    case MESH_EVENT_STARTED: {
        ESP_LOGI(TAG,
            "MESH_EVENT_STARTED: Mesh network initialized");
        break;
    }

    case MESH_EVENT_STOPPED: {
        ESP_LOGI(TAG,
            "MESH_EVENT_STOPPED: Mesh network stopped");
        is_mesh_connected = false;
        break;
    }

    case MESH_EVENT_CHILD_CONNECTED: {
        mesh_event_child_connected_t* child_connected =
            (mesh_event_child_connected_t*)event_data;
        ESP_LOGI(TAG,
            "MESH_EVENT_CHILD_CONNECTED: child " MACSTR
            " at layer %d",
            MAC2STR(child_connected->mac),
            child_connected->self_layer);
        break;
    }

    case MESH_EVENT_CHILD_DISCONNECTED: {
        mesh_event_child_disconnected_t* child_disconnected =
            (mesh_event_child_disconnected_t*)event_data;
        ESP_LOGI(TAG,
            "MESH_EVENT_CHILD_DISCONNECTED: child " MACSTR,
            MAC2STR(child_disconnected->mac));
        break;
    }

    case MESH_EVENT_ROUTING_TABLE_CHANGE: {
        mesh_event_routing_table_change_t* routing =
            (mesh_event_routing_table_change_t*)event_data;
        ESP_LOGI(TAG,
            "MESH_EVENT_ROUTING_TABLE_CHANGE: size %d, capacity %d",
            routing->rt_size, routing->rt_capacity);
        break;
    }

    case MESH_EVENT_PARENT_CONNECTED: {
        mesh_event_connected_t* connected =
            (mesh_event_connected_t*)event_data;
        is_mesh_connected = true;
        mesh_layer = connected->self_layer;
        memcpy(&mesh_parent_addr, &connected->parent_bssid,
            sizeof(mesh_addr_t));
        ESP_LOGI(TAG,
            "MESH_EVENT_PARENT_CONNECTED: layer %d, parent " MACSTR,
            mesh_layer, MAC2STR(connected->parent_bssid));
        break;
    }

    case MESH_EVENT_PARENT_DISCONNECTED: {
        ESP_LOGI(TAG,
            "MESH_EVENT_PARENT_DISCONNECTED");
        is_mesh_connected = false;
        mesh_layer = -1;
        break;
    }

    case MESH_EVENT_NO_PARENT_FOUND: {
        ESP_LOGI(TAG,
            "MESH_EVENT_NO_PARENT_FOUND: scan done, %d APs found",
            event->info.no_parent.scan_size);
        break;
    }

    case MESH_EVENT_ROOT_ADDRESS: {
        mesh_event_root_address_t* root_addr =
            (mesh_event_root_address_t*)event_data;
        ESP_LOGI(TAG,
            "MESH_EVENT_ROOT_ADDRESS: root " MACSTR,
            MAC2STR(root_addr->addr));
        break;
    }

    case MESH_EVENT_TODS_STATE: {
        mesh_event_toDS_state_t* toDs_state =
            (mesh_event_toDS_state_t*)event_data;
        ESP_LOGI(TAG,
            "MESH_EVENT_TODS_STATE: %d", *toDs_state);
        break;
    }

    default:
        ESP_LOGI(TAG, "Mesh event: %ld", event_id);
        break;
    }
}

// ============================================
// TX Task — отправка данных
// ============================================
static void mesh_tx_task(void* arg)
{
    mesh_data_t data;
    uint8_t tx_buf[TX_SIZE] = {0};
    int tx_count = 0;

    data.data = tx_buf;
    data.size = 0;
    data.proto = MESH_PROTO_BIN;
    data.tos = MESH_TOS_P2P;

    while (1) {
        // Формирование сообщения
        int len = snprintf((char*)tx_buf, TX_SIZE,
            "{"
            "\"node\":\"%s\","
            "\"layer\":%d,"
            "\"seq\":%d,"
            "\"rssi\":%d,"
            "\"heap\":%lu,"
            "\"uptime\":%lu"
            "}",
            "ESP32-Node",
            mesh_layer,
            tx_count++,
            esp_wifi_sta_get_ap_info(NULL) == ESP_OK ?
                esp_wifi_get_rssi() : 0,
            (unsigned long)esp_get_free_heap_size(),
            (unsigned long)(xTaskGetTickCount() * portTICK_PERIOD_MS / 1000)
        );

        data.size = len;

        // Отправка родительскому узлу (вверх по дереву)
        esp_err_t err = esp_mesh_send(
            NULL,        // NULL = отправить родителю
            &data,
            MESH_DATA_TODS,  // Направление: к корню
            NULL,
            0
        );

        if (err == ESP_OK) {
            ESP_LOGI(TAG, "TX: sent %d bytes, seq=%d", len, tx_count);
        } else {
            ESP_LOGW(TAG, "TX: failed, err=%d", err);
        }

        vTaskDelay(5000 / portTICK_PERIOD_MS);
    }
}

// ============================================
// RX Task — приём данных
// ============================================
static void mesh_rx_task(void* arg)
{
    mesh_data_t data;
    uint8_t rx_buf[RX_SIZE] = {0};
    int flag = 0;

    data.data = rx_buf;
    data.size = RX_SIZE;

    while (1) {
        mesh_addr_t from;
        data.size = RX_SIZE;

        esp_err_t err = esp_mesh_recv(
            &from,
            &data,
            portMAX_DELAY,
            &flag,
            NULL,
            0
        );

        if (err == ESP_OK) {
            // Обработка полученного сообщения
            ESP_LOGI(TAG,
                "RX: %d bytes from " MACSTR ", flag=0x%04x",
                data.size, MAC2STR(from.addr), flag);

            // Парсинг JSON-сообщения
            if (data.proto == MESH_PROTO_BIN) {
                char msg_str[RX_SIZE] = {0};
                memcpy(msg_str, data.data,
                    min(data.size, RX_SIZE - 1));
                ESP_LOGI(TAG, "RX data: %s", msg_str);

                // Отправка в очередь для дальнейшей обработки
                mesh_message_t msg;
                msg.from = from;
                msg.len = data.size;
                memcpy(msg.data, data.data, data.size);
                xQueueSend(mesh_msg_queue, &msg, 0);
            }
        } else {
            ESP_LOGW(TAG, "RX: error=%d", err);
        }
    }
}

// ============================================
// Network Monitor Task
// ============================================
static void mesh_monitor_task(void* arg)
{
    while (1) {
        int layer = -1;
        int node_count = 0;
        mesh_assoc_t assoc;

        // Получение текущего уровня
        esp_mesh_get_layer(&layer);

        // Получение количества дочерних узлов
        esp_mesh_get_routing_table_size(&node_count);

        // Получение информации о родителе
        esp_mesh_get_parent_bssid(&assoc);

        ESP_LOGI(TAG,
            "📊 Network: layer=%d, nodes=%d, parent_rssi=%d, heap=%lu",
            layer,
            node_count,
            assoc.rssi,
            (unsigned long)esp_get_free_heap_size()
        );

        vTaskDelay(10000 / portTICK_PERIOD_MS);
    }
}

// ============================================
// Main — app_main
// ============================================
void app_main(void)
{
    // Инициализация NVS
    esp_err_t ret = nvs_flash_init();
    if (ret == ESP_ERR_NVS_NO_FREE_PAGES ||
        ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
        nvs_flash_erase();
        nvs_flash_init();
    }

    // Инициализация сетевого стека
    esp_netif_init();
    esp_event_loop_create_default();

    // Создание сетевых интерфейсов
    netif_sta = esp_netif_create_default_wifi_sta();
    netif_ap = esp_netif_create_default_wifi_ap();

    // Инициализация WiFi
    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    esp_wifi_init(&cfg);

    // Регистрация обработчиков событий
    esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID,
        &wifi_event_handler, NULL);
    esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP,
        &ip_event_handler, NULL);
    esp_event_handler_register(MESH_EVENT, ESP_EVENT_ANY_ID,
        &mesh_event_handler, NULL);

    // Конфигурация mesh
    mesh_cfg_t mesh_cfg = {0};
    uint8_t mesh_id[6] = {0x77, 0x77, 0x77,
                              0x77, 0x77, 0x77};

    mesh_cfg.channel = MESH_CHANNEL;
    mesh_cfg.router.ssid = MESH_SSID;
    mesh_cfg.router.password = MESH_PASSWD;
    memcpy(&mesh_cfg.mesh_id, mesh_id, 6);
    mesh_cfg.mesh_ap.max_connection = 10;

    // Запуск mesh
    esp_mesh_init();
    esp_mesh_set_config(&mesh_cfg);
    esp_mesh_start();

    // Создание очереди сообщений
    mesh_msg_queue = xQueueCreate(32, sizeof(mesh_message_t));

    // Запуск задач
    xTaskCreate(mesh_tx_task, "mesh_tx",
        4096, NULL, 5, NULL);
    xTaskCreate(mesh_rx_task, "mesh_rx",
        4096, NULL, 5, NULL);
    xTaskCreate(mesh_monitor_task, "mesh_mon",
        4096, NULL, 3, NULL);

    ESP_LOGI(TAG, "🚀 MeshCore node started!");
}

# Установка Reticulum через pip
$ pip install rns

# Установка LXMF (протокол сообщений)
$ pip install lxmf

# Установка Sideband (CLI-клиент)
$ pip install sideband

# Установка Nomad Network (mesh-браузер)
$ pip install nomadnet

# Установка Reticulum Utilities
$ pip install rnsh

# Проверка установки
$ rns --version
# Reticulum Network Stack 0.7.2

# Инициализация (создаёт конфигурацию и ключи)
$ rns --init

# Запуск Reticulum в фоновом режиме
$ rnsd

# Запуск с выводом логов
$ rnsd -v

# Запуск с максимальным уровнем логирования
$ rnsd -vvv

# ============================================
# Reticulum Network Stack Configuration
# ============================================

# Основные настройки
[reticulum]
# Включить режим transport-узла (ретрансляция)
enable_transport = true

# Share instance statistics
share_instance = true

# Порт TCP-интерфейса (для входящих подключений)
shared_instance_port = 37428

# ============================================
# Интерфейсы
# ============================================

# --- LoRa через RNode (Serial) ---
[[interfaces]]
  [[rnode_lora]]
    # Тип интерфейса
    type = RNodeInterface

    # Serial-порт устройства RNode
    port = /dev/ttyUSB0

    # Скорость serial-соединения
    speed = 115200

    # Частота LoRa (868 МГц для Европы)
    frequency = 868500000

    # Ширина полосы
    bandwidth = 125000

    # Spreading Factor
    txpower = 17

    # Spreading Factor
    spreadingfactor = 10

    # Coding Rate
    codingrate = 5

    # Airtime limit (для соблюдения duty cycle)
    airtime_limit = 1.0

# --- WiFi (TCP/IP Server) ---
[[interfaces]]
  [[tcp_server]]
    type = TCPServerInterface
    listen_port = 4242

# --- WiFi (TCP/IP Client к другому узлу) ---
[[interfaces]]
  [[tcp_client]]
    type = TCPClientInterface
    target_host = 192.168.1.100
    target_port = 4242

# --- I2P Interface (для анонимной маршрутизации) ---
[[interfaces]]
  [[i2p_interface]]
    type = I2PInterface
    peers = "i2p_address_1.b32.i2p,i2p_address_2.b32.i2p"

# --- Serial Interface (прямое подключение) ---
[[interfaces]]
  [[serial_interface]]
    type = SerialInterface
    port = /dev/ttyUSB1
    speed = 9600

# --- UDP Interface ---
[[interfaces]]
  [[udp_interface]]
    type = UDPInterface
    listen_port = 2971
    forward_port = 2971

# ============================================
# LXMF Configuration
# ============================================

[lxmf]
# Propagation node settings
propagation_node = false

# Если true, этот узел будет хранить и
# пересылать LXMF-сообщения для других
offer_propagation = false

# Максимальный размер хранилища (в байтах)
propagation_storage_limit = 104857600  # 100 MB

# Интервал синхронизации (секунды)
propagation_sync_interval = 3600

"""
Reticulum — Базовое приложение для обмена сообщениями

Этот пример демонстрирует:
  - Создание Reticulum-идентичности
  - Объявление сервиса (announce)
  - Установление зашифрованного линка
  - Отправку и приём сообщений
  - Обработку входящих соединений
"""

import RNS
import time
import sys
import threading


class MeshMessenger:
    """
    Простой мессенджер поверх Reticulum Network Stack.
    Поддерживает обнаружение пиров, зашифрованную связь
    и асинхронный обмен сообщениями.
    """

    # Аспект приложения (имя сервиса в сети Reticulum)
    APP_NAME = "meshmessenger"
    APP_ASPECT = "messenger.example"

    def __init__(self, identity_path=None):
        """
        Инициализация мессенджера.

        Args:
            identity_path: Путь к файлу идентичности.
                          Если None, создаётся новая.
        """
        self.reticulum = None
        self.identity = None
        self.destination = None
        self.active_links = {}
        self.message_history = []
        self.known_peers = {}

        # Инициализация Reticulum
        self._init_reticulum(identity_path)

    def _init_reticulum(self, identity_path):
        """Инициализация Reticulum Network Stack."""
        try:
            # Создание или загрузка идентичности
            if identity_path:
                self.identity = RNS.Identity.from_file(identity_path)
                RNS.log("Загружена существующая идентичность")
            else:
                self.identity = RNS.Identity()
                RNS.log("Создана новая идентичность")

            # Инициализация Reticulum
            self.reticulum = RNS.Reticulum()

            # Создание Destination (адреса в сети)
            self.destination = RNS.Destination(
                self.identity,
                RNS.Destination.IN,
                RNS.Destination.SINGLE,
                self.APP_NAME,
                self.APP_ASPECT
            )

            # Установка обработчика входящих линков
            self.destination.set_link_established_callback(
                self.on_link_established
            )

            # Установка обработчика входящих данных
            self.destination.set_packet_callback(
                self.on_packet
            )

            # Объявление сервиса в сети
            self.destination.announce()

            RNS.log(f"🟢 Мессенджер запущен")
            RNS.log(f"📡 Адрес: {self.destination.hash.hex()}")
            RNS.log(f"🔑 Публичный ключ: {self.identity.hash.hex()[:16]}...")

        except Exception as e:
            RNS.log(f"❌ Ошибка инициализации: {e}")
            raise

    def announce(self):
        """Отправка объявления в сеть."""
        self.destination.announce(
            app_data="MeshMessenger Node Online".encode("utf-8")
        )
        RNS.log("📢 Announce отправлен")

    def discover_peers(self):
        """
        Обнаружение пиров в сети.
        Сканирует сеть на наличие других узлов мессенджера.
        """
        RNS.log("🔍 Поиск пиров...")

        # Получение списка известных announce
        for dest_hash, announce_data in \
                RNS.Transport.destination_table().items():

            if announce_data["aspect"] == self.APP_ASPECT:
                peer_hash = dest_hash.hex()
                self.known_peers[peer_hash] = announce_data
                RNS.log(f"  👤 Найден пир: {peer_hash[:16]}...")

        RNS.log(f"✅ Найдено {len(self.known_peers)} пиров")
        return self.known_peers

    def send_message(self, dest_hash, message):
        """
        Отправка зашифрованного сообщения.

        Args:
            dest_hash: Хеш адреса получателя (hex string)
            message: Текст сообщения
        """
        try:
            # Создание destination получателя
            dest_bytes = bytes.fromhex(dest_hash)
            peer_identity = RNS.Identity.recall(dest_bytes)

            if peer_identity is None:
                RNS.log("❌ Идентичность получателя неизвестна")
                RNS.log("   Ожидание announce от получателя...")
                return False

            # Создание destination получателя
            peer_dest = RNS.Destination(
                peer_identity,
                RNS.Destination.OUT,
                RNS.Destination.SINGLE,
                self.APP_NAME,
                self.APP_ASPECT
            )

            # Установление зашифрованного линка
            link = RNS.Link(peer_dest)
            link.set_link_established_callback(
                self.on_link_established
            )

            RNS.log(f"🔗 Установление линка с {dest_hash[:16]}...")

            # Ожидание установления линка
            timeout = 15
            while not link.status() == RNS.Link.ACTIVE:
                time.sleep(0.5)
                timeout -= 0.5
                if timeout <= 0:
                    RNS.log("❌ Таймаут установления линка")
                    return False

            RNS.log("✅ Линк установлен (зашифрован)")

            # Отправка сообщения через линк
            packet = RNS.Packet(
                link,
                message.encode("utf-8")
            )
            packet.send()

            RNS.log(f"📤 Отправлено: {message}")

            # Сохранение в истории
            self.message_history.append({
                "direction": "out",
                "peer": dest_hash,
                "message": message,
                "time": time.time()
            })

            return True

        except Exception as e:
            RNS.log(f"❌ Ошибка отправки: {e}")
            return False

    def on_packet(self, message, packet):
        """Обработчик входящих пакетов."""
        try:
            text = message.decode("utf-8")
            sender = packet.link.destination.hash.hex()

            RNS.log(f"💬 Сообщение от {sender[:16]}: {text}")

            self.message_history.append({
                "direction": "in",
                "peer": sender,
                "message": text,
                "time": time.time()
            })

        except Exception as e:
            RNS.log(f"❌ Ошибка обработки пакета: {e}")

    def on_link_established(self, link):
        """Обработчик установления линка."""
        link_hash = link.link_id.hex()
        self.active_links[link_hash] = link

        RNS.log(f"🔗 Линк установлен: {link_hash[:16]}")

        # Установка обработчика входящих данных для линка
        link.set_packet_callback(self.on_packet)
        link.set_link_closed_callback(self.on_link_closed)

    def on_link_closed(self, link):
        """Обработчик закрытия линка."""
        link_hash = link.link_id.hex()
        if link_hash in self.active_links:
            del self.active_links[link_hash]
        RNS.log(f"🔌 Линк закрыт: {link_hash[:16]}")

    def get_status(self):
        """Получение статуса узла."""
        return {
            "address": self.destination.hash.hex(),
            "known_peers": len(self.known_peers),
            "active_links": len(self.active_links),
            "messages": len(self.message_history),
            "interfaces": len(self.reticulum.interfaces)
        }


# === Пример использования ===
if __name__ == "__main__":
    # Создание мессенджера
    messenger = MeshMessenger()

    # Периодическое объявление
    def announce_loop():
        while True:
            messenger.announce()
            time.sleep(300)  # каждые 5 минут

    announce_thread = threading.Thread(
        target=announce_loop, daemon=True
    )
    announce_thread.start()

    # Основной цикл
    try:
        while True:
            # Обнаружение пиров
            peers = messenger.discover_peers()

            # Отправка тестового сообщения первому найденному пиру
            if peers:
                first_peer = list(peers.keys())[0]
                messenger.send_message(
                    first_peer,
                    "Привет из Reticulum! 🔐"
                )

            # Вывод статуса
            status = messenger.get_status()
            RNS.log(f"📊 Статус: {status}")

            time.sleep(60)

    except KeyboardInterrupt:
        RNS.log("\n👋 Завершение работы...")
        sys.exit(0)

"""
LXMF — Пример отправки и получения сообщений

LXMF (Lightweight Extensible Message Format) — протокол
асинхронного обмена сообщениями поверх Reticulum.
"""

import RNS
import LXMF
import time


def lxmf_delivery_callback(message):
    """Обработчик доставленного сообщения."""
    print(f"✅ Сообщение доставлено: {message.hash.hex()[:16]}")


def lxmf_failed_callback(message):
    """Обработчик недоставленного сообщения."""
    print(f"❌ Не удалось доставить: {message.hash.hex()[:16]}")


def lxmf_incoming(message):
    """Обработчик входящего LXMF-сообщения."""
    source = message.source_hash.hex()
    content = message.content.decode("utf-8")
    title = message.title.decode("utf-8")
    timestamp = message.timestamp

    print(f"\n📬 Новое сообщение!")
    print(f"   От:      {source[:16]}...")
    print(f"   Тема:    {title}")
    print(f"   Текст:   {content}")
    print(f"   Время:   {time.ctime(timestamp)}")
    print(f"   Размер:  {len(content)} байт")


# Инициализация Reticulum
reticulum = RNS.Reticulum()

# Создание идентичности пользователя
user_identity = RNS.Identity()

# Создание LXMF-роутера
lxmf_router = LXMF.LXMRouter(
    identity=user_identity,
    storagepath="./lxmf_storage"
)

# Создание LXMF-адреса (destination)
lxmf_destination = lxmf_router.register_delivery_identity(
    user_identity,
    display_name="MyLXMFNode"
)

# Установка обработчика входящих сообщений
lxmf_router.register_delivery_callback(lxmf_incoming)

# Объявление LXMF-сервиса
lxmf_router.announce(lxmf_destination)

print(f"📡 LXMF-адрес: {lxmf_destination.hex()}")
print(f"🔑 Имя: MyLXMFNode")

# Отправка LXMF-сообщения
# (нужно знать LXMF-адрес получателя)
dest_lxmf_addr = "a1b2c3d4e5f6..."  # адрес получателя

dest_bytes = bytes.fromhex(dest_lxmf_addr)
dest_identity = RNS.Identity.recall(dest_bytes)

if dest_identity:
    # Создание сообщения
    lxmessage = LXMF.LXMessage(
        destination=dest_identity,
        source=user_identity,
        content="Привет! Это тестовое сообщение через LXMF 📨",
        title="Тест LXMF",
        desired_method=LXMF.LXMessage.DIRECT
    )

    # Установка callback-функций
    lxmessage.set_delivery_callback(lxmf_delivery_callback)
    lxmessage.set_failed_callback(lxmf_failed_callback)

    # Отправка
    lxmf_router.handle_outbound(lxmessage)
    print("📤 Сообщение отправлено!")
else:
    print("❌ Идентичность получателя неизвестна")
    print("   Подождите announce от получателя")

# Ожидание сообщений
try:
    while True:
        time.sleep(1)
except KeyboardInterrupt:
    print("\n👋 Завершение...")