shopspring/decimal

import "github.com/shopspring/decimal"

// Create decimals (ALWAYS prefer NewFromString for exact values)
price, _ := decimal.NewFromString("19.99")
quantity := decimal.NewFromInt(3)

// Calculate (immutable - returns new values)
total := price.Mul(quantity)  // 59.97

// Compare (NEVER use == operator - won't work!)
if total.GreaterThan(decimal.NewFromInt(50)) {
    discount := total.Mul(decimal.NewFromString("0.10"))
    total = total.Sub(discount)
}

// Round and display
fmt.Println(total.StringFixed(2))  // "53.97"

// Calculate price with tax
price, _ := decimal.NewFromString("99.99")
taxRate, _ := decimal.NewFromString("0.08")  // 8% tax

// Calculate tax amount
tax := price.Mul(taxRate).Round(2)

// Calculate total
total := price.Add(tax)

fmt.Printf("Price: $%s\n", price.StringFixed(2))    // $99.99
fmt.Printf("Tax:   $%s\n", tax.StringFixed(2))      // $8.00
fmt.Printf("Total: $%s\n", total.StringFixed(2))    // $107.99

// Apply percentage discount
originalPrice, _ := decimal.NewFromString("200.00")
discountPercent := decimal.NewFromInt(15)  // 15% off
hundred := decimal.NewFromInt(100)

// Calculate discount amount
discountAmount := originalPrice.Mul(discountPercent).Div(hundred)

// Apply discount and round
finalPrice := originalPrice.Sub(discountAmount).Round(2)

fmt.Printf("Original: $%s\n", originalPrice.StringFixed(2))        // $200.00
fmt.Printf("Discount: $%s (15%%)\n", discountAmount.StringFixed(2)) // $30.00
fmt.Printf("Final:    $%s\n", finalPrice.StringFixed(2))           // $170.00

// Production-ready division function
func SafeDivide(numerator, denominator decimal.Decimal, places int32) (decimal.Decimal, error) {
    if denominator.IsZero() {
        return decimal.Zero, errors.New("division by zero")
    }
    return numerator.DivRound(denominator, places), nil
}

// Usage
average, err := SafeDivide(total, count, 2)
if err != nil {
    return fmt.Errorf("cannot calculate average: %w", err)
}

// Product with decimal fields
type Product struct {
    ID       int64               `db:"id"`
    Name     string              `db:"name"`
    Price    decimal.Decimal     `db:"price"`      // Required field
    Discount decimal.NullDecimal `db:"discount"`   // Optional field (can be NULL)
}

// Insert product
_, err := db.Exec(
    "INSERT INTO products (id, name, price, discount) VALUES (?, ?, ?, ?)",
    product.ID,
    product.Name,
    product.Price,
    product.Discount,  // NullDecimal handles NULL automatically
)

// Query product
var product Product
err := db.QueryRow(
    "SELECT id, name, price, discount FROM products WHERE id = ?",
    productID,
).Scan(&product.ID, &product.Name, &product.Price, &product.Discount)

// Check if discount is NULL
if product.Discount.Valid {
    finalPrice := product.Price.Sub(product.Discount.Decimal)
} else {
    finalPrice := product.Price
}

// API response structure
type OrderResponse struct {
    OrderID  int64               `json:"order_id"`
    Subtotal decimal.Decimal     `json:"subtotal"`    // Serializes as "19.99" (quoted)
    Tax      decimal.Decimal     `json:"tax"`
    Total    decimal.Decimal     `json:"total"`
    Discount decimal.NullDecimal `json:"discount,omitempty"` // null or omitted if not set
}

// Create response
order := OrderResponse{
    OrderID:  12345,
    Subtotal: decimal.NewFromString("89.97"),
    Tax:      decimal.NewFromString("7.20"),
    Total:    decimal.NewFromString("97.17"),
    Discount: decimal.NullDecimal{Valid: false}, // No discount
}

// Marshal to JSON (default: quoted strings for precision)
jsonData, err := json.Marshal(order)
// {"order_id":12345,"subtotal":"89.97","tax":"7.20","total":"97.17"}

// Unmarshal from JSON
var received OrderResponse
err = json.Unmarshal(jsonData, &received)

// Split amount among N recipients with remainder handling
func SplitAmount(total decimal.Decimal, recipients int) ([]decimal.Decimal, error) {
    if recipients <= 0 {
        return nil, errors.New("recipients must be positive")
    }

    recipientsDecimal := decimal.NewFromInt(int64(recipients))
    perPerson := total.DivRound(recipientsDecimal, 2)

    // Calculate remainder (due to rounding)
    distributed := perPerson.Mul(recipientsDecimal)
    remainder := total.Sub(distributed)

    // Create shares
    shares := make([]decimal.Decimal, recipients)
    for i := 0; i < recipients; i++ {
        shares[i] = perPerson
    }

    // Add remainder to first person (or distribute across recipients)
    if !remainder.IsZero() {
        shares[0] = shares[0].Add(remainder)
    }

    return shares, nil
}

// Usage: Split $100 among 3 people
shares, _ := SplitAmount(decimal.NewFromString("100.00"), 3)
// shares[0] = 33.34, shares[1] = 33.33, shares[2] = 33.33

// Immutable arbitrary-precision decimal number
// Internally: coefficient × 10^exponent
// Zero value is valid and equals 0
type Decimal struct { /* internal fields */ }

// Nullable decimal for database NULL and optional API fields
type NullDecimal struct {
    Decimal Decimal
    Valid   bool  // true if Decimal is valid (not NULL)
}

// Create NULL value
nullValue := decimal.NullDecimal{Valid: false}

// Create valid value
validValue := decimal.NullDecimal{
    Decimal: decimal.NewFromString("19.99"),
    Valid:   true,
}

// Check before using
if validValue.Valid {
    price := validValue.Decimal
}

// Package-level variables (NOT thread-safe - set once at startup)
var DivisionPrecision = 16                // Decimal places for Div() operation
var PowPrecisionNegativeExponent = 16     // Precision for Pow() with negative exponent
var MarshalJSONWithoutQuotes = false      // JSON: false="19.99" (recommended), true=19.99 (loses precision)
var ExpMaxIterations = 1000               // Max iterations for ExpHullAbrham method
var Zero = New(0, 1)                      // Reusable zero constant

// Example: Configure at startup
func init() {
    decimal.DivisionPrecision = 8      // Use 8 decimal places for division
    decimal.MarshalJSONWithoutQuotes = false  // Keep quoted (recommended)
}