package main

import (
    "fmt"
    "log"
    "github.com/dbesio/ygo/pkg/yjs"
)

func main() {
    // Create reconstructor 
    config := yjs.Config{
        Implementation: "yffi", 
    }
    
    reconstructor, err := yjs.NewReconstructor(config)
    if err != nil {
        log.Fatal(err)
    }
    
    // Create a new document
    doc, err := reconstructor.NewDocument()
    if err != nil {
        log.Fatal(err)
    }
    defer doc.Close()
    
    // Insert some text
    err = doc.InsertText("content", 0, "Hello, World!")
    if err != nil {
        log.Fatal(err)
    }
    
    // Get the text
    text, err := doc.GetText("content")
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Printf("Document content: %s\n", text)
    
    // Get update for synchronization
    update, err := doc.GetUpdate()
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Printf("Update size: %d bytes\n", len(update))
}

// Apply multiple deltas to reconstruct file content
deltas := []*yjs.Delta{
    {
        ID:          "delta-1",
        FilePath:    "main.go",
        Data:        deltaBytes1,
        Timestamp:   time.Now(),
        DeltaCount:  1,
    },
    {
        ID:          "delta-2", 
        FilePath:    "main.go",
        Data:        deltaBytes2,
        Timestamp:   time.Now(),
        DeltaCount:  1,
    },
}

baseContent := []byte("// Initial content\n")
result, err := reconstructor.ApplyDeltas(baseContent, deltas)
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Reconstructed content:\n%s\n", string(result))

type Reconstructor interface {
    ApplyDeltas(baseContent []byte, deltas []*Delta) ([]byte, error)
    CreateEmptyDocument() ([]byte, error)
    ValidateDelta(delta []byte) error
    MergeDeltas(deltas []*Delta) (*Delta, error)
    NewDocument() (Document, error)
}

type Document interface {
    InsertText(field string, index uint32, text string) error
    DeleteText(field string, index uint32, length uint32) error
    GetText(field string) (string, error)
    ApplyUpdate(update []byte) error
    GetUpdate() ([]byte, error)
    GetStateVector() ([]byte, error)
    Close() error
}

type Delta struct {
    ID          string    `json:"id"`
    FilePath    string    `json:"file_path"`
    Data        []byte    `json:"data"`
    Timestamp   time.Time `json:"timestamp"`
    DeltaCount  int       `json:"delta_count"`
}

type Config struct {
    Implementation string // "yffi" or "mock"
    
    // yffi-specific options
    YffiLibPath    string
    YffiHeaderPath string
    
    // Mock-specific options
    MockValidation bool
}