// Simple as JSON, fast as binary
data, _ := beve.Marshal(user)        // Encode to BEVE
beve.Unmarshal(data, &decoded)       // Decode from BEVE

package main

import (
    "fmt"
    beve "github.com/beve-org/beve-go"
)

type User struct {
    ID       int64     `beve:"id"`
    Username string    `beve:"username"`
    Email    string    `beve:"email,omitempty"`
    IsActive bool      `beve:"active"`
    Tags     []string  `beve:"tags"`
}

func main() {
    user := User{
        ID:       12345,
        Username: "alice",
        Email:    "[email protected]",
        IsActive: true,
        Tags:     []string{"premium", "verified"},
    }

    // Marshal to BEVE
    data, err := beve.Marshal(user)
    if err != nil {
        panic(err)
    }
    fmt.Printf("Encoded: %d bytes\n", len(data))

    // Unmarshal from BEVE
    var decoded User
    err = beve.Unmarshal(data, &decoded)
    if err != nil {
        panic(err)
    }
    fmt.Printf("Decoded: %+v\n", decoded)
}

// Replace this:
import "encoding/json"
data, _ := json.Marshal(v)
json.Unmarshal(data, &v)

// With this:
import beve "github.com/beve-org/beve-go"
data, _ := beve.Marshal(v)
beve.Unmarshal(data, &v)

// Done! 🎉 Enjoy 2-40× faster serialization

// Standard marshal (optimized, pooled buffers)
data, _ := beve.Marshal(obj)

// Zero-copy mode (2-8× faster, returns internal buffer)
data, _ := beve.MarshalZeroCopy(obj)

// Encoder with io.Writer (streaming)
enc := beve.NewEncoder(conn)
enc.Encode(obj1)
enc.Encode(obj2)

type Product struct {
    ID          int64   `beve:"id"`
    Name        string  `beve:"name"`
    Description string  `beve:"description,omitempty"` // Skip if empty
    Price       float64 `beve:"price"`
    Tags        []string `beve:"tags"`
    Internal    string  `beve:"-"` // Ignore field
}

// Existing struct with json tags
type User struct {
    ID       int    `json:"id"`
    Username string `json:"username"`
    Email    string `json:"email,omitempty"`
}

// Configure BEVE to use json tags
beve.SetStructTag("json")

// Now BEVE reads json:"..." tags instead of beve:"..."
data, _ := beve.Marshal(user)
beve.Unmarshal(data, &user)

type Product struct {
    ID    int64   `beve:"id" json:"product_id" msgpack:"pid"`
    Name  string  `beve:"name" json:"title" msgpack:"n"`
    Price float64 `beve:"price" json:"price" msgpack:"p"`
}

// Use different tag configurations
beve.SetStructTag("beve")    // Uses: id, name, price
beve.SetStructTag("json")    // Uses: product_id, title, price
beve.SetStructTag("msgpack") // Uses: pid, n, p

currentTag := beve.GetStructTag() // Returns "beve", "json", etc.

func init() {
    beve.SetStructTag("json") // Use json tags throughout the app
}

// ✅ GOOD: Pass pointer (1 allocation)
user := User{...}
data, _ := beve.Marshal(&user)

// ❌ BAD: Pass value (3 allocations, slower)
user := User{...}
data, _ := beve.Marshal(user)  // Creates heap copy!

// Ultra-fast mode: 0 allocations, 0 bytes!
data, _ := beve.MarshalZeroCopy(&user)  // 277ns vs 889ns

// Reuse encoder for batch operations
enc := beve.GetEncoderFromPool()
defer beve.PutEncoderToPool(enc)

for _, item := range items {
    data, _ := enc.Marshal(&item)  // No buffer allocation
    enc.Reset()  // Reset for next item
}

// ✅ Primitives
int, int8, int16, int32, int64
uint, uint8, uint16, uint32, uint64
float32, float64
bool, string

// ✅ Complex Types
[]T           // Slices (typed arrays for primitives)
[N]T          // Fixed arrays
map[string]T  // String-keyed maps
map[int]T     // Integer-keyed maps
*T            // Pointers (nullable)

// ✅ Nested Structs
type Address struct { City string }
type User struct { Addr Address }

// ✅ time.Time (optimized fast path)
CreatedAt time.Time `beve:"created_at"`

type Point struct {
    X, Y float64
}

func (p Point) MarshalBEVE() ([]byte, error) {
    return beve.Marshal([]float64{p.X, p.Y})
}

func (p *Point) UnmarshalBEVE(data []byte) error {
    var coords []float64
    if err := beve.Unmarshal(data, &coords); err != nil {
        return err
    }
    p.X, p.Y = coords[0], coords[1]
    return nil
}

// Encode multiple objects
var buf bytes.Buffer
enc := beve.NewEncoder(&buf)
enc.Encode(user1)
enc.Encode(user2)

// Decode multiple objects
dec := beve.NewDecoder(buf.Bytes())
dec.Decode(&user1)
dec.Decode(&user2)

// Automatic pooling with GetEncoderFromPool
enc := beve.GetEncoderFromPool()
defer beve.PutEncoderToPool(enc)

enc.Encode(data)
result := enc.Bytes()

import "github.com/beve-org/beve-go/translator"

// JSON → BEVE
jsonData := []byte(`{"name":"Alice","age":30}`)
beveData, err := translator.FromJSON(jsonData)

// BEVE → JSON
jsonData, err := translator.ToJSON(beveData)

// BEVE → Pretty JSON
jsonStr, err := translator.ToJSONIndent(beveData, "", "  ")
fmt.Println(jsonStr)
// Output:
// {
//   "name": "Alice",
//   "age": 30
// }

// With statistics
beveData, stats, err := translator.FromJSONWithStats(jsonData)
fmt.Printf("Space saved: %.1f%%\n", stats.Savings*100)
fmt.Printf("Compression ratio: %.2fx\n", stats.CompressionRatio)

//go:generate bevegen -type=User

type User struct {
    ID    int64  `beve:"id"`
    Name  string `beve:"name"`
    Email string `beve:"email,omitempty"`
}

func UserHandler(w http.ResponseWriter, r *http.Request) {
    user := getUser(r.Context())
    
    // Encode to BEVE
    data, err := beve.Marshal(user)
    if err != nil {
        http.Error(w, err.Error(), 500)
        return
    }
    
    w.Header().Set("Content-Type", "application/beve")
    w.Write(data)
}

import "github.com/redis/go-redis/v9"

func CacheUser(ctx context.Context, user *User) error {
    // Encode to BEVE (30% smaller than JSON)
    data, err := beve.Marshal(user)
    if err != nil {
        return err
    }
    
    // Store in Redis
    key := fmt.Sprintf("user:%d", user.ID)
    return rdb.Set(ctx, key, data, time.Hour).Err()
}

func GetCachedUser(ctx context.Context, id int64) (*User, error) {
    key := fmt.Sprintf("user:%d", id)
    data, err := rdb.Get(ctx, key).Bytes()
    if err != nil {
        return nil, err
    }
    
    var user User
    err = beve.Unmarshal(data, &user)
    return &user, err
}

func PublishEvent(conn net.Conn, event *Event) error {
    enc := beve.NewEncoder(conn)
    return enc.Encode(event)
}

func ConsumeEvents(conn net.Conn) error {
    dec := beve.NewDecoder(conn)
    
    for {
        var event Event
        if err := dec.Decode(&event); err != nil {
            if err == io.EOF {
                break
            }
            return err
        }
        
        handleEvent(&event)
    }
    return nil
}

import (
    "gorm.io/gorm"
    beve "github.com/beve-org/beve-go"
)

type Product struct {
    gorm.Model
    Code  string `gorm:"size:100" beve:"code"`
    Price uint   `beve:"price"`
}

// Cache GORM model in Redis
product := Product{Code: "D42", Price: 100}
db.Create(&product)

data, _ := beve.Marshal(product)
redis.Set("product:1", data, time.Hour)

// Retrieve from cache
var cached Product
data, _ := redis.Get("product:1").Bytes()
beve.Unmarshal(data, &cached)

obj := map[string]interface{}{
    "name": "Alice",
    "age": 30,
    "email": "[email protected]",
}

// Encode with field index
data, _ := beve.EncodeIndexedObject(obj)

// Fast field access (77ns, O(1))
email, _ := beve.ReadFieldByName(data, "email")
fmt.Println(email) // "[email protected]"

users := []User{
    {Name: "Alice", Age: 30},
    {Name: "Bob", Age: 25},
}

// Automatic typed array encoding
data, _ := beve.MarshalTyped(users)

// Or use auto-detection
data, _ := beve.MarshalAuto(users)

now := time.Now()

// Encode timestamp (14-16 bytes)
data, _ := beve.MarshalTimestamp(now)

// Decode with full precision
decoded, _ := beve.UnmarshalTimestamp(data)
fmt.Println(decoded.Equal(now)) // true

// Duration (14 bytes, signed)
duration := 5*time.Hour + 30*time.Minute
data, _ := beve.EncodeDuration(duration)

// Interval (29 bytes, 2 timestamps)
start := time.Now()
end := start.Add(time.Hour)
data, _ := beve.EncodeInterval(start, end)

// From binary (18 bytes vs 36 for string)
uuid := [16]byte{...}
data, _ := beve.MarshalUUID(uuid)

// From string
uuidStr := "6ba7b810-9dad-41d1-80b4-00c04fd430c8"
data, _ := beve.MarshalUUIDString(uuidStr)

pattern := regexp.MustCompile("^[a-z0-9._%+-]+@[a-z0-9.-]+\\.[a-z]{2,}$")

// Encode regex (7-51 bytes)
data, _ := beve.MarshalRegExp(pattern)

// Decode and use
decoded, _ := beve.UnmarshalRegExp(data)
decoded.MatchString("[email protected]") // true

// Automatically detects and decodes any extension
var result interface{}
beve.Unmarshal(data, &result)

import "github.com/beve-org/beve-go/core"

// Create arena pool for reuse (55% faster than create/destroy)
pool := core.NewArenaPool(16 * 1024) // 16KB arenas

// Encode with arena
arena := pool.Get()
enc := core.GetEncoderFromPoolWithArena(arena)
enc.Encode(largeData)
core.PutEncoderToPool(enc)
pool.Put(arena) // Reuse arena

// Decode with arena
arena = pool.Get()
dec := core.NewDecoderWithArena(data, arena)
var result LargeStruct
dec.Decode(&result)
core.PutDecoderToPool(dec)
pool.Put(arena)