package main

import (
    "fmt"
    "sync"

    "github.com/pion/interceptor"
    "github.com/pion/rtp"
)

// LoggerInterceptor logs RTP packets for each stream
type LoggerInterceptor struct {
    interceptor.NoOp
    mu           sync.Mutex
    packetCounts map[uint32]int
}

// NewLoggerInterceptor creates a new logger interceptor
func NewLoggerInterceptor() *LoggerInterceptor {
    return &LoggerInterceptor{
        packetCounts: make(map[uint32]int),
    }
}

// BindLocalStream is called when a new local stream is created
func (l *LoggerInterceptor) BindLocalStream(info *interceptor.StreamInfo, writer interceptor.RTPWriter) interceptor.RTPWriter {
    fmt.Printf("[Logger] New local stream bound - SSRC: %d, PayloadType: %d\n", 
        info.SSRC, info.PayloadType)
    
    // Return a writer that logs each packet
    return interceptor.RTPWriterFunc(func(header *rtp.Header, payload []byte, attributes interceptor.Attributes) (int, error) {
        // Increment packet count
        l.mu.Lock()
        l.packetCounts[header.SSRC]++
        count := l.packetCounts[header.SSRC]
        l.mu.Unlock()
        
        // Log packet information
        fmt.Printf("[Logger] SSRC: %d, Seq: %d, Timestamp: %d, Payload: %d bytes, Count: %d\n",
            header.SSRC, header.SequenceNumber, header.Timestamp, len(payload), count)
        
        // Pass the packet to the next writer in the chain
        return writer.Write(header, payload, attributes)
    })
}

// UnbindLocalStream is called when a stream is removed
func (l *LoggerInterceptor) UnbindLocalStream(info *interceptor.StreamInfo) {
    l.mu.Lock()
    defer l.mu.Unlock()
    
    count := l.packetCounts[info.SSRC]
    delete(l.packetCounts, info.SSRC)
    
    fmt.Printf("[Logger] Stream unbound - SSRC: %d, Total packets: %d\n", 
        info.SSRC, count)
}

// Close cleans up the interceptor
func (l *LoggerInterceptor) Close() error {
    fmt.Println("[Logger] Interceptor closed")
    return nil
}

package main

import (
    "fmt"
    "time"

    "github.com/pion/interceptor"
    "github.com/pion/rtp"
)

func main() {
    fmt.Println("Starting Pion Interceptor example...\n")
    
    // Create our custom logger interceptor
    logger := NewLoggerInterceptor()
    
    // Create an interceptor chain
    chain := interceptor.NewChain([]interceptor.Interceptor{logger})
    defer chain.Close()
    
    // Simulate a stream being bound
    streamInfo := &interceptor.StreamInfo{
        SSRC:        12345,
        PayloadType: 96,
        MimeType:    "video/VP8",
        ClockRate:   90000,
    }
    
    // Bind the local stream with a writer that simulates sending packets
    writer := chain.BindLocalStream(streamInfo, interceptor.RTPWriterFunc(
        func(header *rtp.Header, payload []byte, attributes interceptor.Attributes) (int, error) {
            // This is the final writer - in a real app, this would send to the network
            return len(payload), nil
        },
    ))
    
    // Simulate sending 10 RTP packets
    fmt.Println("\nSending packets...\n")
    for i := uint16(0); i < 10; i++ {
        header := &rtp.Header{
            Version:        2,
            SSRC:           12345,
            SequenceNumber: i,
            Timestamp:      uint32(i * 3000),
            PayloadType:    96,
        }
        
        payload := []byte(fmt.Sprintf("Packet %d", i))
        
        if _, err := writer.Write(header, payload, nil); err != nil {
            fmt.Printf("Error writing packet: %v\n", err)
            return
        }
        
        // Small delay between packets
        time.Sleep(100 * time.Millisecond)
    }
    
    // Unbind the stream
    fmt.Println("\nUnbinding stream...\n")
    chain.UnbindLocalStream(streamInfo)
    
    fmt.Println("\nExample completed successfully!")
}

package main

import (
    "fmt"
    "time"

    "github.com/pion/interceptor"
    "github.com/pion/interceptor/pkg/nack"
    "github.com/pion/rtcp"
    "github.com/pion/rtp"
)

func nackExample() {
    // Create a NACK responder factory
    responderFactory, err := nack.NewResponderInterceptor()
    if err != nil {
        panic(err)
    }
    
    // Build the interceptor
    responder, err := responderFactory.NewInterceptor("")
    if err != nil {
        panic(err)
    }
    
    // Create a chain with the NACK responder
    chain := interceptor.NewChain([]interceptor.Interceptor{responder})
    defer chain.Close()
    
    // Bind RTCP reader to receive NACK packets
    rtcpReader := chain.BindRTCPReader(
        interceptor.RTCPReaderFunc(func(b []byte, a interceptor.Attributes) (int, interceptor.Attributes, error) {
            return len(b), nil, nil
        }),
    )
    
    // Bind local stream
    streamInfo := &interceptor.StreamInfo{
        SSRC:         5000,
        RTCPFeedback: []interceptor.RTCPFeedback{{Type: "nack", Parameter: ""}},
    }
    
    streamWriter := chain.BindLocalStream(streamInfo, 
        interceptor.RTPWriterFunc(func(header *rtp.Header, payload []byte, attributes interceptor.Attributes) (int, error) {
            fmt.Printf("Sending packet: Seq=%d\n", header.SequenceNumber)
            return len(payload), nil
        }),
    )
    
    // Send some packets
    for i := uint16(0); i < 5; i++ {
        header := &rtp.Header{
            Version:        2,
            SSRC:           5000,
            SequenceNumber: i,
            Timestamp:      uint32(i * 3000),
        }
        streamWriter.Write(header, []byte{0x01, 0x02, 0x03}, nil)
        time.Sleep(50 * time.Millisecond)
    }
    
    // Simulate receiving a NACK for packet 2
    fmt.Println("\nSimulating NACK for packet 2...")
    nackPacket := &rtcp.TransportLayerNack{
        MediaSSRC: 5000,
        Nacks:     []rtcp.NackPair{{PacketID: 2}},
    }
    
    nackBytes, _ := nackPacket.Marshal()
    rtcpReader.Read(nackBytes, nil)
    
    time.Sleep(100 * time.Millisecond)
    fmt.Println("\nNACK example completed!")
}