package main

import (
    "fmt"
    "log"
    
    "github.com/mkfoss/foxi"
)

func main() {
    // Create new instance (backend selected by build tags)
    f := foxi.NewFoxi()
    
    // Open database
    err := f.Open("customers.dbf")
    if err != nil {
        log.Fatal(err)
    }
    defer f.Close()
    
    // Show backend information
    fmt.Printf("Using backend: %s\n", f.Backend().String())
    
    // Get database information  
    header := f.Header()
    fmt.Printf("Records: %d, Last Updated: %s\n", 
        header.RecordCount(), header.LastUpdated().Format("2006-01-02"))
    
    // Navigate through records
    f.First()
    for !f.EOF() {
        nameField := f.FieldByName("NAME")
        name, _ := nameField.AsString()
        
        ageField := f.FieldByName("AGE") 
        age, _ := ageField.AsInt()
        
        fmt.Printf("Record %d: %s, Age: %d\n", f.Position(), name, age)
        f.Next()
    }
}

f := foxi.NewFoxi()         // Create new instance
err := f.Open("data.dbf")   // Open database
defer f.Close()             // Always close when done
active := f.Active()        // Check if database is open
backend := f.Backend()      // Get backend information

header := f.Header()
count := header.RecordCount()        // Total records
updated := header.LastUpdated()     // Last modification date
hasIndex := header.HasIndex()       // Has index files
hasMemo := header.HasFpt()          // Has memo file
codepage := header.Codepage()       // Character encoding

// Field count and enumeration
fieldCount := f.FieldCount()
for i := 0; i < fieldCount; i++ {
    field := f.Field(i)
    fmt.Printf("%s (%s)\n", field.Name(), field.Type().String())
}

// Access field by name
nameField := f.FieldByName("CUSTOMER_NAME")
if nameField != nil {
    value, _ := nameField.AsString()
    fieldType := nameField.Type()
    size := nameField.Size()
}

f.First()                   // Go to first record
f.Last()                    // Go to last record
f.Next()                    // Next record
f.Previous()                // Previous record
f.Skip(10)                  // Skip multiple records
f.Goto(42)                  // Go to specific record

pos := f.Position()         // Current record number (1-indexed)
isEOF := f.EOF()           // At end of file
isBOF := f.BOF()           // At beginning of file

field := f.FieldByName("SOME_FIELD")

// Type-safe conversion methods
stringVal, err := field.AsString()   // Convert to string
intVal, err := field.AsInt()         // Convert to integer  
floatVal, err := field.AsFloat()     // Convert to float64
boolVal, err := field.AsBool()       // Convert to boolean
timeVal, err := field.AsTime()       // Convert to time.Time

// Native value access
nativeVal, err := field.Value()      // Get in native type
isNull, err := field.IsNull()        // Check for null

deleted := f.Deleted()      // Check if record is deleted
err := f.Delete()           // Mark record for deletion (soft delete)
err := f.Recall()           // Undelete record

// Access the indexes collection (lazy loaded)
indexes := f.Indexes()

// List all available indexes
indexList := indexes.List()
fmt.Printf("Available indexes: %d\n", len(indexList))
for _, index := range indexList {
    fmt.Printf("  Index: %s, Tags: %d\n", index.Name(), index.TagCount())
}

// List all available tags from all indexes
tags := indexes.Tags()
fmt.Printf("Available tags: %d\n", len(tags))
for _, tag := range tags {
    fmt.Printf("  Tag: %s, Expression: %s, KeyLen: %d\n", 
        tag.Name(), tag.Expression(), tag.KeyLength())
}

// Select a tag for navigation
nameTag := indexes.TagByName("NAME_IDX")
if nameTag != nil {
    err := indexes.SelectTag(nameTag)
    if err == nil {
        // Navigation now follows index order
        f.First()  // First in index order
        f.Next()   // Next in index order
    }
}

// Return to physical record order
indexes.SelectTag(nil)

// Get currently selected tag
selectedTag := indexes.SelectedTag()
if selectedTag != nil {
    fmt.Printf("Using tag: %s\n", selectedTag.Name())
}

// Get a tag for seeking
indexes := f.Indexes()
nameTag := indexes.TagByName("NAME_IDX")
if nameTag == nil {
    log.Fatal("NAME_IDX tag not found")
}

// Seek for specific values
result, err := nameTag.SeekString("Smith")
if err != nil {
    log.Printf("Seek failed: %v", err)
} else {
    switch result {
    case foxi.SeekSuccess:
        fmt.Println("Found exact match")
        // Record is now positioned at the matching entry
        nameField := f.FieldByName("NAME")
        name, _ := nameField.AsString()
        fmt.Printf("Found: %s at record %d\n", name, f.Position())
    case foxi.SeekAfter:
        fmt.Println("Positioned after where record would be")
    case foxi.SeekEOF:
        fmt.Println("Value would be after last record")
    }
}

// Seek with different data types
result, err = nameTag.Seek("Smith")        // Generic seek
result, err = nameTag.SeekInt(12345)       // Integer seek
result, err = nameTag.SeekDouble(50000.0)  // Float64 seek

// Tag-specific navigation
if result == foxi.SeekSuccess {
    err = nameTag.Next()     // Next in tag order
    err = nameTag.Previous() // Previous in tag order
    
    key := nameTag.CurrentKey()     // Current index key value
    recNo := nameTag.RecordNumber() // Current record number
    pos := nameTag.Position()       // Position as percentage (0.0-1.0)
}

f := foxi.NewFoxi()
f.MustOpen("customers.dbf")  // Panics if file doesn't exist
defer f.Close()

// Navigation Must variants
f.MustFirst()          // Panic instead of error
f.MustNext()           // Panic instead of error
f.MustGoto(10)         // Panic instead of error

// Field Must variants
nameField := f.FieldByName("NAME")
name := nameField.MustAsString()   // Panic instead of (value, error)
age := nameField.MustAsInt()       // Panic instead of (value, error)
null := nameField.MustIsNull()     // Panic instead of (bool, error)

// Index Must variants
indexes := f.Indexes()
indexes.MustLoad()                 // Panic instead of error
nameTag := indexes.TagByName("NAME_IDX")
if nameTag != nil {
    indexes.MustSelectTag(nameTag) // Panic instead of error
    result := nameTag.MustSeekString("Smith") // Panic instead of (SeekResult, error)
    nameTag.MustFirst()            // Panic instead of error
}

// Check if current record is deleted
f.First()
if f.Deleted() {
    fmt.Println("Current record is marked for deletion")
}

// Mark record for deletion (soft delete)
err := f.Delete()
if err != nil {
    log.Printf("Failed to delete record: %v", err)
}

// Undelete (recall) a record
err = f.Recall()
if err != nil {
    log.Printf("Failed to recall record: %v", err)
}

// Additional deleted record operations would be available
// in future versions of foxi

f := foxi.NewFoxi()

// Always check errors
err := f.Open("data.dbf")
if err != nil {
    log.Fatalf("Failed to open: %v", err)
}

// Handle navigation errors
err = f.Goto(999999)
if err != nil {
    log.Printf("Invalid record: %v", err)
}

// Field conversion errors
field := f.FieldByName("NUMERIC_FIELD")
value, err := field.AsInt()
if err != nil {
    log.Printf("Conversion failed: %v", err)
}

import "github.com/mkfoss/foxi/pkg/gocore"

// Direct gomkfdbf usage
cb := &gocore.Code4{}
data := gocore.D4Open(cb, "data.dbf")
defer gocore.D4Close(data)

// Navigate and read fields
gocore.D4Top(data)
field := gocore.D4Field(data, "NAME")
value := gocore.F4Str(field)

import "github.com/mkfoss/foxi/pkg/cgocore"

// Direct C library usage
// Note: This is a low-level interface requiring C knowledge