package main

import (
    "github.com/execute008/goelectrodb/electrodb"
)

func main() {
    // Define schema
    schema := &electrodb.Schema{
        Service: "MyApp",
        Entity:  "User",
        Table:   "my-table",

        Attributes: map[string]*electrodb.AttributeDefinition{
            "userId": {
                Type:     electrodb.AttributeTypeString,
                Required: true,
            },
            "email": {
                Type:     electrodb.AttributeTypeString,
                Required: true,
            },
            "status": {
                Type:       electrodb.AttributeTypeEnum,
                EnumValues: []interface{}{"active", "inactive"},
                Default:    func() interface{} { return "active" },
            },
        },

        Indexes: map[string]*electrodb.IndexDefinition{
            "primary": {
                PK: electrodb.FacetDefinition{
                    Field:  "pk",
                    Facets: []string{"userId"},
                },
            },
        },

        // Automatic timestamp management
        Timestamps: &electrodb.TimestampsConfig{
            CreatedAt: "createdAt",
            UpdatedAt: "updatedAt",
        },
    }

    // Create entity
    entity, _ := electrodb.NewEntity(schema, nil)

    // Put item
    entity.Put(electrodb.Item{
        "userId": "user-123",
        "email":  "[email protected]",
    }).Go()

    // Get item
    result, _ := entity.Get(electrodb.Keys{"userId": "user-123"}).Go()

    // Update with multiple operations
    entity.Update(electrodb.Keys{"userId": "user-123"}).
        Set(map[string]interface{}{"email": "[email protected]"}).
        Add(map[string]interface{}{"loginCount": 1}).
        Append(map[string]interface{}{"tags": []string{"verified"}}).
        Go()

    // Query with filters
    results, _ := entity.Query("primary").
        Query("user-123").
        Where(func(attr electrodb.AttributeRef) string {
            return attr["status"].Eq("active")
        }).
        Go()
}

schema := &electrodb.Schema{
    Attributes: map[string]*electrodb.AttributeDefinition{
        "email": {
            Type: electrodb.AttributeTypeString,
            Validate: func(value interface{}) error {
                email, ok := value.(string)
                if !ok || !strings.Contains(email, "@") {
                    return errors.New("invalid email")
                }
                return nil
            },
            Set: func(value interface{}) interface{} {
                if email, ok := value.(string); ok {
                    return strings.ToLower(email)
                }
                return value
            },
        },
    },
}

// Automatic pagination (fetches all pages)
allItems, err := entity.Query("primary").
    Query("user-123").
    Pages(electrodb.PagesOptions{
        MaxPages: 10,
        Limit:    50,
    })

// Manual pagination
iterator := entity.Query("primary").
    Query("user-123").
    Page(electrodb.PagesOptions{Limit: 20})

for {
    page, hasMore, err := iterator.Next()
    if err != nil || !hasMore {
        break
    }
    // Process page.Data
}

// Batch Get
results, _ := entity.BatchGet([]electrodb.Keys{
    {"userId": "user-1"},
    {"userId": "user-2"},
    {"userId": "user-3"},
}).Go()

// Batch Write
entity.BatchWrite().
    Put([]electrodb.Item{
        {"userId": "user-4", "email": "[email protected]"},
        {"userId": "user-5", "email": "[email protected]"},
    }).
    Delete([]electrodb.Keys{
        {"userId": "user-6"},
    }).
    Go()

service.Transaction().
    Write(entity1.Put(item1).Commit()).
    Write(entity2.Update(keys).Set(updates).Commit()).
    Write(entity3.Delete(keys).Commit()).
    Commit()