func main() {
    // Recommended to call at the beginning of the program
    ziva.AutoConfigure()

    // Your application code
    queue := ziva.NewQueue("Application Name")
}

func init() {
    // For CI pipelines or scripted runs we don't need the pause
    ziva.DisableCompletionDelay()
}

if ziva.Is64Bit() {
    // Use algorithms for 64-bit systems
    fmt.Println("64-bit architecture")
} else {
    // Optimizations for 32-bit systems
    fmt.Println("32-bit architecture")
}

// Create a separator of 50 "-" characters
separator := ziva.RepeatEfficient("-", 50)
fmt.Println(separator)

// Indentation for formatting
indent := ziva.RepeatEfficient(" ", 4)

items := []string{"apple", "banana", "cherry"}
result := ziva.JoinEfficient(items, ", ")
// Result: "apple, banana, cherry"

message := ziva.FastConcat(
    "User ", username,
    " performed ", action,
    " at ", timestamp,
)

text := "  Too    many\t\tspaces\n\nand\nlines  "
clean := ziva.CleanWhitespaceEfficient(text)
// Result: "Too many spaces and lines"

import "github.com/charmbracelet/lipgloss"

// Red errors with yellow statuses
ziva.SetErrorColor(
    lipgloss.Color("#FF0000"), // red for error text
    lipgloss.Color("#FFFF00"), // yellow for statuses
)

// After experimenting with colors
ziva.ResetErrorColors()

// Make the exit item look like a regular menu row
ziva.SetExitMenuItemStyle(ziva.MenuItemDefaultStyle())

// Or keep the highlight but adjust the color
altExit := ziva.MenuActionDefaultStyle().Foreground(lipgloss.Color("#FFB000"))
ziva.SetExitMenuItemStyle(altExit)

// Turn the "Back" item into a neutral entry
ziva.SetBackMenuItemStyle(ziva.MenuItemDefaultStyle())

// Restore the highlight later
ziva.ResetBackMenuItemStyle()

ziva.ResetExitMenuItemStyle()

ziva.ResetBackMenuItemStyle()

// Reuse the default highlight for a custom shortcut
task.WithSelectAll("Enable all", "Disable all", ziva.MenuActionDefaultStyle())

// Align a special entry with standard items
task.WithSelectAll("Enable all", "Disable all", ziva.MenuItemDefaultStyle())

// For routers, IoT devices
ziva.EnableEmbeddedMode()

// For terminals without Unicode support
ziva.EnableASCIIMode()

if ziva.IsEmbeddedColorMode() {
    fmt.Println("Running in embedded system mode")
}

// Password minimum 8 characters
passwordValidator := ziva.NewPasswordValidator(8)

input := ziva.NewInputTask("Password", "Enter password:").
    WithInputType(ziva.InputTypePassword).
    WithValidator(passwordValidator)

emailValidator := ziva.NewEmailValidator()

email := ziva.NewInputTask("Email", "Enter email:").
    WithInputType(ziva.InputTypeEmail).
    WithValidator(emailValidator)

// IPv4 only
ipv4Validator := ziva.NewIPValidator(true, false)

// IPv6 only
ipv6Validator := ziva.NewIPValidator(false, true)

// Any IP
anyIPValidator := ziva.NewIPValidator(true, true)

ipv4 := ziva.NewIPv4Validator()
ipv6 := ziva.NewIPv6Validator()

domainValidator := ziva.NewDomainValidator()

domain := ziva.NewInputTask("Domain", "Enter domain:").
    WithValidator(domainValidator)

// 3 to 50 characters
textValidator := ziva.NewTextValidator(3, 50)

// Minimum only (no maximum limit)
minValidator := ziva.NewTextValidator(5, 0)

// Maximum only (no minimum limit)
maxValidator := ziva.NewTextValidator(0, 100)

// For frequently repeated strings in UI
label1 := ziva.InternString("Done")
label2 := ziva.InternString("Done") // References same object

size, capacity := ziva.GetCacheStats()
fmt.Printf("Cache: %d/%d strings\n", size, capacity)

// Periodic cleanup in long-running applications
ziva.ClearInternCache()

screenWidth := 120
layoutWidth := ziva.CalculateLayoutWidth(screenWidth)

// Use in custom UI
queue := ziva.NewQueue("Application")
// layout will be optimized for calculated width

func setupForEmbedded() {
    // Auto-configuration for optimization
    ziva.AutoConfigure()

    // Embedded system mode
    ziva.EnableEmbeddedMode()

    // For very old terminals
    if needASCII {
        ziva.EnableASCIIMode()
    }

    // Memory monitoring
    size, capacity := ziva.GetCacheStats()
    if size > capacity*0.8 {
        ziva.ClearInternCache()
    }
}

func createRegistrationForm() {
    queue := ziva.NewQueue("Registration")

    // Email with validation
    email := ziva.NewInputTask("Email", "Your email:").
        WithValidator(ziva.NewEmailValidator())

    // Password with security requirements
    password := ziva.NewInputTask("Password", "Password (min. 8 chars):").
        WithInputType(ziva.InputTypePassword).
        WithValidator(ziva.NewPasswordValidator(8))

    // Username with constraints
    username := ziva.NewInputTask("Username", "Username:").
        WithValidator(ziva.NewTextValidator(3, 20))

    queue.AddTasks(email, password, username)
}

func processLargeDataset(items []string) string {
    // Use efficient functions for string operations
    var results []string

    for _, item := range items {
        // Data cleaning
        cleaned := ziva.CleanWhitespaceEfficient(item)

        // Interning for memory efficiency
        interned := ziva.InternString(cleaned)

        results = append(results, interned)
    }

    // Efficient result joining
    return ziva.JoinEfficient(results, "\n")
}