//go:build use_nwaku
// +build use_nwaku

package wakuv2

/*
	#cgo LDFLAGS: -L../third_party/nwaku/build/ -lnegentropy -lwaku
	#cgo LDFLAGS: -L../third_party/nwaku -Wl,-rpath,../third_party/nwaku/build/

	#include "../third_party/nwaku/library/libwaku.h"
	#include <stdio.h>
	#include <stdlib.h>

	extern void globalEventCallback(int ret, char* msg, size_t len, void* userData);

	typedef struct {
		int ret;
		char* msg;
		size_t len;
	} Resp;

	static void* allocResp() {
		return calloc(1, sizeof(Resp));
	}

	static void freeResp(void* resp) {
		if (resp != NULL) {
			free(resp);
		}
	}

	static char* getMyCharPtr(void* resp) {
		if (resp == NULL) {
			return NULL;
		}
		Resp* m = (Resp*) resp;
		return m->msg;
	}

	static size_t getMyCharLen(void* resp) {
		if (resp == NULL) {
			return 0;
		}
		Resp* m = (Resp*) resp;
		return m->len;
	}

	static int getRet(void* resp) {
		if (resp == NULL) {
			return 0;
		}
		Resp* m = (Resp*) resp;
		return m->ret;
	}

	// resp must be set != NULL in case interest on retrieving data from the callback
	static void callback(int ret, char* msg, size_t len, void* resp) {
		printf("---------- GABRIEL calling callback 1 ----\n");
		if (resp != NULL) {
			printf("---------- GABRIEL calling callback 2 ----\n");
			Resp* m = (Resp*) resp;
			m->ret = ret;
			m->msg = msg;
			m->len = len;
		}
	}

	#define WAKU_CALL(call)                                                        \
	do {                                                                           \
		printf("---------- GABRIEL calling WAKU_CALL 1 ----\n"); 						\
		int ret = call;                                                              \
		if (ret != 0) {                                                              \
			printf("Failed the call to: %s. Returned code: %d\n", #call, ret);         \
			exit(1);                                                                   \
		}                                                                            \
	} while (0)

	static void* cGoWakuNew(const char* configJson, void* resp) {
		// We pass NULL because we are not interested in retrieving data from this callback
		void* ret = waku_new(configJson, (WakuCallBack) callback, resp);
		return ret;
	}

	static void cGoWakuStart(void* wakuCtx, void* resp) {
		WAKU_CALL(waku_start(wakuCtx, (WakuCallBack) callback, resp));
	}

	static void cGoWakuStop(void* wakuCtx, void* resp) {
		WAKU_CALL(waku_stop(wakuCtx, (WakuCallBack) callback, resp));
	}

	static void cGoWakuDestroy(void* wakuCtx, void* resp) {
		WAKU_CALL(waku_destroy(wakuCtx, (WakuCallBack) callback, resp));
	}

	static void cGoWakuStartDiscV5(void* wakuCtx, void* resp) {
		WAKU_CALL(waku_start_discv5(wakuCtx, (WakuCallBack) callback, resp));
	}

	static void cGoWakuStopDiscV5(void* wakuCtx, void* resp) {
		WAKU_CALL(waku_stop_discv5(wakuCtx, (WakuCallBack) callback, resp));
	}

	static void cGoWakuVersion(void* wakuCtx, void* resp) {
		WAKU_CALL(waku_version(wakuCtx, (WakuCallBack) callback, resp));
	}

	static void cGoWakuSetEventCallback(void* wakuCtx) {
		// The 'globalEventCallback' Go function is shared amongst all possible Waku instances.

		// Given that the 'globalEventCallback' is shared, we pass again the
		// wakuCtx instance but in this case is needed to pick up the correct method
		// that will handle the event.

		// In other words, for every call the libwaku makes to globalEventCallback,
		// the 'userData' parameter will bring the context of the node that registered
		// that globalEventCallback.

		// This technique is needed because cgo only allows to export Go functions and not methods.

		waku_set_event_callback(wakuCtx, (WakuCallBack) globalEventCallback, wakuCtx);
	}

	static void cGoWakuContentTopic(void* wakuCtx,
							char* appName,
							int appVersion,
							char* contentTopicName,
							char* encoding,
							void* resp) {

		WAKU_CALL( waku_content_topic(wakuCtx,
							appName,
							appVersion,
							contentTopicName,
							encoding,
							(WakuCallBack) callback,
							resp) );
	}

	static void cGoWakuPubsubTopic(void* wakuCtx, char* topicName, void* resp) {
		WAKU_CALL( waku_pubsub_topic(wakuCtx, topicName, (WakuCallBack) callback, resp) );
	}

	static void cGoWakuDefaultPubsubTopic(void* wakuCtx, void* resp) {
		WAKU_CALL (waku_default_pubsub_topic(wakuCtx, (WakuCallBack) callback, resp));
	}

	static void cGoWakuRelayPublish(void* wakuCtx,
                       const char* pubSubTopic,
                       const char* jsonWakuMessage,
                       int timeoutMs,
					   void* resp) {

		WAKU_CALL (waku_relay_publish(wakuCtx,
                       pubSubTopic,
                       jsonWakuMessage,
                       timeoutMs,
                       (WakuCallBack) callback,
                       resp));
	}

	static void cGoWakuRelaySubscribe(void* wakuCtx, char* pubSubTopic, void* resp) {
		WAKU_CALL ( waku_relay_subscribe(wakuCtx,
							pubSubTopic,
							(WakuCallBack) callback,
							resp) );
	}

	static void cGoWakuRelayUnsubscribe(void* wakuCtx, char* pubSubTopic, void* resp) {

		WAKU_CALL ( waku_relay_unsubscribe(wakuCtx,
							pubSubTopic,
							(WakuCallBack) callback,
							resp) );
	}

	static void cGoWakuConnect(void* wakuCtx, char* peerMultiAddr, int timeoutMs, void* resp) {
		WAKU_CALL( waku_connect(wakuCtx,
						peerMultiAddr,
						timeoutMs,
						(WakuCallBack) callback,
						resp) );
	}

	static void cGoWakuListenAddresses(void* wakuCtx, void* resp) {
		WAKU_CALL (waku_listen_addresses(wakuCtx, (WakuCallBack) callback, resp) );
	}

	static void cGoWakuGetMyENR(void* ctx, void* resp) {
		WAKU_CALL (waku_get_my_enr(ctx, (WakuCallBack) callback, resp) );
	}

	static void cGoWakuListPeersInMesh(void* ctx, char* pubSubTopic, void* resp) {
		WAKU_CALL (waku_relay_get_num_peers_in_mesh(ctx, pubSubTopic, (WakuCallBack) callback, resp) );
	}

	static void cGoWakuGetNumConnectedPeers(void* ctx, char* pubSubTopic, void* resp) {
		WAKU_CALL (waku_relay_get_num_connected_peers(ctx, pubSubTopic, (WakuCallBack) callback, resp) );
	}

	static void cGoWakuLightpushPublish(void* wakuCtx,
					const char* pubSubTopic,
					const char* jsonWakuMessage,
					void* resp) {

		WAKU_CALL (waku_lightpush_publish(wakuCtx,
						pubSubTopic,
						jsonWakuMessage,
						(WakuCallBack) callback,
						resp));
	}

	static void cGoWakuStoreQuery(void* wakuCtx,
					const char* jsonQuery,
					const char* peerAddr,
					int timeoutMs,
					void* resp) {

		WAKU_CALL (waku_store_query(wakuCtx,
									jsonQuery,
									peerAddr,
									timeoutMs,
									(WakuCallBack) callback,
									resp));
	}

	static void cGoWakuPeerExchangeQuery(void* wakuCtx,
								uint64_t numPeers,
								void* resp) {

		WAKU_CALL (waku_peer_exchange_request(wakuCtx,
									numPeers,
									(WakuCallBack) callback,
									resp));
	}

	static void cGoWakuGetPeerIdsByProtocol(void* wakuCtx,
									 const char* protocol,
									 void* resp) {

		WAKU_CALL (waku_get_peerids_by_protocol(wakuCtx,
									protocol,
									(WakuCallBack) callback,
									resp));
	}

*/
import "C"

import (
	"context"
	"crypto/ecdsa"
	"crypto/sha256"
	"database/sql"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"runtime"
	"strconv"
	"strings"
	"sync"
	"time"
	"unsafe"

	gethcommon "github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/common/hexutil"
	"github.com/ethereum/go-ethereum/crypto"
	"github.com/ethereum/go-ethereum/event"
	"github.com/ethereum/go-ethereum/p2p"
	"github.com/ethereum/go-ethereum/p2p/enode"
	"github.com/ethereum/go-ethereum/rpc"
	"github.com/jellydator/ttlcache/v3"
	"github.com/libp2p/go-libp2p/core/metrics"
	"github.com/libp2p/go-libp2p/core/peer"
	peermod "github.com/libp2p/go-libp2p/core/peer"
	"github.com/libp2p/go-libp2p/core/peerstore"
	"github.com/multiformats/go-multiaddr"
	ma "github.com/multiformats/go-multiaddr"
	"github.com/status-im/status-go/connection"
	"github.com/status-im/status-go/eth-node/types"
	"github.com/status-im/status-go/logutils"
	"github.com/status-im/status-go/timesource"
	"github.com/status-im/status-go/wakuv2/common"
	"github.com/status-im/status-go/wakuv2/persistence"
	filterapi "github.com/waku-org/go-waku/waku/v2/api/filter"
	"github.com/waku-org/go-waku/waku/v2/api/missing"
	"github.com/waku-org/go-waku/waku/v2/api/publish"
	"github.com/waku-org/go-waku/waku/v2/dnsdisc"
	node "github.com/waku-org/go-waku/waku/v2/node"
	"github.com/waku-org/go-waku/waku/v2/onlinechecker"
	"github.com/waku-org/go-waku/waku/v2/peermanager"
	wps "github.com/waku-org/go-waku/waku/v2/peerstore"
	"github.com/waku-org/go-waku/waku/v2/protocol"
	"github.com/waku-org/go-waku/waku/v2/protocol/legacy_store"
	"github.com/waku-org/go-waku/waku/v2/protocol/pb"
	"github.com/waku-org/go-waku/waku/v2/protocol/store"
	storepb "github.com/waku-org/go-waku/waku/v2/protocol/store/pb"
	"github.com/waku-org/go-waku/waku/v2/utils"
	"go.uber.org/zap"
	"golang.org/x/crypto/pbkdf2"
	"golang.org/x/time/rate"
)

const messageQueueLimit = 1024
const requestTimeout = 30 * time.Second
const bootnodesQueryBackoffMs = 200
const bootnodesMaxRetries = 7
const cacheTTL = 20 * time.Minute
const maxRelayPeers = 300
const randomPeersKeepAliveInterval = 5 * time.Second
const allPeersKeepAliveInterval = 5 * time.Minute
const peersToPublishForLightpush = 2
const publishingLimiterRate = rate.Limit(2)
const publishingLimitBurst = 4

type SentEnvelope struct {
	Envelope      *protocol.Envelope
	PublishMethod PublishMethod
}

type ErrorSendingEnvelope struct {
	Error        error
	SentEnvelope SentEnvelope
}

type ITelemetryClient interface {
	PushReceivedEnvelope(ctx context.Context, receivedEnvelope *protocol.Envelope)
	PushSentEnvelope(ctx context.Context, sentEnvelope SentEnvelope)
	PushErrorSendingEnvelope(ctx context.Context, errorSendingEnvelope ErrorSendingEnvelope)
	PushPeerCount(ctx context.Context, peerCount int)
	PushPeerConnFailures(ctx context.Context, peerConnFailures map[string]int)
}

func (w *Waku) SetStatusTelemetryClient(client ITelemetryClient) {
	w.statusTelemetryClient = client
}

func newTTLCache() *ttlcache.Cache[gethcommon.Hash, *common.ReceivedMessage] {
	cache := ttlcache.New[gethcommon.Hash, *common.ReceivedMessage](ttlcache.WithTTL[gethcommon.Hash, *common.ReceivedMessage](cacheTTL))
	go cache.Start()
	return cache
}

func (w *Waku) SubscribeToConnStatusChanges() *types.ConnStatusSubscription {
	w.connStatusMu.Lock()
	defer w.connStatusMu.Unlock()
	subscription := types.NewConnStatusSubscription()
	w.connStatusSubscriptions[subscription.ID] = subscription
	return subscription
}

func (w *Waku) getDiscV5BootstrapNodes(ctx context.Context, addresses []string) ([]*enode.Node, error) {
	wg := sync.WaitGroup{}
	mu := sync.Mutex{}
	var result []*enode.Node

	w.seededBootnodesForDiscV5 = true

	retrieveENR := func(d dnsdisc.DiscoveredNode, wg *sync.WaitGroup) {
		mu.Lock()
		defer mu.Unlock()
		defer wg.Done()
		if d.ENR != nil {
			result = append(result, d.ENR)
		}
	}

	for _, addrString := range addresses {
		if addrString == "" {
			continue
		}

		if strings.HasPrefix(addrString, "enrtree://") {
			// Use DNS Discovery
			wg.Add(1)
			go func(addr string) {
				defer wg.Done()
				if err := w.dnsDiscover(ctx, addr, retrieveENR); err != nil {
					mu.Lock()
					w.seededBootnodesForDiscV5 = false
					mu.Unlock()
				}
			}(addrString)
		} else {
			// It's a normal enr
			bootnode, err := enode.Parse(enode.ValidSchemes, addrString)
			if err != nil {
				return nil, err
			}
			result = append(result, bootnode)
		}
	}
	wg.Wait()

	return result, nil
}

type fnApplyToEachPeer func(d dnsdisc.DiscoveredNode, wg *sync.WaitGroup)

func (w *Waku) dnsDiscover(ctx context.Context, enrtreeAddress string, apply fnApplyToEachPeer) error {
	w.logger.Info("retrieving nodes", zap.String("enr", enrtreeAddress))
	ctx, cancel := context.WithTimeout(ctx, requestTimeout)
	defer cancel()

	w.dnsAddressCacheLock.Lock()
	defer w.dnsAddressCacheLock.Unlock()

	discNodes, ok := w.dnsAddressCache[enrtreeAddress]
	if !ok {
		nameserver := w.cfg.Nameserver
		resolver := w.cfg.Resolver

		var opts []dnsdisc.DNSDiscoveryOption
		if nameserver != "" {
			opts = append(opts, dnsdisc.WithNameserver(nameserver))
		}
		if resolver != nil {
			opts = append(opts, dnsdisc.WithResolver(resolver))
		}

		discoveredNodes, err := dnsdisc.RetrieveNodes(ctx, enrtreeAddress, opts...)
		if err != nil {
			w.logger.Warn("dns discovery error ", zap.Error(err))
			return err
		}

		if len(discoveredNodes) != 0 {
			w.dnsAddressCache[enrtreeAddress] = append(w.dnsAddressCache[enrtreeAddress], discoveredNodes...)
			discNodes = w.dnsAddressCache[enrtreeAddress]
		}
	}

	wg := &sync.WaitGroup{}
	wg.Add(len(discNodes))
	for _, d := range discNodes {
		apply(d, wg)
	}
	wg.Wait()

	return nil
}

func (w *Waku) discoverAndConnectPeers() {
	fnApply := func(d dnsdisc.DiscoveredNode, wg *sync.WaitGroup) {
		defer wg.Done()
		if len(d.PeerInfo.Addrs) != 0 {
			go w.connect(d.PeerInfo, d.ENR, wps.DNSDiscovery)
		}
	}

	for _, addrString := range w.cfg.WakuNodes {
		addrString := addrString
		if strings.HasPrefix(addrString, "enrtree://") {
			// Use DNS Discovery
			go func() {
				if err := w.dnsDiscover(w.ctx, addrString, fnApply); err != nil {
					w.logger.Error("could not obtain dns discovery peers for ClusterConfig.WakuNodes", zap.Error(err), zap.String("dnsDiscURL", addrString))
				}
			}()
		} else {
			// It is a normal multiaddress
			addr, err := multiaddr.NewMultiaddr(addrString)
			if err != nil {
				w.logger.Warn("invalid peer multiaddress", zap.String("ma", addrString), zap.Error(err))
				continue
			}

			peerInfo, err := peer.AddrInfoFromP2pAddr(addr)
			if err != nil {
				w.logger.Warn("invalid peer multiaddress", zap.Stringer("addr", addr), zap.Error(err))
				continue
			}

			go w.connect(*peerInfo, nil, wps.Static)
		}
	}
}

func (w *Waku) connect(peerInfo peer.AddrInfo, enr *enode.Node, origin wps.Origin) {
	// Connection will be prunned eventually by the connection manager if needed
	// The peer connector in go-waku uses Connect, so it will execute identify as part of its
	addr := peerInfo.Addrs[0]
	w.WakuConnect(addr.String(), 1000)
}

func (w *Waku) telemetryBandwidthStats(telemetryServerURL string) {
	w.wg.Add(1)
	defer w.wg.Done()

	if telemetryServerURL == "" {
		return
	}

	telemetry := NewBandwidthTelemetryClient(w.logger, telemetryServerURL)

	ticker := time.NewTicker(time.Second * 20)
	defer ticker.Stop()

	today := time.Now()

	for {
		select {
		case <-w.ctx.Done():
			return
		case now := <-ticker.C:
			// Reset totals when day changes
			if now.Day() != today.Day() {
				today = now
				w.bandwidthCounter.Reset()
			}

			go telemetry.PushProtocolStats(w.bandwidthCounter.GetBandwidthByProtocol())
		}
	}
}

func (w *Waku) GetStats() types.StatsSummary {
	stats := w.bandwidthCounter.GetBandwidthTotals()
	return types.StatsSummary{
		UploadRate:   uint64(stats.RateOut),
		DownloadRate: uint64(stats.RateIn),
	}
}

func (w *Waku) runPeerExchangeLoop() {
	w.wg.Add(1)
	defer w.wg.Done()

	if !w.cfg.EnablePeerExchangeClient {
		// Currently peer exchange client is only used for light nodes
		return
	}

	ticker := time.NewTicker(time.Second * 5)
	defer ticker.Stop()

	for {
		select {
		case <-w.ctx.Done():
			w.logger.Debug("Peer exchange loop stopped")
			return
		case <-ticker.C:
			w.logger.Info("Running peer exchange loop")

			// We select only the nodes discovered via DNS Discovery that support peer exchange
			// We assume that those peers are running peer exchange according to infra config,
			// If not, the peer selection process in go-waku will filter them out anyway
			w.dnsAddressCacheLock.RLock()
			var peers peer.IDSlice
			for _, record := range w.dnsAddressCache {
				for _, discoveredNode := range record {
					if len(discoveredNode.PeerInfo.Addrs) == 0 {
						continue
					}
					// Attempt to connect to the peers.
					// Peers will be added to the libp2p peer store thanks to identify
					go w.connect(discoveredNode.PeerInfo, discoveredNode.ENR, wps.DNSDiscovery)
					peers = append(peers, discoveredNode.PeerID)
				}
			}
			w.dnsAddressCacheLock.RUnlock()

			if len(peers) != 0 {
				// TODO
				// err := w.node.PeerExchange().Request(w.ctx, w.cfg.DiscoveryLimit, peer_exchange.WithAutomaticPeerSelection(peers...),
				// 	peer_exchange.FilterByShard(int(w.defaultShardInfo.ClusterID), int(w.defaultShardInfo.ShardIDs[0])))
				// if err != nil {
				// 	w.logger.Error("couldnt request peers via peer exchange", zap.Error(err))
				// }
			}
		}
	}
}

func (w *Waku) GetPubsubTopic(topic string) string {
	if topic == "" {
		topic = w.cfg.DefaultShardPubsubTopic
	}

	return topic
}

// CurrentTime returns current time.
func (w *Waku) CurrentTime() time.Time {
	return w.timesource.Now()
}

// APIs returns the RPC descriptors the Waku implementation offers
func (w *Waku) APIs() []rpc.API {
	return []rpc.API{
		{
			Namespace: Name,
			Version:   VersionStr,
			Service:   NewPublicWakuAPI(w),
			Public:    false,
		},
	}
}

// Protocols returns the waku sub-protocols ran by this particular client.
func (w *Waku) Protocols() []p2p.Protocol {
	return []p2p.Protocol{}
}

func (w *Waku) SendEnvelopeEvent(event common.EnvelopeEvent) int {
	return w.envelopeFeed.Send(event)
}

// SubscribeEnvelopeEvents subscribes to envelopes feed.
// In order to prevent blocking waku producers events must be amply buffered.
func (w *Waku) SubscribeEnvelopeEvents(events chan<- common.EnvelopeEvent) event.Subscription {
	return w.envelopeFeed.Subscribe(events)
}

// NewKeyPair generates a new cryptographic identity for the client, and injects
// it into the known identities for message decryption. Returns ID of the new key pair.
func (w *Waku) NewKeyPair() (string, error) {
	key, err := crypto.GenerateKey()
	if err != nil || !validatePrivateKey(key) {
		key, err = crypto.GenerateKey() // retry once
	}
	if err != nil {
		return "", err
	}
	if !validatePrivateKey(key) {
		return "", fmt.Errorf("failed to generate valid key")
	}

	id, err := toDeterministicID(hexutil.Encode(crypto.FromECDSAPub(&key.PublicKey)), common.KeyIDSize)
	if err != nil {
		return "", err
	}

	w.keyMu.Lock()
	defer w.keyMu.Unlock()

	if w.privateKeys[id] != nil {
		return "", fmt.Errorf("failed to generate unique ID")
	}
	w.privateKeys[id] = key
	return id, nil
}

// DeleteKeyPair deletes the specified key if it exists.
func (w *Waku) DeleteKeyPair(key string) bool {
	deterministicID, err := toDeterministicID(key, common.KeyIDSize)
	if err != nil {
		return false
	}

	w.keyMu.Lock()
	defer w.keyMu.Unlock()

	if w.privateKeys[deterministicID] != nil {
		delete(w.privateKeys, deterministicID)
		return true
	}
	return false
}

// AddKeyPair imports a asymmetric private key and returns it identifier.
func (w *Waku) AddKeyPair(key *ecdsa.PrivateKey) (string, error) {
	id, err := makeDeterministicID(hexutil.Encode(crypto.FromECDSAPub(&key.PublicKey)), common.KeyIDSize)
	if err != nil {
		return "", err
	}
	if w.HasKeyPair(id) {
		return id, nil // no need to re-inject
	}

	w.keyMu.Lock()
	w.privateKeys[id] = key
	w.keyMu.Unlock()

	return id, nil
}

// SelectKeyPair adds cryptographic identity, and makes sure
// that it is the only private key known to the node.
func (w *Waku) SelectKeyPair(key *ecdsa.PrivateKey) error {
	id, err := makeDeterministicID(hexutil.Encode(crypto.FromECDSAPub(&key.PublicKey)), common.KeyIDSize)
	if err != nil {
		return err
	}

	w.keyMu.Lock()
	defer w.keyMu.Unlock()

	w.privateKeys = make(map[string]*ecdsa.PrivateKey) // reset key store
	w.privateKeys[id] = key

	return nil
}

// DeleteKeyPairs removes all cryptographic identities known to the node
func (w *Waku) DeleteKeyPairs() error {
	w.keyMu.Lock()
	defer w.keyMu.Unlock()

	w.privateKeys = make(map[string]*ecdsa.PrivateKey)

	return nil
}

// HasKeyPair checks if the waku node is configured with the private key
// of the specified public pair.
func (w *Waku) HasKeyPair(id string) bool {
	deterministicID, err := toDeterministicID(id, common.KeyIDSize)
	if err != nil {
		return false
	}

	w.keyMu.RLock()
	defer w.keyMu.RUnlock()
	return w.privateKeys[deterministicID] != nil
}

// GetPrivateKey retrieves the private key of the specified identity.
func (w *Waku) GetPrivateKey(id string) (*ecdsa.PrivateKey, error) {
	deterministicID, err := toDeterministicID(id, common.KeyIDSize)
	if err != nil {
		return nil, err
	}

	w.keyMu.RLock()
	defer w.keyMu.RUnlock()
	key := w.privateKeys[deterministicID]
	if key == nil {
		return nil, fmt.Errorf("invalid id")
	}
	return key, nil
}

// GenerateSymKey generates a random symmetric key and stores it under id,
// which is then returned. Will be used in the future for session key exchange.
func (w *Waku) GenerateSymKey() (string, error) {
	key, err := common.GenerateSecureRandomData(common.AESKeyLength)
	if err != nil {
		return "", err
	} else if !common.ValidateDataIntegrity(key, common.AESKeyLength) {
		return "", fmt.Errorf("error in GenerateSymKey: crypto/rand failed to generate random data")
	}

	id, err := common.GenerateRandomID()
	if err != nil {
		return "", fmt.Errorf("failed to generate ID: %s", err)
	}

	w.keyMu.Lock()
	defer w.keyMu.Unlock()

	if w.symKeys[id] != nil {
		return "", fmt.Errorf("failed to generate unique ID")
	}
	w.symKeys[id] = key
	return id, nil
}

// AddSymKey stores the key with a given id.
func (w *Waku) AddSymKey(id string, key []byte) (string, error) {
	deterministicID, err := toDeterministicID(id, common.KeyIDSize)
	if err != nil {
		return "", err
	}

	w.keyMu.Lock()
	defer w.keyMu.Unlock()

	if w.symKeys[deterministicID] != nil {
		return "", fmt.Errorf("key already exists: %v", id)
	}
	w.symKeys[deterministicID] = key
	return deterministicID, nil
}

// AddSymKeyDirect stores the key, and returns its id.
func (w *Waku) AddSymKeyDirect(key []byte) (string, error) {
	if len(key) != common.AESKeyLength {
		return "", fmt.Errorf("wrong key size: %d", len(key))
	}

	id, err := common.GenerateRandomID()
	if err != nil {
		return "", fmt.Errorf("failed to generate ID: %s", err)
	}

	w.keyMu.Lock()
	defer w.keyMu.Unlock()

	if w.symKeys[id] != nil {
		return "", fmt.Errorf("failed to generate unique ID")
	}
	w.symKeys[id] = key
	return id, nil
}

// AddSymKeyFromPassword generates the key from password, stores it, and returns its id.
func (w *Waku) AddSymKeyFromPassword(password string) (string, error) {
	id, err := common.GenerateRandomID()
	if err != nil {
		return "", fmt.Errorf("failed to generate ID: %s", err)
	}
	if w.HasSymKey(id) {
		return "", fmt.Errorf("failed to generate unique ID")
	}

	// kdf should run no less than 0.1 seconds on an average computer,
	// because it's an once in a session experience
	derived := pbkdf2.Key([]byte(password), nil, 65356, common.AESKeyLength, sha256.New)

	w.keyMu.Lock()
	defer w.keyMu.Unlock()

	// double check is necessary, because deriveKeyMaterial() is very slow
	if w.symKeys[id] != nil {
		return "", fmt.Errorf("critical error: failed to generate unique ID")
	}
	w.symKeys[id] = derived
	return id, nil
}

// HasSymKey returns true if there is a key associated with the given id.
// Otherwise returns false.
func (w *Waku) HasSymKey(id string) bool {
	w.keyMu.RLock()
	defer w.keyMu.RUnlock()
	return w.symKeys[id] != nil
}

// DeleteSymKey deletes the key associated with the name string if it exists.
func (w *Waku) DeleteSymKey(id string) bool {
	w.keyMu.Lock()
	defer w.keyMu.Unlock()
	if w.symKeys[id] != nil {
		delete(w.symKeys, id)
		return true
	}
	return false
}

// GetSymKey returns the symmetric key associated with the given id.
func (w *Waku) GetSymKey(id string) ([]byte, error) {
	w.keyMu.RLock()
	defer w.keyMu.RUnlock()
	if w.symKeys[id] != nil {
		return w.symKeys[id], nil
	}
	return nil, fmt.Errorf("non-existent key ID")
}

// Subscribe installs a new message handler used for filtering, decrypting
// and subsequent storing of incoming messages.
func (w *Waku) Subscribe(f *common.Filter) (string, error) {
	f.PubsubTopic = w.GetPubsubTopic(f.PubsubTopic)
	id, err := w.filters.Install(f)
	if err != nil {
		return id, err
	}

	if w.cfg.LightClient {
		cf := protocol.NewContentFilter(f.PubsubTopic, f.ContentTopics.ContentTopics()...)
		w.filterManager.SubscribeFilter(id, cf)
	}

	return id, nil
}

// Unsubscribe removes an installed message handler.
func (w *Waku) Unsubscribe(ctx context.Context, id string) error {
	ok := w.filters.Uninstall(id)
	if !ok {
		return fmt.Errorf("failed to unsubscribe: invalid ID '%s'", id)
	}

	if w.cfg.LightClient {
		w.filterManager.UnsubscribeFilter(id)
	}

	return nil
}

// GetFilter returns the filter by id.
func (w *Waku) GetFilter(id string) *common.Filter {
	return w.filters.Get(id)
}

// Unsubscribe removes an installed message handler.
func (w *Waku) UnsubscribeMany(ids []string) error {
	for _, id := range ids {
		w.logger.Info("cleaning up filter", zap.String("id", id))
		ok := w.filters.Uninstall(id)
		if !ok {
			w.logger.Warn("could not remove filter with id", zap.String("id", id))
		}
	}
	return nil
}

func (w *Waku) SkipPublishToTopic(value bool) {
	w.cfg.SkipPublishToTopic = value
}

func (w *Waku) ConfirmMessageDelivered(hashes []gethcommon.Hash) {
	if !w.cfg.EnableStoreConfirmationForMessagesSent {
		return
	}
	w.messageSentCheck.DeleteByMessageIDs(hashes)
}

func (w *Waku) SetStorePeerID(peerID peer.ID) {
	if w.messageSentCheck != nil {
		w.messageSentCheck.SetStorePeerID(peerID)
	}
}

func (w *Waku) Query(ctx context.Context,
	peerID peer.ID,
	query store.FilterCriteria,
	cursor []byte,
	opts []store.RequestOption,
	processEnvelopes bool) ([]byte, int, error) {
	requestID := protocol.GenerateRequestID()

	opts = append(opts,
		store.WithRequestID(requestID),
		store.WithPeer(peerID),
		store.WithCursor(cursor))

	logger := w.logger.With(zap.String("requestID", hexutil.Encode(requestID)), zap.Stringer("peerID", peerID))

	logger.Debug("store.query",
		logutils.WakuMessageTimestamp("startTime", query.TimeStart),
		logutils.WakuMessageTimestamp("endTime", query.TimeEnd),
		zap.Strings("contentTopics", query.ContentTopics.ToList()),
		zap.String("pubsubTopic", query.PubsubTopic),
		zap.String("cursor", hexutil.Encode(cursor)),
	)

	// queryStart := time.Now()

	params := new(store.Parameters)

	optList := store.DefaultOptions()
	optList = append(optList, opts...)
	for _, opt := range optList {
		err := opt(params)
		if err != nil {
			return nil, 0, err
		}
	}

	storeRequest := &storepb.StoreQueryRequest{
		RequestId:         hex.EncodeToString(requestID),
		IncludeData:       params.IncludeData,
		PaginationForward: params.Forward,
		PaginationLimit:   &params.PageLimit,
	}

	jsonStoreRequest, err := json.Marshal(storeRequest)
	if err != nil {
		return nil, 0, err
	}

	result, err := w.wakuStoreQuery(string(jsonStoreRequest), string(peerID), 10000)

	fmt.Println("Store result ", result)

	// result, err := w.node.Store().Query(ctx, query, opts...)
	// queryDuration := time.Since(queryStart)
	// if err != nil {
	// 	logger.Error("error querying storenode", zap.Error(err))

	// 	if w.onHistoricMessagesRequestFailed != nil {
	// 		w.onHistoricMessagesRequestFailed(requestID, peerID, err)
	// 	}
	// 	return nil, 0, err
	// }

	// messages := result.Messages()
	// envelopesCount := len(messages)
	// w.logger.Debug("store.query response", zap.Duration("queryDuration", queryDuration), zap.Int("numMessages", envelopesCount), zap.Bool("hasCursor", result.IsComplete() && result.Cursor() != nil))
	// for _, mkv := range messages {
	// 	msg := mkv.Message

	// 	// Temporarily setting RateLimitProof to nil so it matches the WakuMessage protobuffer we are sending
	// 	// See https://github.com/vacp2p/rfc/issues/563
	// 	mkv.Message.RateLimitProof = nil

	// 	envelope := protocol.NewEnvelope(msg, msg.GetTimestamp(), query.PubsubTopic)

	// 	err = w.OnNewEnvelopes(envelope, common.StoreMessageType, processEnvelopes)
	// 	if err != nil {
	// 		return nil, 0, err
	// 	}
	// }

	// return result.Cursor(), envelopesCount, nil
	return nil, 0, nil
}

// OnNewEnvelope is an interface from Waku FilterManager API that gets invoked when any new message is received by Filter.
func (w *Waku) OnNewEnvelope(env *protocol.Envelope) error {
	return w.OnNewEnvelopes(env, common.RelayedMessageType, false)
}

// Start implements node.Service, starting the background data propagation thread
// of the Waku protocol.
func (w *Waku) Start() error {
	// if w.ctx == nil {
	// 	w.ctx, w.cancel = context.WithCancel(context.Background())
	// }

	// var err error
	// if w.node, err = node.New(w.options...); err != nil {
	// 	return fmt.Errorf("failed to create a go-waku node: %v", err)
	// }

	// w.goingOnline = make(chan struct{})

	err := w.WakuStart()
	if err != nil {
		fmt.Println("Error happened:", err.Error())
		return err
	}

	// ch := make(chan os.Signal, 1)
	// signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
	//<-ch

	// if err = w.node.Start(w.ctx); err != nil {
	// 	return fmt.Errorf("failed to start go-waku node: %v", err)
	// }

	// w.logger.Info("WakuV2 PeerID", zap.Stringer("id", w.node.Host().ID()))

	// w.discoverAndConnectPeers()

	// if w.cfg.EnableDiscV5 {
	// 	err := w.node.DiscV5().Start(w.ctx)
	// 	if err != nil {
	// 		return err
	// 	}
	// }

	// w.wg.Add(1)
	// go func() {
	// 	defer w.wg.Done()
	// 	ticker := time.NewTicker(5 * time.Second)
	// 	defer ticker.Stop()
	// 	for {
	// 		select {
	// 		case <-w.ctx.Done():
	// 			return
	// 		case <-ticker.C:
	// 			w.checkForConnectionChanges()
	// 		case <-w.topicHealthStatusChan:
	// 			// TODO: https://github.com/status-im/status-go/issues/4628
	// 		case <-w.connectionNotifChan:
	// 			w.checkForConnectionChanges()
	// 		}
	// 	}
	// }()

	// go w.telemetryBandwidthStats(w.cfg.TelemetryServerURL)
	//TODO: commenting for now so that only fleet nodes are used.
	//Need to uncomment once filter peer scoring etc is implemented.
	// go w.runPeerExchangeLoop()

	// if w.cfg.EnableMissingMessageVerification {

	// 	w.missingMsgVerifier = missing.NewMissingMessageVerifier(
	// 		w.node.Store(),
	// 		w,
	// 		w.node.Timesource(),
	// 		w.logger)

	// 	w.missingMsgVerifier.Start(w.ctx)

	// 	w.wg.Add(1)
	// 	go func() {
	// 		w.wg.Done()
	// 		for {
	// 			select {
	// 			case <-w.ctx.Done():
	// 				return
	// 			case envelope := <-w.missingMsgVerifier.C:
	// 				err = w.OnNewEnvelopes(envelope, common.MissingMessageType, false)
	// 				if err != nil {
	// 					w.logger.Error("OnNewEnvelopes error", zap.Error(err))
	// 				}
	// 			}
	// 		}
	// 	}()
	// }

	// if w.cfg.LightClient {
	// 	// Create FilterManager that will main peer connectivity
	// 	// for installed filters
	// 	w.filterManager = filterapi.NewFilterManager(w.ctx, w.logger, w.cfg.MinPeersForFilter,
	// 		w,
	// 		w.node.FilterLightnode())
	// }

	// err = w.setupRelaySubscriptions()
	// if err != nil {
	// 	return err
	// }

	// numCPU := runtime.NumCPU()
	// for i := 0; i < numCPU; i++ {
	// 	go w.processQueueLoop()
	// }

	// go w.broadcast()

	// go w.sendQueue.Start(w.ctx)

	// if w.cfg.EnableStoreConfirmationForMessagesSent {
	// 	w.confirmMessagesSent()
	// }

	// we should wait `seedBootnodesForDiscV5` shutdown smoothly before set w.ctx to nil within `w.Stop()`
	// go w.seedBootnodesForDiscV5()

	return nil
}

func (w *Waku) checkForConnectionChanges() {

	// isOnline := len(w.node.Host().Network().Peers()) > 0

	// w.connStatusMu.Lock()

	// latestConnStatus := types.ConnStatus{
	// 	IsOnline: isOnline,
	// 	Peers:    FormatPeerStats(w.node),
	// }

	// w.logger.Debug("peer stats",
	// 	zap.Int("peersCount", len(latestConnStatus.Peers)),
	// 	zap.Any("stats", latestConnStatus))
	// for k, subs := range w.connStatusSubscriptions {
	// 	if !subs.Send(latestConnStatus) {
	// 		delete(w.connStatusSubscriptions, k)
	// 	}
	// }

	// w.connStatusMu.Unlock()

	// if w.onPeerStats != nil {
	// 	w.onPeerStats(latestConnStatus)
	// }

	// if w.statusTelemetryClient != nil {
	// 	connFailures := FormatPeerConnFailures(w.node)
	// 	w.statusTelemetryClient.PushPeerCount(w.ctx, w.PeerCount())
	// 	w.statusTelemetryClient.PushPeerConnFailures(w.ctx, connFailures)
	// }

	// w.ConnectionChanged(connection.State{
	// 	Type:    w.state.Type, //setting state type as previous one since there won't be a change here
	// 	Offline: !latestConnStatus.IsOnline,
	// })
}

// func (w *Waku) confirmMessagesSent() {
// 	w.messageSentCheck = publish.NewMessageSentCheck(w.ctx, w.node.Store(), w.node.Timesource(), w.logger)
// 	go w.messageSentCheck.Start()

// 	go func() {
// 		for {
// 			select {
// 			case <-w.ctx.Done():
// 				return
// 			case hash := <-w.messageSentCheck.MessageStoredChan:
// 				w.SendEnvelopeEvent(common.EnvelopeEvent{
// 					Hash:  hash,
// 					Event: common.EventEnvelopeSent,
// 				})
// 			case hash := <-w.messageSentCheck.MessageExpiredChan:
// 				w.SendEnvelopeEvent(common.EnvelopeEvent{
// 					Hash:  hash,
// 					Event: common.EventEnvelopeExpired,
// 				})
// 			}
// 		}
// 	}()
// }

func (w *Waku) MessageExists(mh pb.MessageHash) (bool, error) {
	w.poolMu.Lock()
	defer w.poolMu.Unlock()
	return w.envelopeCache.Has(gethcommon.Hash(mh)), nil
}

func (w *Waku) SetTopicsToVerifyForMissingMessages(peerID peer.ID, pubsubTopic string, contentTopics []string) {
	if !w.cfg.EnableMissingMessageVerification {
		return
	}

	w.missingMsgVerifier.SetCriteriaInterest(peerID, protocol.NewContentFilter(pubsubTopic, contentTopics...))
}

func (w *Waku) setupRelaySubscriptions() error {
	if w.cfg.LightClient {
		return nil
	}

	if w.protectedTopicStore != nil {
		protectedTopics, err := w.protectedTopicStore.ProtectedTopics()
		if err != nil {
			return err
		}

		for _, pt := range protectedTopics {
			// Adding subscription to protected topics
			// err = w.subscribeToPubsubTopicWithWakuRelay(pt.Topic, pt.PubKey)
			// if err != nil {
			// 	return err
			// }

			fmt.Println("Subscription to topic: ", pt.Topic)
			err = w.WakuRelaySubscribe(pt.Topic)
			if err != nil {
				return err
			}
		}
	}

	err := w.WakuRelaySubscribe(w.cfg.DefaultShardPubsubTopic)
	if err != nil {
		return err
	}

	return nil
}

func (w *Waku) OnNewEnvelopes(envelope *protocol.Envelope, msgType common.MessageType, processImmediately bool) error {
	if envelope == nil {
		return nil
	}

	recvMessage := common.NewReceivedMessage(envelope, msgType)
	if recvMessage == nil {
		return nil
	}

	if w.statusTelemetryClient != nil {
		w.statusTelemetryClient.PushReceivedEnvelope(w.ctx, envelope)
	}

	logger := w.logger.With(
		zap.String("messageType", msgType),
		zap.Stringer("envelopeHash", envelope.Hash()),
		zap.String("pubsubTopic", envelope.PubsubTopic()),
		zap.String("contentTopic", envelope.Message().ContentTopic),
		logutils.WakuMessageTimestamp("timestamp", envelope.Message().Timestamp),
	)

	logger.Debug("received new envelope")
	trouble := false

	_, err := w.add(recvMessage, processImmediately)
	if err != nil {
		logger.Info("invalid envelope received", zap.Error(err))
		trouble = true
	}

	common.EnvelopesValidatedCounter.Inc()

	if trouble {
		return errors.New("received invalid envelope")
	}

	return nil
}

// addEnvelope adds an envelope to the envelope map, used for sending
func (w *Waku) addEnvelope(envelope *common.ReceivedMessage) {
	w.poolMu.Lock()
	w.envelopeCache.Set(envelope.Hash(), envelope, ttlcache.DefaultTTL)
	w.poolMu.Unlock()
}

func (w *Waku) add(recvMessage *common.ReceivedMessage, processImmediately bool) (bool, error) {
	common.EnvelopesReceivedCounter.Inc()

	w.poolMu.Lock()
	envelope := w.envelopeCache.Get(recvMessage.Hash())
	alreadyCached := envelope != nil
	w.poolMu.Unlock()

	if !alreadyCached {
		recvMessage.Processed.Store(false)
		w.addEnvelope(recvMessage)
	}

	logger := w.logger.With(zap.String("envelopeHash", recvMessage.Hash().Hex()))

	if alreadyCached {
		logger.Debug("w envelope already cached")
		common.EnvelopesCachedCounter.WithLabelValues("hit").Inc()
	} else {
		logger.Debug("cached w envelope")
		common.EnvelopesCachedCounter.WithLabelValues("miss").Inc()
		common.EnvelopesSizeMeter.Observe(float64(len(recvMessage.Envelope.Message().Payload)))
	}

	if !alreadyCached || !envelope.Value().Processed.Load() {
		if processImmediately {
			logger.Debug("immediately processing envelope")
			w.processMessage(recvMessage)
		} else {
			logger.Debug("posting event")
			w.postEvent(recvMessage) // notify the local node about the new message
		}
	}

	return true, nil
}

// postEvent queues the message for further processing.
func (w *Waku) postEvent(envelope *common.ReceivedMessage) {
	w.msgQueue <- envelope
}

// processQueueLoop delivers the messages to the watchers during the lifetime of the waku node.
func (w *Waku) processQueueLoop() {
	if w.ctx == nil {
		return
	}
	for {
		select {
		case <-w.ctx.Done():
			return
		case e := <-w.msgQueue:
			w.processMessage(e)
		}
	}
}

func (w *Waku) processMessage(e *common.ReceivedMessage) {
	logger := w.logger.With(
		zap.Stringer("envelopeHash", e.Envelope.Hash()),
		zap.String("pubsubTopic", e.PubsubTopic),
		zap.String("contentTopic", e.ContentTopic.ContentTopic()),
		zap.Int64("timestamp", e.Envelope.Message().GetTimestamp()),
	)

	if e.MsgType == common.StoreMessageType {
		// We need to insert it first, and then remove it if not matched,
		// as messages are processed asynchronously
		w.storeMsgIDsMu.Lock()
		w.storeMsgIDs[e.Hash()] = true
		w.storeMsgIDsMu.Unlock()
	}

	ephemeral := e.Envelope.Message().Ephemeral
	if w.cfg.EnableStoreConfirmationForMessagesSent && e.MsgType == common.SendMessageType && (ephemeral == nil || !*ephemeral) {
		w.messageSentCheck.Add(e.PubsubTopic, e.Hash(), e.Sent)
	}

	matched := w.filters.NotifyWatchers(e)

	// If not matched we remove it
	if !matched {
		logger.Debug("filters did not match")
		w.storeMsgIDsMu.Lock()
		delete(w.storeMsgIDs, e.Hash())
		w.storeMsgIDsMu.Unlock()
	} else {
		logger.Debug("filters did match")
		e.Processed.Store(true)
	}

	w.envelopeFeed.Send(common.EnvelopeEvent{
		Topic: e.ContentTopic,
		Hash:  e.Hash(),
		Event: common.EventEnvelopeAvailable,
	})
}

// GetEnvelope retrieves an envelope from the message queue by its hash.
// It returns nil if the envelope can not be found.
func (w *Waku) GetEnvelope(hash gethcommon.Hash) *common.ReceivedMessage {
	w.poolMu.RLock()
	defer w.poolMu.RUnlock()

	envelope := w.envelopeCache.Get(hash)
	if envelope == nil {
		return nil
	}

	return envelope.Value()
}

// isEnvelopeCached checks if envelope with specific hash has already been received and cached.
func (w *Waku) IsEnvelopeCached(hash gethcommon.Hash) bool {
	w.poolMu.Lock()
	defer w.poolMu.Unlock()

	return w.envelopeCache.Has(hash)
}

func (w *Waku) ClearEnvelopesCache() {
	w.poolMu.Lock()
	defer w.poolMu.Unlock()

	w.envelopeCache.Stop()
	w.envelopeCache = newTTLCache()
}

func (w *Waku) PeerCount() int {
	return 0
	// return w.node.PeerCount()
}

func (w *Waku) Peers() types.PeerStats {
	return nil
	// return FormatPeerStats(w.node)
}

func (w *Waku) RelayPeersByTopic(topic string) (*types.PeerList, error) {
	if w.cfg.LightClient {
		return nil, errors.New("only available in relay mode")
	}

	// return &types.PeerList{
	// 	FullMeshPeers: w.node.Relay().PubSub().MeshPeers(topic),
	// 	AllPeers:      w.node.Relay().PubSub().ListPeers(topic),
	// }, nil
	return nil, nil
}

func (w *Waku) SubscribeToPubsubTopic(topic string, pubkey *ecdsa.PublicKey) error {
	topic = w.GetPubsubTopic(topic)

	if !w.cfg.LightClient {
		err := w.WakuRelaySubscribe(topic)
		// err := w.subscribeToPubsubTopicWithWakuRelay(topic, pubkey)
		if err != nil {
			return err
		}
	}
	return nil
}

func (w *Waku) UnsubscribeFromPubsubTopic(topic string) error {
	topic = w.GetPubsubTopic(topic)

	if !w.cfg.LightClient {
		err := w.WakuRelayUnsubscribe(topic)
		if err != nil {
			return err
		}
	}
	return nil
}

func (w *Waku) RetrievePubsubTopicKey(topic string) (*ecdsa.PrivateKey, error) {
	topic = w.GetPubsubTopic(topic)
	if w.protectedTopicStore == nil {
		return nil, nil
	}

	return w.protectedTopicStore.FetchPrivateKey(topic)
}

func (w *Waku) StorePubsubTopicKey(topic string, privKey *ecdsa.PrivateKey) error {
	topic = w.GetPubsubTopic(topic)
	if w.protectedTopicStore == nil {
		return nil
	}

	return w.protectedTopicStore.Insert(topic, privKey, &privKey.PublicKey)
}

func (w *Waku) RemovePubsubTopicKey(topic string) error {
	topic = w.GetPubsubTopic(topic)
	if w.protectedTopicStore == nil {
		return nil
	}

	return w.protectedTopicStore.Delete(topic)
}

func (w *Waku) handleNetworkChangeFromApp(state connection.State) {
	//If connection state is reported by something other than peerCount becoming 0 e.g from mobile app, disconnect all peers
	// if (state.Offline && len(w.node.Host().Network().Peers()) > 0) ||
	// 	(w.state.Type != state.Type && !w.state.Offline && !state.Offline) { // network switched between wifi and cellular
	// 	w.logger.Info("connection switched or offline detected via mobile, disconnecting all peers")
	// 	w.node.DisconnectAllPeers()
	// 	if w.cfg.LightClient {
	// 		w.filterManager.NetworkChange()
	// 	}
	// }
}

func (w *Waku) ConnectionChanged(state connection.State) {
	isOnline := !state.Offline
	if w.cfg.LightClient {
		//TODO: Update this as per  https://github.com/waku-org/go-waku/issues/1114
		go w.filterManager.OnConnectionStatusChange("", isOnline)
		w.handleNetworkChangeFromApp(state)
	} else {
		// for lightClient state update and onlineChange is handled in filterManager.
		// going online
		if isOnline && !w.onlineChecker.IsOnline() {
			//TODO: analyze if we need to discover and connect to peers for relay.
			w.discoverAndConnectPeers()
			select {
			case w.goingOnline <- struct{}{}:
			default:
				w.logger.Warn("could not write on connection changed channel")
			}
		}
		// update state
		w.onlineChecker.SetOnline(isOnline)
	}
	w.state = state
}

func (w *Waku) AddStorePeer(address multiaddr.Multiaddr) (peer.ID, error) {
	// peerID, err := w.node.AddPeer(address, wps.Static, w.cfg.DefaultShardedPubsubTopics, store.StoreQueryID_v300)
	// if err != nil {
	// 	return "", err
	// }
	// return peerID, nil
	return "", nil
}

func (w *Waku) timestamp() int64 {
	return w.timesource.Now().UnixNano()
}

func (w *Waku) AddRelayPeer(address multiaddr.Multiaddr) (peer.ID, error) {
	// peerID, err := w.node.AddPeer(address, wps.Static, w.cfg.DefaultShardedPubsubTopics, relay.WakuRelayID_v200)
	// if err != nil {
	// 	return "", err
	// }
	// return peerID, nil
	return "", nil
}

func (w *Waku) DialPeer(address multiaddr.Multiaddr) error {
	// ctx, cancel := context.WithTimeout(w.ctx, requestTimeout)
	// defer cancel()
	// return w.node.DialPeerWithMultiAddress(ctx, address)
	return nil
}

func (w *Waku) DialPeerByID(peerID peer.ID) error {
	// ctx, cancel := context.WithTimeout(w.ctx, requestTimeout)
	// defer cancel()
	// return w.node.DialPeerByID(ctx, peerID)
	return nil
}

func (w *Waku) DropPeer(peerID peer.ID) error {
	// return w.node.ClosePeerById(peerID)
	return nil
}

func (w *Waku) ProcessingP2PMessages() bool {
	w.storeMsgIDsMu.Lock()
	defer w.storeMsgIDsMu.Unlock()
	return len(w.storeMsgIDs) != 0
}

func (w *Waku) MarkP2PMessageAsProcessed(hash gethcommon.Hash) {
	w.storeMsgIDsMu.Lock()
	defer w.storeMsgIDsMu.Unlock()
	delete(w.storeMsgIDs, hash)
}

func (w *Waku) Clean() error {
	w.msgQueue = make(chan *common.ReceivedMessage, messageQueueLimit)

	for _, f := range w.filters.All() {
		f.Messages = common.NewMemoryMessageStore()
	}

	return nil
}

func (w *Waku) PeerID() peer.ID {
	// return w.node.Host().ID()
	return ""
}

func (w *Waku) Peerstore() peerstore.Peerstore {
	// return w.node.Host().Peerstore()
	return nil
}

// validatePrivateKey checks the format of the given private key.
func validatePrivateKey(k *ecdsa.PrivateKey) bool {
	if k == nil || k.D == nil || k.D.Sign() == 0 {
		return false
	}
	return common.ValidatePublicKey(&k.PublicKey)
}

// makeDeterministicID generates a deterministic ID, based on a given input
func makeDeterministicID(input string, keyLen int) (id string, err error) {
	buf := pbkdf2.Key([]byte(input), nil, 4096, keyLen, sha256.New)
	if !common.ValidateDataIntegrity(buf, common.KeyIDSize) {
		return "", fmt.Errorf("error in GenerateDeterministicID: failed to generate key")
	}
	id = gethcommon.Bytes2Hex(buf)
	return id, err
}

// toDeterministicID reviews incoming id, and transforms it to format
// expected internally be private key store. Originally, public keys
// were used as keys, now random keys are being used. And in order to
// make it easier to consume, we now allow both random IDs and public
// keys to be passed.
func toDeterministicID(id string, expectedLen int) (string, error) {
	if len(id) != (expectedLen * 2) { // we received hex key, so number of chars in id is doubled
		var err error
		id, err = makeDeterministicID(id, expectedLen)
		if err != nil {
			return "", err
		}
	}

	return id, nil
}

func FormatPeerStats(wakuNode *node.WakuNode) types.PeerStats {
	p := make(types.PeerStats)
	for k, v := range wakuNode.PeerStats() {
		p[k] = types.WakuV2Peer{
			Addresses: utils.EncapsulatePeerID(k, wakuNode.Host().Peerstore().PeerInfo(k).Addrs...),
			Protocols: v,
		}
	}
	return p
}

func (w *Waku) StoreNode() *store.WakuStore {
	// return w.node.Store()
	return nil
}

func FormatPeerConnFailures(wakuNode *node.WakuNode) map[string]int {
	p := make(map[string]int)
	for _, peerID := range wakuNode.Host().Network().Peers() {
		peerInfo := wakuNode.Host().Peerstore().PeerInfo(peerID)
		connFailures := wakuNode.Host().Peerstore().(wps.WakuPeerstore).ConnFailures(peerInfo)
		if connFailures > 0 {
			p[peerID.String()] = connFailures
		}
	}
	return p
}

func (w *Waku) LegacyStoreNode() legacy_store.Store {
	// return w.node.LegacyStore()
	return nil
}

type WakuMessageHash = string
type WakuPubsubTopic = string
type WakuContentTopic = string

type WakuConfig struct {
	Host        string `json:"host,omitempty"`
	Port        int    `json:"port,omitempty"`
	NodeKey     string `json:"key,omitempty"`
	EnableRelay bool   `json:"relay"`
	LogLevel    string `json:"logLevel"`
}

var jamon unsafe.Pointer

type Waku struct {
	wakuCtx unsafe.Pointer

	appDB *sql.DB

	dnsAddressCache     map[string][]dnsdisc.DiscoveredNode // Map to store the multiaddresses returned by dns discovery
	dnsAddressCacheLock *sync.RWMutex                       // lock to handle access to the map

	// Filter-related
	filters       *common.Filters // Message filters installed with Subscribe function
	filterManager *filterapi.FilterManager

	privateKeys map[string]*ecdsa.PrivateKey // Private key storage
	symKeys     map[string][]byte            // Symmetric key storage
	keyMu       sync.RWMutex                 // Mutex associated with key stores

	envelopeCache *ttlcache.Cache[gethcommon.Hash, *common.ReceivedMessage] // Pool of envelopes currently tracked by this node
	poolMu        sync.RWMutex                                              // Mutex to sync the message and expiration pools

	bandwidthCounter *metrics.BandwidthCounter

	protectedTopicStore *persistence.ProtectedTopicsStore

	sendQueue *publish.MessageQueue
	limiter   *publish.PublishRateLimiter

	missingMsgVerifier *missing.MissingMessageVerifier

	msgQueue chan *common.ReceivedMessage // Message queue for waku messages that havent been decoded

	ctx    context.Context
	cancel context.CancelFunc
	wg     sync.WaitGroup

	cfg     *Config
	options []node.WakuNodeOption

	envelopeFeed event.Feed

	storeMsgIDs   map[gethcommon.Hash]bool // Map of the currently processing ids
	storeMsgIDsMu sync.RWMutex

	messageSentCheck *publish.MessageSentCheck

	topicHealthStatusChan   chan peermanager.TopicHealthStatus
	connectionNotifChan     chan node.PeerConnection
	connStatusSubscriptions map[string]*types.ConnStatusSubscription
	connStatusMu            sync.Mutex
	onlineChecker           *onlinechecker.DefaultOnlineChecker
	state                   connection.State

	logger *zap.Logger

	// NTP Synced timesource
	timesource *timesource.NTPTimeSource

	// seededBootnodesForDiscV5 indicates whether we manage to retrieve discovery
	// bootnodes successfully
	seededBootnodesForDiscV5 bool

	// goingOnline is channel that notifies when connectivity has changed from offline to online
	goingOnline chan struct{}

	// discV5BootstrapNodes is the ENR to be used to fetch bootstrap nodes for discovery
	discV5BootstrapNodes []string

	onHistoricMessagesRequestFailed func([]byte, peer.ID, error)
	onPeerStats                     func(types.ConnStatus)

	statusTelemetryClient ITelemetryClient

	defaultShardInfo protocol.RelayShards
}

func (w *Waku) Stop() error {
	return w.WakuStop()
}

func WakuSetup() {
	C.waku_setup()
}

func printStackTrace() {
	// Create a buffer to hold the stack trace
	buf := make([]byte, 102400)
	// Capture the stack trace into the buffer
	n := runtime.Stack(buf, false)
	// Print the stack trace
	fmt.Printf("Current stack trace:\n%s\n", buf[:n])
}

func wakuNew(nodeKey *ecdsa.PrivateKey,
	fleet string,
	cfg *Config,
	logger *zap.Logger,
	appDB *sql.DB,
	ts *timesource.NTPTimeSource,
	onHistoricMessagesRequestFailed func([]byte, peer.ID, error), onPeerStats func(types.ConnStatus)) (*Waku, error) {

	nwakuConfig := WakuConfig{
		Host:        cfg.Host,
		Port:        30303,
		NodeKey:     "11d0dcea28e86f81937a3bd1163473c7fbc0a0db54fd72914849bc47bdf78710",
		EnableRelay: true,
		LogLevel:    "DEBUG",
	}

	var err error
	if logger == nil {
		logger, err = zap.NewDevelopment()
		if err != nil {
			return nil, err
		}
	}
	if ts == nil {
		ts = timesource.Default()
	}

	cfg = setDefaults(cfg)
	if err = cfg.Validate(logger); err != nil {
		return nil, err
	}

	ctx, cancel := context.WithCancel(context.Background())

	jsonConfig, err := json.Marshal(nwakuConfig)
	if err != nil {
		return nil, err
	}

	var cJsonConfig = C.CString(string(jsonConfig))
	var resp = C.allocResp()

	defer C.free(unsafe.Pointer(cJsonConfig))
	defer C.freeResp(resp)

	wakuCtx := C.cGoWakuNew(cJsonConfig, resp)
	jamon = wakuCtx
	// Notice that the events for self node are handled by the 'MyEventCallback' method

	if C.getRet(resp) == C.RET_OK {

		return &Waku{
			wakuCtx:                         wakuCtx,
			cfg:                             cfg,
			privateKeys:                     make(map[string]*ecdsa.PrivateKey),
			symKeys:                         make(map[string][]byte),
			envelopeCache:                   newTTLCache(),
			msgQueue:                        make(chan *common.ReceivedMessage, messageQueueLimit),
			topicHealthStatusChan:           make(chan peermanager.TopicHealthStatus, 100),
			connectionNotifChan:             make(chan node.PeerConnection, 20),
			connStatusSubscriptions:         make(map[string]*types.ConnStatusSubscription),
			ctx:                             ctx,
			cancel:                          cancel,
			wg:                              sync.WaitGroup{},
			dnsAddressCache:                 make(map[string][]dnsdisc.DiscoveredNode),
			dnsAddressCacheLock:             &sync.RWMutex{},
			storeMsgIDs:                     make(map[gethcommon.Hash]bool),
			timesource:                      ts,
			storeMsgIDsMu:                   sync.RWMutex{},
			logger:                          logger,
			discV5BootstrapNodes:            cfg.DiscV5BootstrapNodes,
			onHistoricMessagesRequestFailed: onHistoricMessagesRequestFailed,
			onPeerStats:                     onPeerStats,
			onlineChecker:                   onlinechecker.NewDefaultOnlineChecker(false).(*onlinechecker.DefaultOnlineChecker),
			sendQueue:                       publish.NewMessageQueue(1000, cfg.UseThrottledPublish),
		}, nil
	}

	errMsg := "error wakuNew: " + C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
	return nil, errors.New(errMsg)
}

func (self *Waku) WakuStart() error {

	var resp = C.allocResp()
	defer C.freeResp(resp)
	
	
	fmt.Println("------------ GABRIEL called wakuStart")
	C.cGoWakuStart(self.wakuCtx, resp)
	fmt.Println("------------ GABRIEL wakuStart 2")

	if C.getRet(resp) == C.RET_OK {
		fmt.Println("------------ GABRIEL wakuStart received RET_OK")
		return nil
	}
	fmt.Println("------------ GABRIEL wakuStart 3")
	errMsg := "error WakuStart: " + C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
	fmt.Println("------------ GABRIEL error in wakuStart ", errMsg)
	return errors.New(errMsg)
}

func (self *Waku) WakuStop() error {
	var resp = C.allocResp()
	defer C.freeResp(resp)
	C.cGoWakuStop(self.wakuCtx, resp)

	if C.getRet(resp) == C.RET_OK {
		return nil
	}
	errMsg := "error WakuStop: " + C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
	return errors.New(errMsg)
}

func (self *Waku) WakuDestroy() error {
	var resp = C.allocResp()
	defer C.freeResp(resp)
	C.cGoWakuDestroy(self.wakuCtx, resp)

	if C.getRet(resp) == C.RET_OK {
		return nil
	}
	errMsg := "error WakuDestroy: " + C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
	return errors.New(errMsg)
}

func (self *Waku) StartDiscV5() error {
	var resp = C.allocResp()
	defer C.freeResp(resp)
	C.cGoWakuStartDiscV5(self.wakuCtx, resp)

	if C.getRet(resp) == C.RET_OK {
		return nil
	}
	errMsg := "error WakuStartDiscV5: " + C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
	return errors.New(errMsg)
}

func (self *Waku) StopDiscV5() error {
	var resp = C.allocResp()
	defer C.freeResp(resp)
	C.cGoWakuStopDiscV5(self.wakuCtx, resp)

	if C.getRet(resp) == C.RET_OK {
		return nil
	}
	errMsg := "error WakuStopDiscV5: " + C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
	return errors.New(errMsg)
}

func (self *Waku) WakuVersion() (string, error) {
	var resp = C.allocResp()
	defer C.freeResp(resp)

	C.cGoWakuVersion(self.wakuCtx, resp)

	if C.getRet(resp) == C.RET_OK {
		var version = C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
		return version, nil
	}

	errMsg := "error WakuVersion: " +
		C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
	return "", errors.New(errMsg)
}

//export globalEventCallback
func globalEventCallback(callerRet C.int, msg *C.char, len C.size_t, userData unsafe.Pointer) {
	// This is shared among all Golang instances
	self := Waku{wakuCtx: userData}
	self.MyEventCallback(callerRet, msg, len)
}

func (self *Waku) MyEventCallback(callerRet C.int, msg *C.char, len C.size_t) {
	fmt.Println("Event received:", C.GoStringN(msg, C.int(len)))
}

func (self *Waku) WakuSetEventCallback() {
	// Notice that the events for self node are handled by the 'MyEventCallback' method
	C.cGoWakuSetEventCallback(self.wakuCtx)
}

func (self *Waku) FormatContentTopic(
	appName string,
	appVersion int,
	contentTopicName string,
	encoding string) (WakuContentTopic, error) {

	var cAppName = C.CString(appName)
	var cContentTopicName = C.CString(contentTopicName)
	var cEncoding = C.CString(encoding)
	var resp = C.allocResp()

	defer C.free(unsafe.Pointer(cAppName))
	defer C.free(unsafe.Pointer(cContentTopicName))
	defer C.free(unsafe.Pointer(cEncoding))
	defer C.freeResp(resp)

	C.cGoWakuContentTopic(self.wakuCtx,
		cAppName,
		C.int(appVersion),
		cContentTopicName,
		cEncoding,
		resp)

	if C.getRet(resp) == C.RET_OK {
		var contentTopic = C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
		return contentTopic, nil
	}

	errMsg := "error FormatContentTopic: " +
		C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))

	return "", errors.New(errMsg)
}

func (self *Waku) FormatPubsubTopic(topicName string) (WakuPubsubTopic, error) {
	var cTopicName = C.CString(topicName)
	var resp = C.allocResp()

	defer C.free(unsafe.Pointer(cTopicName))
	defer C.freeResp(resp)

	C.cGoWakuPubsubTopic(self.wakuCtx, cTopicName, resp)
	if C.getRet(resp) == C.RET_OK {
		var pubsubTopic = C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
		return pubsubTopic, nil
	}

	errMsg := "error FormatPubsubTopic: " +
		C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))

	return "", errors.New(errMsg)
}

func (self *Waku) WakuDefaultPubsubTopic() (WakuPubsubTopic, error) {
	var resp = C.allocResp()
	defer C.freeResp(resp)
	C.cGoWakuDefaultPubsubTopic(self.wakuCtx, resp)
	if C.getRet(resp) == C.RET_OK {
		var defaultPubsubTopic = C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
		return defaultPubsubTopic, nil
	}

	errMsg := "error WakuDefaultPubsubTopic: " +
		C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))

	return "", errors.New(errMsg)
}

func (self *Waku) WakuRelayPublish(wakuMsg *pb.WakuMessage, pubsubTopic string) (string, error) {
	timeoutMs := 1000

	message, err := json.Marshal(wakuMsg)
	if err != nil {
		return "", err
	}

	var cPubsubTopic = C.CString(pubsubTopic)
	var msg = C.CString(string(message))
	var resp = C.allocResp()

	defer C.freeResp(resp)
	defer C.free(unsafe.Pointer(cPubsubTopic))
	defer C.free(unsafe.Pointer(msg))

	C.cGoWakuRelayPublish(self.wakuCtx, cPubsubTopic, msg, C.int(timeoutMs), resp)
	if C.getRet(resp) == C.RET_OK {
		msgHash := C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
		return msgHash, nil
	}
	errMsg := "error WakuRelayPublish: " +
		C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
	return "", errors.New(errMsg)
}

func (self *Waku) WakuRelaySubscribe(pubsubTopic string) error {
	var resp = C.allocResp()
	var cPubsubTopic = C.CString(pubsubTopic)

	defer C.freeResp(resp)
	defer C.free(unsafe.Pointer(cPubsubTopic))

	if self.wakuCtx == nil {
		fmt.Println("ctx is nil")
	}
	// if self.cPubsubTopic == nil {
	// 	fmt.Println("cPubsubTopic is nil")
	// }
	// if self.resp == nil {
	// 	fmt.Println("resp is nil")
	// }

	C.cGoWakuRelaySubscribe(self.wakuCtx, cPubsubTopic, resp)

	if C.getRet(resp) == C.RET_OK {
		return nil
	}
	errMsg := "error WakuRelaySubscribe: " +
		C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
	return errors.New(errMsg)
}

func (self *Waku) WakuRelayUnsubscribe(pubsubTopic string) error {
	var resp = C.allocResp()
	var cPubsubTopic = C.CString(pubsubTopic)
	defer C.freeResp(resp)
	defer C.free(unsafe.Pointer(cPubsubTopic))
	C.cGoWakuRelayUnsubscribe(self.wakuCtx, cPubsubTopic, resp)

	if C.getRet(resp) == C.RET_OK {
		return nil
	}
	errMsg := "error WakuRelayUnsubscribe: " +
		C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
	return errors.New(errMsg)
}

func (self *Waku) WakuLightpushPublish(message *pb.WakuMessage, pubsubTopic string) (string, error) {
	jsonMsg, err := json.Marshal(message)
	if err != nil {
		return "", err
	}

	var cPubsubTopic = C.CString(pubsubTopic)
	var msg = C.CString(string(jsonMsg))
	var resp = C.allocResp()

	defer C.freeResp(resp)
	defer C.free(unsafe.Pointer(cPubsubTopic))
	defer C.free(unsafe.Pointer(msg))

	C.cGoWakuLightpushPublish(self.wakuCtx, cPubsubTopic, msg, resp)
	if C.getRet(resp) == C.RET_OK {
		msg := C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
		return msg, nil
	}
	errMsg := "error WakuLightpushPublish: " +
		C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
	return "", errors.New(errMsg)
}

func (self *Waku) wakuStoreQuery(
	jsonQuery string,
	peerAddr string,
	timeoutMs int) (string, error) {

	var cJsonQuery = C.CString(jsonQuery)
	var cPeerAddr = C.CString(peerAddr)
	var resp = C.allocResp()

	defer C.free(unsafe.Pointer(cJsonQuery))
	defer C.free(unsafe.Pointer(cPeerAddr))
	defer C.freeResp(resp)

	C.cGoWakuStoreQuery(self.wakuCtx, cJsonQuery, cPeerAddr, C.int(timeoutMs), resp)
	if C.getRet(resp) == C.RET_OK {
		msg := C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
		return msg, nil
	}
	errMsg := "error WakuStoreQuery: " +
		C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
	return "", errors.New(errMsg)
}

func (self *Waku) WakuPeerExchangeRequest(numPeers uint64) (string, error) {
	var resp = C.allocResp()
	defer C.freeResp(resp)

	C.cGoWakuPeerExchangeQuery(self.wakuCtx, C.uint64_t(numPeers), resp)
	if C.getRet(resp) == C.RET_OK {
		msg := C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
		return msg, nil
	}
	errMsg := "error WakuPeerExchangeRequest: " +
		C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
	return "", errors.New(errMsg)
}

func (self *Waku) WakuConnect(peerMultiAddr string, timeoutMs int) error {
	var resp = C.allocResp()
	var cPeerMultiAddr = C.CString(peerMultiAddr)
	defer C.freeResp(resp)
	defer C.free(unsafe.Pointer(cPeerMultiAddr))

	C.cGoWakuConnect(self.wakuCtx, cPeerMultiAddr, C.int(timeoutMs), resp)

	if C.getRet(resp) == C.RET_OK {
		return nil
	}
	errMsg := "error WakuConnect: " +
		C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
	return errors.New(errMsg)
}

func (self *Waku) ListenAddresses() ([]multiaddr.Multiaddr, error) {
	var resp = C.allocResp()
	defer C.freeResp(resp)
	C.cGoWakuListenAddresses(self.wakuCtx, resp)

	if C.getRet(resp) == C.RET_OK {

		var addrsRet []multiaddr.Multiaddr
		listenAddresses := C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
		addrss := strings.Split(listenAddresses, ",")
		for _, addr := range addrss {
			addr, err := ma.NewMultiaddr(addr)
			if err != nil {
				return nil, err
			}

			addrsRet = append(addrsRet, addr)
		}

		fmt.Println("AAAAAA listen addresses: ", listenAddresses)

		return addrsRet, nil
	}
	errMsg := "error WakuListenAddresses: " +
		C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))

	return nil, errors.New(errMsg)
}

func (self *Waku) ENR() (*enode.Node, error) {
	var resp = C.allocResp()
	defer C.freeResp(resp)
	C.cGoWakuGetMyENR(self.wakuCtx, resp)

	if C.getRet(resp) == C.RET_OK {
		enrStr := C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
		n, err := enode.Parse(enode.ValidSchemes, enrStr)
		if err != nil {
			return nil, err
		}
		return n, nil
	}
	errMsg := "error WakuGetMyENR: " +
		C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
	return nil, errors.New(errMsg)
}

func (self *Waku) ListPeersInMesh(pubsubTopic string) (int, error) {
	var resp = C.allocResp()
	var cPubsubTopic = C.CString(pubsubTopic)
	defer C.freeResp(resp)
	defer C.free(unsafe.Pointer(cPubsubTopic))

	C.cGoWakuListPeersInMesh(self.wakuCtx, cPubsubTopic, resp)

	if C.getRet(resp) == C.RET_OK {
		numPeersStr := C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
		numPeers, err := strconv.Atoi(numPeersStr)
		if err != nil {
			fmt.Println(":", err)
			errMsg := "ListPeersInMesh - error converting string to int: " + err.Error()
			return 0, errors.New(errMsg)
		}
		return numPeers, nil
	}
	errMsg := "error ListPeersInMesh: " +
		C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
	return 0, errors.New(errMsg)
}

func (self *Waku) GetNumConnectedPeers(paramPubsubTopic ...string) (int, error) {
	var pubsubTopic string
	if len(paramPubsubTopic) == 0 {
		pubsubTopic = ""
	} else {
		pubsubTopic = paramPubsubTopic[0]
	}

	var resp = C.allocResp()
	var cPubsubTopic = C.CString(pubsubTopic)
	defer C.freeResp(resp)
	defer C.free(unsafe.Pointer(cPubsubTopic))

	C.cGoWakuGetNumConnectedPeers(self.wakuCtx, cPubsubTopic, resp)

	if C.getRet(resp) == C.RET_OK {
		numPeersStr := C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
		numPeers, err := strconv.Atoi(numPeersStr)
		if err != nil {
			fmt.Println(":", err)
			errMsg := "ListPeersInMesh - error converting string to int: " + err.Error()
			return 0, errors.New(errMsg)
		}
		return numPeers, nil
	}
	errMsg := "error ListPeersInMesh: " +
		C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
	return 0, errors.New(errMsg)
}

func (self *Waku) GetPeerIdsByProtocol(protocol string) (peer.IDSlice, error) {
	var resp = C.allocResp()
	var cProtocol = C.CString(protocol)
	defer C.freeResp(resp)
	defer C.free(unsafe.Pointer(cProtocol))

	C.cGoWakuGetPeerIdsByProtocol(self.wakuCtx, cProtocol, resp)

	if C.getRet(resp) == C.RET_OK {
		peersStr := C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
		// peersStr contains a comma-separated list of peer ids
		itemsPeerIds := strings.Split(peersStr, ",")

		var peers peer.IDSlice
		for _, peer := range itemsPeerIds {
			id, err := peermod.Decode(peer)
			if err != nil {
				errMsg := "ListPeersInMesh - error converting string to int: " + err.Error()
				return nil, errors.New(errMsg)
			}
			peers = append(peers, id)
		}

		return peers, nil
	}
	errMsg := "error GetPeerIdsByProtocol: " +
		C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
	return nil, errors.New(errMsg)
}

// func main() {

// 	config := WakuConfig{
// 		Host:        "0.0.0.0",
// 		Port:        30304,
// 		NodeKey:     "11d0dcea28e86f81937a3bd1163473c7fbc0a0db54fd72914849bc47bdf78710",
// 		EnableRelay: true,
// 		LogLevel:    "DEBUG",
// 	}

// 	node, err := wakuNew(config)
// 	if err != nil {
// 		fmt.Println("Error happened:", err.Error())
// 		return
// 	}

// 	node.WakuSetEventCallback()

// 	defaultPubsubTopic, err := node.WakuDefaultPubsubTopic()
// 	if err != nil {
// 		fmt.Println("Error happened:", err.Error())
// 		return
// 	}

// 	err = node.WakuRelaySubscribe(defaultPubsubTopic)
// 	if err != nil {
// 		fmt.Println("Error happened:", err.Error())
// 		return
// 	}

// 	err = node.WakuConnect(
// 		// tries to connect to a localhost node with key: 0d714a1fada214dead6dc9c7274585eca0ff292451866e7d6d677dc818e8ccd2
// 		"/ip4/0.0.0.0/tcp/60000/p2p/16Uiu2HAmVFXtAfSj4EiR7mL2KvL4EE2wztuQgUSBoj2Jx2KeXFLN",
// 		10000)
// 	if err != nil {
// 		fmt.Println("Error happened:", err.Error())
// 		return
// 	}

// 	err = node.WakuStart()
// 	if err != nil {
// 		fmt.Println("Error happened:", err.Error())
// 		return
// 	}

// 	version, err := node.WakuVersion()
// 	if err != nil {
// 		fmt.Println("Error happened:", err.Error())
// 		return
// 	}

// 	formattedContentTopic, err := node.FormatContentTopic("appName", 1, "cTopicName", "enc")
// 	if err != nil {
// 		fmt.Println("Error happened:", err.Error())
// 		return
// 	}

// 	formattedPubsubTopic, err := node.FormatPubsubTopic("my-ctopic")
// 	if err != nil {
// 		fmt.Println("Error happened:", err.Error())
// 		return
// 	}

// 	listenAddresses, err := node.WakuListenAddresses()
// 	if err != nil {
// 		fmt.Println("Error happened:", err.Error())
// 		return
// 	}

// 	fmt.Println("Version:", version)
// 	fmt.Println("Custom content topic:", formattedContentTopic)
// 	fmt.Println("Custom pubsub topic:", formattedPubsubTopic)
// 	fmt.Println("Default pubsub topic:", defaultPubsubTopic)
// 	fmt.Println("Listen addresses:", listenAddresses)

// 	// Wait for a SIGINT or SIGTERM signal
// 	ch := make(chan os.Signal, 1)
// 	signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
// 	<-ch

// 	err = node.WakuStop()
// 	if err != nil {
// 		fmt.Println("Error happened:", err.Error())
// 		return
// 	}

// 	err = node.WakuDestroy()
// 	if err != nil {
// 		fmt.Println("Error happened:", err.Error())
// 		return
// 	}
// }

// MaxMessageSize returns the maximum accepted message size.
func (w *Waku) MaxMessageSize() uint32 {
	return w.cfg.MaxMessageSize
}

// New creates a WakuV2 client ready to communicate through the LibP2P network.
func New(nodeKey *ecdsa.PrivateKey,
	fleet string,
	cfg *Config,
	logger *zap.Logger,
	appDB *sql.DB,
	ts *timesource.NTPTimeSource,
	onHistoricMessagesRequestFailed func([]byte, peer.ID, error),
	onPeerStats func(types.ConnStatus)) (*Waku, error) {

	fmt.Println("-------- GABRIEL func New 1 ---------")

	// Lock the main goroutine to its current OS thread
	runtime.LockOSThread()

	fmt.Println("-------- GABRIEL func New 2 ---------")

	WakuSetup() // This should only be called once in the whole app's life

	fmt.Println("-------- GABRIEL func New 3 ---------")
	node, err := wakuNew(nodeKey,
		fleet,
		cfg, logger, appDB, ts, onHistoricMessagesRequestFailed,
		onPeerStats)
	if err != nil {
		return nil, err
	}

	fmt.Println("-------- GABRIEL func New 4 ---------")
	defaultPubsubTopic, err := node.WakuDefaultPubsubTopic()
	if err != nil {
		fmt.Println("Error happened:", err.Error())
	}

	fmt.Println("-------- GABRIEL func New 5 ---------")
	err = node.WakuRelaySubscribe(defaultPubsubTopic)
	if err != nil {
		fmt.Println("Error happened:", err.Error())
	}

	fmt.Println("-------- GABRIEL func New 6 ---------")
	node.WakuSetEventCallback()
	fmt.Println("-------- GABRIEL func New 7 ---------")

	return node, nil

	// if !cfg.UseThrottledPublish || testing.Testing() {
	// 	// To avoid delaying the tests, or for when we dont want to rate limit, we set up an infinite rate limiter,
	// 	// basically disabling the rate limit functionality
	// 	waku.limiter = publish.NewPublishRateLimiter(rate.Inf, 1)

	// } else {
	// 	waku.limiter = publish.NewPublishRateLimiter(publishingLimiterRate, publishingLimitBurst)
	// }

	// waku.filters = common.NewFilters(waku.cfg.DefaultShardPubsubTopic, waku.logger)
	// waku.bandwidthCounter = metrics.NewBandwidthCounter()

	// if nodeKey == nil {
	// 	// No nodekey is provided, create an ephemeral key
	// 	nodeKey, err = crypto.GenerateKey()
	// 	if err != nil {
	// 		return nil, fmt.Errorf("failed to generate a random go-waku private key: %v", err)
	// 	}
	// }

	// hostAddr, err := net.ResolveTCPAddr("tcp", fmt.Sprint(cfg.Host, ":", cfg.Port))
	// if err != nil {
	// 	return nil, fmt.Errorf("failed to setup the network interface: %v", err)
	// }

	// libp2pOpts := node.DefaultLibP2POptions
	// libp2pOpts = append(libp2pOpts, libp2p.BandwidthReporter(waku.bandwidthCounter))
	// libp2pOpts = append(libp2pOpts, libp2p.NATPortMap())

	// opts := []node.WakuNodeOption{
	// 	node.WithLibP2POptions(libp2pOpts...),
	// 	node.WithPrivateKey(nodeKey),
	// 	node.WithHostAddress(hostAddr),
	// 	node.WithConnectionNotification(waku.connectionNotifChan),
	// 	node.WithTopicHealthStatusChannel(waku.topicHealthStatusChan),
	// 	node.WithKeepAlive(randomPeersKeepAliveInterval, allPeersKeepAliveInterval),
	// 	node.WithLogger(logger),
	// 	node.WithLogLevel(logger.Level()),
	// 	node.WithClusterID(cfg.ClusterID),
	// 	node.WithMaxMsgSize(1024 * 1024),
	// }

	// if cfg.EnableDiscV5 {
	// 	bootnodes, err := waku.getDiscV5BootstrapNodes(waku.ctx, cfg.DiscV5BootstrapNodes)
	// 	if err != nil {
	// 		logger.Error("failed to get bootstrap nodes", zap.Error(err))
	// 		return nil, err
	// 	}
	// 	opts = append(opts, node.WithDiscoveryV5(uint(cfg.UDPPort), bootnodes, cfg.AutoUpdate))
	// }
	// shards, err := protocol.TopicsToRelayShards(cfg.DefaultShardPubsubTopic)
	// if err != nil {
	// 	logger.Error("FATAL ERROR: failed to parse relay shards", zap.Error(err))
	// 	return nil, errors.New("failed to parse relay shard, invalid pubsubTopic configuration")
	// }
	// if len(shards) == 0 { //Hack so that tests don't fail. TODO: Need to remove this once tests are changed to use proper cluster and shard.
	// 	shardInfo := protocol.RelayShards{ClusterID: 0, ShardIDs: []uint16{0}}
	// 	shards = append(shards, shardInfo)
	// }
	// waku.defaultShardInfo = shards[0]
	// if cfg.LightClient {
	// 	opts = append(opts, node.WithWakuFilterLightNode())
	// 	waku.defaultShardInfo = shards[0]
	// 	opts = append(opts, node.WithMaxPeerConnections(cfg.DiscoveryLimit))
	// 	cfg.EnableStoreConfirmationForMessagesSent = false
	// 	//TODO: temporary work-around to improve lightClient connectivity, need to be removed once community sharding is implemented
	// 	opts = append(opts, node.WithPubSubTopics(cfg.DefaultShardedPubsubTopics))
	// } else {
	// 	relayOpts := []pubsub.Option{
	// 		pubsub.WithMaxMessageSize(int(waku.cfg.MaxMessageSize)),
	// 	}

	// 	if waku.logger.Level() == zap.DebugLevel {
	// 		relayOpts = append(relayOpts, pubsub.WithEventTracer(waku))
	// 	}

	// 	opts = append(opts, node.WithWakuRelayAndMinPeers(waku.cfg.MinPeersForRelay, relayOpts...))
	// 	opts = append(opts, node.WithMaxPeerConnections(maxRelayPeers))
	// 	cfg.EnablePeerExchangeClient = true //Enabling this until discv5 issues are resolved. This will enable more peers to be connected for relay mesh.
	// 	cfg.EnableStoreConfirmationForMessagesSent = true
	// }

	// if cfg.EnableStore {
	// 	if appDB == nil {
	// 		return nil, errors.New("appDB is required for store")
	// 	}
	// 	opts = append(opts, node.WithWakuStore())
	// 	dbStore, err := persistence.NewDBStore(logger, persistence.WithDB(appDB), persistence.WithRetentionPolicy(cfg.StoreCapacity, time.Duration(cfg.StoreSeconds)*time.Second))
	// 	if err != nil {
	// 		return nil, err
	// 	}
	// 	opts = append(opts, node.WithMessageProvider(dbStore))
	// }

	// if !cfg.LightClient {
	// 	opts = append(opts, node.WithWakuFilterFullNode(filter.WithMaxSubscribers(20)))
	// 	opts = append(opts, node.WithLightPush(lightpush.WithRateLimiter(1, 1)))
	// }

	// if appDB != nil {
	// 	waku.protectedTopicStore, err = persistence.NewProtectedTopicsStore(logger, appDB)
	// 	if err != nil {
	// 		return nil, err
	// 	}
	// }

	// if cfg.EnablePeerExchangeServer {
	// 	opts = append(opts, node.WithPeerExchange(peer_exchange.WithRateLimiter(1, 1)))
	// }

	// waku.options = opts
	// waku.logger.Info("setup the go-waku node successfully")

	// return waku, nil
}