package zsocket

import (

"bytes"

"compress/flate"

"fmt"

"io"

)

// Compressor describes per-message compression behavior.

type Compressor interface {

Compress(data []byte) ([]byte, error)

Decompress(data []byte) ([]byte, error)

}

// Deflate implements RFC7692-like per-message deflate without context takeover.

type Deflate struct {

level int

}

// NewDeflate creates a deflate compressor with the given level.

func NewDeflate(level int) (*Deflate, error) {

if level == 0 {

level = flate.DefaultCompression

}

if level < flate.HuffmanOnly || level > flate.BestCompression {

if level != flate.DefaultCompression {

return nil, fmt.Errorf("zsocket: invalid compression level %d", level)

}

}

return &Deflate{level: level}, nil

}

func (d *Deflate) Compress(data []byte) ([]byte, error) {

if len(data) == 0 {

return nil, nil

}

var out bytes.Buffer

w, err := flate.NewWriter(&out, d.level)

if err != nil {

return nil, err

}

if _, err := w.Write(data); err != nil {

_ = w.Close()

return nil, err

}

if err := w.Close(); err != nil {

return nil, err

}

return out.Bytes(), nil

}

func (d *Deflate) Decompress(data []byte) ([]byte, error) {

if len(data) == 0 {

return nil, nil

}

r := flate.NewReader(bytes.NewReader(data))

defer r.Close()

return io.ReadAll(r)

}