package main

import (
    "context"
    "time"
    
    "github.com/depinkit/network"
    "github.com/depinkit/network/config"
    "github.com/depinkit/network/libp2p"
    "github.com/spf13/afero"
    "gitlab.com/nunet/device-management-service/types"
)

func main() {
    // Create configuration
    cfg := &config.Config{
        P2P: config.P2P{
            ListenAddress: []string{
                "/ip4/0.0.0.0/tcp/9000",
                "/ip4/0.0.0.0/udp/9001/quic-v1",
            },
            BootstrapPeers: []string{
                // Bootstrap peer addresses
            },
        },
    }
    
    // Create libp2p configuration
    libp2pCfg := &types.Libp2pConfig{
        PrivateKey:     generatePrivKey(), // Your key generation
        Rendezvous:     "my-network",
        ListenAddress:  cfg.P2P.ListenAddress,
        BootstrapPeers: parseBootstrapPeers(cfg.P2P.BootstrapPeers),
    }
    
    // Create libp2p instance
    fs := afero.NewOsFs()
    l, err := libp2p.NewLibp2p(libp2pCfg, fs)
    if err != nil {
        panic(err)
    }
    
    // Initialize and start
    if err := l.Init(cfg); err != nil {
        panic(err)
    }
    if err := l.Start(); err != nil {
        panic(err)
    }
    
    defer l.Stop()
    
    // Your application logic here
    select {}
}

// Register a custom protocol handler
handler := func(stream network.Stream) {
    defer stream.Close()
    
    // Read from stream
    buf := make([]byte, 1024)
    n, err := stream.Read(buf)
    if err != nil {
        return
    }
    
    // Process and respond
    response := processMessage(buf[:n])
    stream.Write(response)
}

l.SetStreamHandler("/my-protocol/1.0.0", handler)

import (
    "github.com/depinkit/network/libp2p"
)

// Subscribe to a topic
topic := "/my-app/messages"
if err := l.Subscribe(context.Background(), topic); err != nil {
    panic(err)
}

// Add handler for messages on this topic
validator := func(msg *libp2p.Message) bool {
    // Validate message
    return true
}

l.RegisterTopicValidator(topic, 0, validator, libp2p.ValidatorOptions{})

// Publish a message
message := []byte("Hello, network!")
if err := l.Publish(context.Background(), topic, message); err != nil {
    log.Error("Failed to publish")
}

// Create a virtual subnet
subnetCfg := &libp2p.SubnetConfig{
    CIDR:      "10.0.0.0/24",
    Routes:    map[string]peer.ID{
        "10.0.0.2": peerID,
    },
    DNSZones: map[string]string{
        "app.local": "10.0.0.2",
    },
}

subnet, err := l.CreateSubnet(context.Background(), "my-subnet", subnetCfg)
if err != nil {
    panic(err)
}
defer subnet.Close()

// Now you can use standard networking to connect to peers
// via their virtual IPs (e.g., dial tcp://10.0.0.2:8080)

type Network interface {
    Init(cfg *config.Config) error
    Start() error
    Stop() error
    Host() host.Host
    DHT() *dht.IpfsDHT
}

cfg := &config.Config{
    General: config.General{
        DataDir: "/var/lib/myapp",
        Debug:   true,
    },
    P2P: config.P2P{
        ListenAddress: []string{
            "/ip4/0.0.0.0/tcp/9000",
            "/ip4/0.0.0.0/udp/9001/quic-v1",
        },
        BootstrapPeers: []string{
            "/ip4/bootstrap.example.com/tcp/4001/p2p/12D3...",
        },
        Memory:          512,  // MB for libp2p
        FileDescriptors: 2048,
    },
}

import "github.com/depinkit/network/background_tasks"

scheduler := background_tasks.NewScheduler(10, time.Second)

task := &background_tasks.Task{
    Name:        "Heartbeat",
    Description: "Send periodic heartbeat",
    Function: func(_ interface{}) error {
        return sendHeartbeat()
    },
    Triggers: []background_tasks.Trigger{
        &background_tasks.PeriodicTrigger{
            Interval: 30 * time.Second,
        },
    },
}

scheduler.AddTask(task)
scheduler.Start()
defer scheduler.Stop()

// Provide a value in the DHT
key := "/myapp/value"
value := []byte("important data")
if err := l.DHT().PutValue(ctx, key, value); err != nil {
    log.Error("Failed to put value")
}

// Find a value in the DHT
val, err := l.DHT().GetValue(ctx, key)
if err != nil {
    log.Error("Failed to get value")
}

// Find peers providing a service
peers, err := l.FindPeers(ctx, "my-service", 10)
if err != nil {
    log.Error("Discovery failed")
}

for _, p := range peers {
    // Connect to peer
    if err := l.Host().Connect(ctx, p); err != nil {
        log.Warnf("Failed to connect to %s", p.ID)
    }
}

// Get connected peers
peers := l.Host().Network().Peers()
log.Infof("Connected to %d peers", len(peers))

// Get connection info
for _, p := range peers {
    conns := l.Host().Network().ConnsToPeer(p)
    for _, conn := range conns {
        log.Infof("Connection to %s via %s", 
            p, conn.RemoteMultiaddr())
    }
}

import (
    "github.com/depinkit/network/libp2p"
    "gitlab.com/nunet/device-management-service/types"
)

libp2pCfg := &types.Libp2pConfig{
    // Configuration
}