package main

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

func main() {
    // Open a DBF file
    v := &vulpo.Vulpo{}
    err := v.Open("customers.dbf")
    if err != nil {
        log.Fatal(err)
    }
    defer v.Close()
    
    // Get database information
    header := v.Header()
    fmt.Printf("Records: %d, Last Updated: %s\n", 
        header.RecordCount(), header.LastUpdated().Format("2006-01-02"))
    
    // List all fields
    fmt.Println("Fields:")
    for i := 0; i < v.FieldCount(); i++ {
        field := v.Field(i)
        fmt.Printf("  %s (%s) - width:%d\n", 
            field.Name(), field.Type().String(), field.Size())
    }
    
    // Navigate through records
    v.First(0)
    for !v.EOF() {
        // Read field values using the new Field API
        nameField := v.FieldByName("NAME")
        name, _ := nameField.AsString()
        
        ageField := v.FieldByName("AGE")
        age, _ := ageField.AsInt()
        
        fmt.Printf("Record %d: %s, Age: %d\n", v.Position(), name, age)
        
        v.Next()
    }
}

// Open a database
v := &vulpo.Vulpo{}
err := v.Open("data.dbf")
if err != nil {
    return fmt.Errorf("failed to open database: %w", err)
}
defer v.Close()  // Always close when done

// Check if database is open
if v.Active() {
    fmt.Println("Database is open and ready")
}

header := v.Header()
fmt.Printf("Database Information:\n")
fmt.Printf("  Total Records: %d\n", header.RecordCount())
fmt.Printf("  Last Updated: %s\n", header.LastUpdated().Format("2006-01-02"))
fmt.Printf("  Has Index: %t\n", header.HasIndex())
fmt.Printf("  Codepage: %d\n", int(header.Codepage()))

// Separate objects for definition and reading
fieldDef := v.FieldByName("NAME")         // Get definition
fieldReader := v.FieldReader("NAME")     // Create reader
value, _ := fieldReader.AsString()       // Read value
fieldType := fieldDef.Type()             // Get type from definition

// Single object for both definition and reading
field := v.FieldByName("NAME")           // Get field with both capabilities
value, _ := field.AsString()             // Read value
fieldType := field.Type()                // Get type from same object

// Get field count
fieldCount := v.FieldCount()
fmt.Printf("Database has %d fields\n", fieldCount)

// Access fields by index
for i := 0; i < v.FieldCount(); i++ {
    field := v.Field(i)
    fmt.Printf("Field %d: %s (%s) - Size:%d, Decimals:%d\n",
        i, field.Name(), field.Type().String(), field.Size(), field.Decimals())
}

// Access field by name (case-insensitive)
field := v.FieldByName("CUSTOMER_NAME")
if field != nil {
    fmt.Printf("Found field: %s\n", field.Name())
}

// Position at a record first
v.First(0)

// Access fields directly (no need to create separate readers)
nameField := v.FieldByName("NAME")
ageField := v.FieldByName("AGE")
salaryField := v.FieldByName("SALARY")
activeField := v.FieldByName("ACTIVE")
birthDateField := v.FieldByName("BIRTH_DATE")

// Read values in different types
name, err := nameField.AsString()
age, err := ageField.AsInt()
salary, err := salaryField.AsFloat()
active, err := activeField.AsBool()
birthDate, err := birthDateField.AsTime()

fmt.Printf("Name: %s, Age: %d, Salary: %.2f, Active: %t, Born: %s\n",
    name, age, salary, active, birthDate.Format("2006-01-02"))

// Check for null values
if nameField.IsNull() {
    fmt.Println("Name field is null")
}

// Access field metadata
fmt.Printf("Name field: type=%s, size=%d\n", nameField.Type().String(), nameField.Size())

// Move to specific positions
err := v.First(0)    // Go to first record
err = v.Last(0)      // Go to last record
err = v.Goto(15)     // Go to record 15 (1-indexed)

// Sequential navigation
err = v.Next()       // Next record
err = v.Previous()   // Previous record
err = v.Skip(10)     // Skip 10 records forward
err = v.Skip(-5)     // Skip 5 records backward

// Check position and boundaries
pos := v.Position()  // Current record number (1-indexed)
if v.EOF() {
    fmt.Println("At end of file")
}
if v.BOF() {
    fmt.Println("At beginning of file") 
}

// List available indexes
tags := v.ListTags()
fmt.Printf("Available indexes: %d\n", len(tags))
for _, tag := range tags {
    fmt.Printf("  %s\n", tag.Name())
}

// Select an index for navigation
nameTag := v.TagByName("NAME_IDX")
if nameTag != nil {
    v.SelectTag(nameTag)
    
    // Now navigation follows name alphabetical order
    v.First(0)  // First alphabetically
    v.Next()    // Next alphabetically
}

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

// Check what index is currently selected
selectedTag := v.SelectedTag()
if selectedTag != nil {
    fmt.Printf("Using index: %s\n", selectedTag.Name())
} else {
    fmt.Println("Using physical record order")
}

// Get the default index
defaultTag := v.DefaultTag()
if defaultTag != nil {
    fmt.Printf("Default index: %s\n", defaultTag.Name())
}

// Select an index first
nameTag := v.TagByName("NAME_IDX")
v.SelectTag(nameTag)

// Seek for specific values
result, err := v.Seek("Smith")
if err != nil {
    log.Printf("Seek failed: %v", err)
} else {
    switch result {
    case vulpo.SeekSuccess:
        fmt.Println("Found exact match")
    case vulpo.SeekAfter:
        fmt.Println("Positioned after where record would be")
    case vulpo.SeekEOF:
        fmt.Println("Value would be after last record")
    }
}

// Continue seeking for more matches
for {
    result, err := v.SeekNext("Smith")
    if result != vulpo.SeekSuccess {
        break
    }
    
    // Process matching record
    nameReader := v.FieldReader("NAME")
    name, _ := nameReader.AsString()
    fmt.Printf("Found: %s\n", name)
}

// Seek with numeric values
salaryTag := v.TagByName("SALARY_IDX")
v.SelectTag(salaryTag)
result, err = v.SeekDouble(50000.0)  // More efficient for numbers

// Simple field comparisons
results, err := v.SearchByExpression("AGE > 30", nil)
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Found %d records with age > 30\n", len(results.Matches))
for _, match := range results.Matches {
    nameReader := match.FieldReaders["NAME"]
    ageReader := match.FieldReaders["AGE"]
    
    name, _ := nameReader.AsString()
    age, _ := ageReader.AsInt()
    
    fmt.Printf("Record %d: %s, Age: %d\n", match.RecordNumber, name, age)
}

// Complex expressions with functions
results, err = v.SearchByExpression(
    "YEAR(BIRTH_DATE) = 1990 .AND. SUBSTR(NAME, 1, 1) = 'J'", 
    &vulpo.ExprSearchOptions{MaxResults: 10})

// String functions
results, err = v.SearchByExpression("UPPER(LEFT(NAME, 3)) = 'SMI'", nil)

// Date functions  
results, err = v.SearchByExpression("MONTH(HIRE_DATE) = 12", nil)

// Logical operations
results, err = v.SearchByExpression(
    "(SALARY > 50000 .OR. BONUS > 10000) .AND. ACTIVE", nil)

// Count matching records
count, err := v.CountByExpression("ACTIVE .AND. SALARY > 40000")
fmt.Printf("Found %d active high-salary employees\n", count)

// Iterate through matches
err = v.ForEachExpressionMatch("YEAR(BIRTH_DATE) = 1985", 
    func(fieldReaders map[string]vulpo.FieldReader) error {
        nameReader := fieldReaders["NAME"]
        name, _ := nameReader.AsString()
        fmt.Printf("Born in 1985: %s\n", name)
        return nil  // Continue iteration
    })

// Basic regex search
results, err := v.RegexSearch("NAME", "^Smith", &vulpo.RegexSearchOptions{
    CaseInsensitive: true,
    MaxResults: 50,
})

if err != nil {
    log.Fatal(err)
}

for _, match := range results.Matches {
    fmt.Printf("Record %d: %s (matches: %v)\n", 
        match.RecordNumber, match.FieldValue, match.Matches)
}

// Count regex matches
count, err := v.RegexCount("EMAIL", "@gmail\\.com$", nil)
fmt.Printf("Found %d Gmail addresses\n", count)

// Check if any records match
exists, err := v.RegexExists("PHONE", "\\(555\\)", nil)
if exists {
    fmt.Println("Found records with 555 area code")
}

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

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

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

// Physical removal (permanent)
err = v.Pack()  // WARNING: This is destructive!
if err != nil {
    log.Printf("Failed to pack database: %v", err)
}
// After pack, must reposition
v.First(0)

// Count deleted records
deletedCount, err := v.CountDeleted()
activeCount, err := v.CountActive()

fmt.Printf("Records: %d deleted, %d active\n", deletedCount, activeCount)

// List all deleted records
deletedRecords, err := v.ListDeletedRecords()
fmt.Printf("Deleted record numbers: ")
for _, record := range deletedRecords {
    fmt.Printf("%d ", record.RecordNumber)
}
fmt.Println()

// Process each deleted record
err = v.ForEachDeletedRecord(func(recordNumber int) error {
    fmt.Printf("Processing deleted record %d\n", recordNumber)
    return nil
})

// Batch recall all deleted records
recalledCount, err := v.RecallAllDeleted()
fmt.Printf("Recalled %d records\n", recalledCount)

// Create a compiled expression filter
filter, err := v.NewExprFilter("AGE >= 18 .AND. ACTIVE")
if err != nil {
    log.Fatal(err)
}
defer filter.Free()  // Always free resources

// Use filter on different records
v.First(0)
for !v.EOF() {
    matches, err := filter.Evaluate()
    if err != nil {
        log.Fatal(err)
    }
    
    if matches {
        fmt.Printf("Record %d matches criteria\n", v.Position())
    }
    
    v.Next()
}

// Get different result types from expressions
stringResult, err := filter.EvaluateAsString()
numericResult, err := filter.EvaluateAsDouble()

v.First(0)

// Get field reader
reader := v.FieldReader("BIRTH_DATE")
if reader == nil {
    log.Fatal("Field not found")
}

// Multiple conversion options
dateValue, err := reader.AsTime()       // as time.Time
stringValue, err := reader.AsString()   // as string
intValue, err := reader.AsInt()         // as int (if convertible)

// Check for null values
if isNull, _ := reader.IsNull(); isNull {
    fmt.Println("Field is null")
}

// Get field definition
fieldDef := reader.FieldDef()
fmt.Printf("Field: %s, Type: %s, Size: %d\n", 
    fieldDef.Name(), fieldDef.Type().String(), fieldDef.Size())

type Vulpo struct {
    // private fields
}

type Header struct {
    // Contains metadata about the DBF file
}

type FieldDef struct {
    // Field metadata
}

package main

import (
    "fmt"
    "log"
    "time"
    
    "github.com/mkfoss/vulpo"
)

func main() {
    // Open database - field readers are created automatically
    v := &vulpo.Vulpo{}
    err := v.Open("employees.dbf")
    if err != nil {
        log.Fatal(err)
    }
    defer v.Close()
    
    // Display database info
    header := v.Header()
    fmt.Printf("Employee Database\n")
    fmt.Printf("Total Records: %d\n", header.RecordCount())
    fmt.Printf("Last Updated: %s\n", header.LastUpdated().Format("2006-01-02"))
    
    // Show field structure using unified Field API
    fmt.Printf("\nField Structure:\n")
    for i := 0; i < v.FieldCount(); i++ {
        field := v.Field(i)  // Gets field with both definition and reading capabilities
        fmt.Printf("  %-15s %-10s %3d,%d\n", 
            field.Name(), field.Type().String(), field.Size(), field.Decimals())
    }
    
    // Find high-salary employees
    fmt.Printf("\nHigh Salary Employees (>$75,000):\n")
    results, err := v.SearchByExpression("SALARY > 75000 .AND. .NOT. DELETED()", 
        &vulpo.ExprSearchOptions{MaxResults: 10})
    if err != nil {
        log.Fatal(err)
    }
    
    for _, match := range results.Matches {
        nameField := match.FieldReaders["NAME"]
        salaryField := match.FieldReaders["SALARY"]
        deptField := match.FieldReaders["DEPARTMENT"]
        
        name, _ := nameField.AsString()
        salary, _ := salaryField.AsFloat()
        dept, _ := deptField.AsString()
        
        fmt.Printf("  %-20s $%8.2f  %s\n", name, salary, dept)
    }
    
    // Department summary using expressions
    fmt.Printf("\nDepartment Summary:\n")
    departments := []string{"SALES", "ENGINEERING", "MARKETING", "HR"}
    for _, dept := range departments {
        expression := fmt.Sprintf("TRIM(UPPER(DEPARTMENT)) = '%s' .AND. .NOT. DELETED()", dept)
        count, err := v.CountByExpression(expression)
        if err == nil {
            fmt.Printf("  %-15s: %d employees\n", dept, count)
        }
    }
    
    // Show employees hired in current year
    currentYear := time.Now().Year()
    fmt.Printf("\nEmployees Hired in %d:\n", currentYear)
    expression := fmt.Sprintf("YEAR(HIRE_DATE) = %d .AND. .NOT. DELETED()", currentYear)
    
    err = v.ForEachExpressionMatch(expression, func(fields map[string]vulpo.FieldReader) error {
        nameField := fields["NAME"]     // These are actually Field instances
        hireDateField := fields["HIRE_DATE"]
        
        name, _ := nameField.AsString()
        hireDate, _ := hireDateField.AsTime()
        
        fmt.Printf("  %-20s  %s\n", name, hireDate.Format("2006-01-02"))
        return nil
    })
    
    // Clean up deleted records if any
    deletedCount, _ := v.CountDeleted()
    if deletedCount > 0 {
        fmt.Printf("\nFound %d deleted records\n", deletedCount)
        
        // Show deleted record numbers
        deletedRecords, _ := v.ListDeletedRecords()
        fmt.Printf("Deleted record numbers: ")
        for _, record := range deletedRecords {
            fmt.Printf("%d ", record.RecordNumber)
        }
        fmt.Println()
        
        // Optionally pack database (remove deleted records permanently)
        // WARNING: This is destructive - make backups first!
        // err = v.Pack()
        // if err != nil {
        //     log.Printf("Pack failed: %v", err)
        // } else {
        //     fmt.Println("Database packed successfully")
        // }
    }
    
    fmt.Printf("\nDatabase processing complete\n")
}

func demonstrateIndexes(v *vulpo.Vulpo) {
    // List all available indexes
    tags := v.ListTags()
    fmt.Printf("Available indexes: %d\n", len(tags))
    for _, tag := range tags {
        fmt.Printf("  %s\n", tag.Name())
    }
    
    // Use name index for alphabetical processing
    nameTag := v.TagByName("NAME_IDX")
    if nameTag != nil {
        fmt.Println("\nProcessing records in alphabetical order:")
        v.SelectTag(nameTag)
        
        v.First(0)
        count := 0
        for !v.EOF() && count < 5 {
            nameReader := v.FieldReader("NAME")
            name, _ := nameReader.AsString()
            fmt.Printf("  %s\n", name)
            
            v.Next()
            count++
        }
        
        // Seek for specific names
        fmt.Println("\nSeeking for names starting with 'Smith':")
        result, err := v.Seek("Smith")
        if err == nil && result.IsPositioned() {
            for {
                nameReader := v.FieldReader("NAME")
                name, _ := nameReader.AsString()
                
                // Check if still matches prefix
                if len(name) < 5 || name[:5] != "Smith" {
                    break
                }
                
                fmt.Printf("  Found: %s\n", name)
                
                // Look for next match
                result, err := v.SeekNext("Smith")
                if result != vulpo.SeekSuccess || err != nil {
                    break
                }
            }
        }
    }
    
    // Return to physical record order
    v.SelectTag(nil)
    fmt.Println("\nReturned to physical record order")
}

// Always check for errors
err := v.Open("nonexistent.dbf")
if err != nil {
    log.Printf("Open failed: %v", err)
}

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

// Expression errors
_, err = v.SearchByExpression("INVALID_SYNTAX((", nil)
if err != nil {
    log.Printf("Expression parse error: %v", err)
}

// Old way - manual field reader creation
fieldReader := v.FieldReader("NAME")
value, err := fieldReader.AsString()

// Getting field definition separately
fieldDef := v.FieldByName("NAME")
fmt.Printf("Field type: %s\n", fieldDef.Type().String())

// New way - unified field access
field := v.FieldByName("NAME")
value, err := field.AsString()

// Field definition is included in the same object
fmt.Printf("Field type: %s\n", field.Type().String())