espnow_manager.h

#ifndef ESPNOW_MANAGER_H
#define ESPNOW_MANAGER_H

#include "espnow_protocol.h"
#include <esp_now.h>
#include <esp_wifi.h>
#include <functional>
#include <vector>
#include <string>
#include <mutex>
#include <map>

namespace espnow {

// Peer device information
struct PeerDevice {
    uint8_t mac[6];
    std::string uuid;
    std::string name;
    std::string agentmail_inbox;
    int8_t rssi;
    uint32_t last_seen;      // Timestamp in milliseconds
    bool paired;
    uint32_t paired_time;    // When pairing occurred
};

// Callback types
using OnPairingRequestCallback = std::function<void(const uint8_t* mac, const PairingRequestPayload& payload)>;
using OnPairingResponseCallback = std::function<void(const uint8_t* mac, const PairingResponsePayload& payload)>;
using OnTextMessageCallback = std::function<void(const uint8_t* mac, const TextMessagePayload& payload)>;
using OnMetadataUpdateCallback = std::function<void(const uint8_t* mac, const MetadataUpdatePayload& payload)>;
using OnHeartbeatCallback = std::function<void(const uint8_t* mac, const HeartbeatPayload& payload)>;
using OnUnpairCallback = std::function<void(const uint8_t* mac, const UnpairPayload& payload)>;
using OnSendCallback = std::function<void(const uint8_t* mac, esp_now_send_status_t status)>;

class EspNowManager {
public:
    // Singleton pattern
    static EspNowManager& GetInstance() {
        static EspNowManager instance;
        return instance;
    }

    // Delete copy constructor and assignment operator
    EspNowManager(const EspNowManager&) = delete;
    EspNowManager& operator=(const EspNowManager&) = delete;

    // Initialize ESP-NOW
    // Must be called after WiFi is initialized
    bool Initialize();

    // Shutdown ESP-NOW
    void Shutdown();

    // Check if initialized
    bool IsInitialized() const { return initialized_; }

    // Peer management
    bool AddPeer(const uint8_t* mac, uint8_t channel = 0, bool encrypt = false);
    bool RemovePeer(const uint8_t* mac);
    bool HasPeer(const uint8_t* mac) const;
    bool GetPeerInfo(const uint8_t* mac, PeerDevice& peer) const;
    std::vector<PeerDevice> GetAllPeers() const;
    std::vector<PeerDevice> GetPairedDevices() const;
    size_t GetPeerCount() const;
    void ClearAllPeers();

    // Send messages
    bool SendPairingRequest(
        const uint8_t* peer_mac,
        const std::string& device_uuid,
        const std::string& device_name,
        const std::string& agentmail_inbox,
        int8_t rssi);

    bool SendPairingResponse(
        const uint8_t* peer_mac,
        const std::string& device_uuid,
        const std::string& device_name,
        const std::string& agentmail_inbox,
        bool accepted);

    bool SendTextMessage(
        const uint8_t* peer_mac,
        const std::string& sender_uuid,
        const std::string& sender_name,
        const std::string& text);

    bool SendMetadataUpdate(
        const uint8_t* peer_mac,
        const std::string& device_uuid,
        const std::string& device_name,
        const std::string& agentmail_inbox);

    bool SendHeartbeat(
        const uint8_t* peer_mac,
        uint32_t uptime_seconds,
        int8_t rssi,
        uint8_t battery_level);

    bool SendUnpair(
        const uint8_t* peer_mac,
        const std::string& device_uuid,
        uint8_t reason = 0);

    // Broadcast to all paired peers
    bool BroadcastTextMessage(
        const std::string& sender_uuid,
        const std::string& sender_name,
        const std::string& text);

    // Callback registration
    void OnPairingRequest(OnPairingRequestCallback callback);
    void OnPairingResponse(OnPairingResponseCallback callback);
    void OnTextMessage(OnTextMessageCallback callback);
    void OnMetadataUpdate(OnMetadataUpdateCallback callback);
    void OnHeartbeat(OnHeartbeatCallback callback);
    void OnUnpair(OnUnpairCallback callback);
    void OnSend(OnSendCallback callback);

    // Get local MAC address
    bool GetLocalMacAddress(uint8_t* mac) const;
    std::string GetLocalMacString() const;

    // Utility functions
    static std::string MacToString(const uint8_t* mac);
    static bool StringToMac(const std::string& str, uint8_t* mac);

private:
    EspNowManager();
    ~EspNowManager();

    // ESP-NOW callbacks (static for C API compatibility)
    static void EspNowReceiveCallback(const esp_now_recv_info_t* recv_info, const uint8_t* data, int len);
    static void EspNowSendCallback(const uint8_t* mac, esp_now_send_status_t status);  // IDF < 5.5
    static void EspNowSendCallbackV2(const wifi_tx_info_t* tx_info, esp_now_send_status_t status);  // IDF >= 5.5

    // Instance methods for handling callbacks
    void HandleReceive(const uint8_t* mac, const uint8_t* data, int len);
    void HandleSend(const uint8_t* mac, esp_now_send_status_t status);

    // Internal send method
    bool SendMessage(const uint8_t* peer_mac, const Message& msg);

    // Peer tracking
    void UpdatePeerInfo(const uint8_t* mac, const std::string& uuid,
                       const std::string& name, const std::string& inbox,
                       int8_t rssi, bool paired);
    void RemovePeerInfo(const uint8_t* mac);

    // State
    bool initialized_;
    mutable std::mutex mutex_;
    
    // Peer database
    std::map<std::string, PeerDevice> peers_;  // Key: MAC address as string

    // Callbacks
    OnPairingRequestCallback on_pairing_request_;
    OnPairingResponseCallback on_pairing_response_;
    OnTextMessageCallback on_text_message_;
    OnMetadataUpdateCallback on_metadata_update_;
    OnHeartbeatCallback on_heartbeat_;
    OnUnpairCallback on_unpair_;
    OnSendCallback on_send_;

    // Local MAC address
    uint8_t local_mac_[6];
};

} // namespace espnow

#endif // ESPNOW_MANAGER_H