// Basic arithmetic
const math = {
  sum: { $add: [10, 20, 30] },                    // 60
  difference: { $subtract: [100, 25] },            // 75
  product: { $multiply: [5, 6] },                  // 30
  quotient: { $divide: [100, 4] },                 // 25
  absolute: { $abs: -42 },                         // 42
  roundUp: { $ceil: 4.2 },                         // 5
  roundDown: { $floor: 4.8 },                      // 4
  maximum: { $max: [10, 25, 15] },                 // 25
  minimum: { $min: [10, 25, 15] }                  // 10
};

// Advanced math
const advanced = {
  remainder: { $mod: { dividend: 17, divisor: 5 } },      // 2
  power: { $pow: { base: 2, exponent: 10 } },             // 1024
  squareRoot: { $sqrt: { value: 144 } },                  // 12
  truncated: { $trunc: 3.9 },                             // 3
  formatted: { $toFixed: { value: 3.14159, precision: 2 } }, // "3.14"
  rounded: { $round: { value: 3.14159, precision: 2 } }   // 3.14
};

// With fallback for errors
const safe = {
  safeSqrt: { $sqrt: { value: -16, fallback: 0 } }        // 0 (negative number)
};

// Basic string operations
const strings = {
  upper: { $toUpper: "hello world" },                     // "HELLO WORLD"
  lower: { $toLower: "HELLO WORLD" },                     // "hello world"
  joined: { $concat: ["Hello", " ", "World", "!"] },      // "Hello World!"
  substring: { $substr: { value: "Hello World", start: 6, length: 5 } }, // "World"
  sliced: { $slice: { input: "Hello", start: 1, end: 4 } }, // "ell"
  parts: { $split: { input: "a,b,c", delimiter: "," } },  // ["a", "b", "c"]
  length: { $size: "Hello" }                              // 5
};

// Advanced string manipulation
const advanced = {
  cleaned: { $trim: { input: "  hello  ", chars: [" "] } },              // "hello"
  leftTrim: { $ltrim: { input: "  hello", chars: [" "] } },             // "hello"
  rightTrim: { $rtrim: { input: "hello  ", chars: [" "] } },            // "hello"
  position: { $indexOf: { input: "hello world", substring: "world" } }, // 6
  replaceFirst: { $replaceOne: { input: "hello", search: "l", replacement: "L" } }, // "heLlo"
  replaceAll: { $replaceAll: { input: "hello", search: "l", replacement: "L" } }    // "heLLo"
};

// Pattern replacement
const patterns = {
  // Remove all non-digits
  digitsOnly: { 
    $regexReplace: { input: "ABC-123-XYZ", pattern: "\\D", replacement: "" } 
  },  // "123"
  
  // Normalize whitespace
  normalized: { 
    $regexReplace: { input: "hello    world", pattern: "\\s+", replacement: " " } 
  },  // "hello world"
  
  // Clean phone number
  cleanPhone: { 
    $replace: { 
      input: "(555) 123-4567", 
      searchValues: ["(", ")", " ", "-"], 
      replacement: "" 
    } 
  }  // "5551234567"
};

// Comparisons
const checks = {
  isEqual: { $eq: [5, 5] },                        // true
  notEqual: { $ne: [5, 3] },                       // true
  greaterThan: { $gt: [10, 5] },                   // true
  greaterOrEqual: { $gte: [5, 5] },                // true
  lessThan: { $lt: [3, 5] },                       // true
  lessOrEqual: { $lte: [5, 5] }                    // true
};

// Logical operators
const logic = {
  allTrue: { $and: [true, true, true] },           // true
  anyTrue: { $or: [false, true, false] },          // true
  inverted: { $not: false },                       // true
  noneTrue: { $none: [false, false, false] }       // true
};

// Membership
const membership = {
  inList: { $in: ["apple", ["apple", "banana"]] }, // true
  notInList: { $nin: ["grape", ["apple", "banana"]] } // true
};

// Validation
const validation = {
  hasField: { $exists: "$user.email" },            // true/false
  isNull: { $isNull: "$optionalField" },           // true/false
  isValidNumber: { $isNumber: "$age" },            // true/false
  isNotANumber: { $isNaN: "$invalidNumber" }       // true/false
};

// Pattern matching
const patterns = {
  isEmail: { 
    $regex: { 
      value: "$email", 
      pattern: "^[^@]+@[^@]+\\.[^@]+$" 
    } 
  }  // true/false
};

// If-then-else with $cond
const status = {
  age: 25,
  category: {
    $cond: {
      if: { $gte: ["$age", 18] },
      then: "Adult",
      else: "Minor"
    }
  }  // "Adult"
};

// Multi-branch with $switch
const tier = {
  score: 850,
  level: {
    $switch: {
      branches: [
        { case: { $gte: ["$score", 900] }, then: "Platinum" },
        { case: { $gte: ["$score", 800] }, then: "Gold" },
        { case: { $gte: ["$score", 700] }, then: "Silver" }
      ],
      default: "Bronze"
    }
  }  // "Gold"
};

// Null handling
const safe = {
  optionalName: null,
  displayName: { $coalesce: ["$optionalName", "$firstName", "Guest"] }, // Uses first non-null
  safeName: { $ifNull: ["$optionalName", "Unknown"] }                   // "Unknown"
};

// Multiple conditions
const validation = {
  checks: [
    { $gte: ["$age", 18] },
    { $eq: ["$status", "active"] },
    "$verified"
  ],
  allValid: { $every: { conditions: "$checks", then: true, else: false } },
  anyValid: { $some: { conditions: "$checks", then: true, else: false } }
};

// Number conversion
const numbers = {
  fromString: { $toNumber: "123.45" },             // 123.45
  fromBoolean: { $toNumber: true },                // 1
  invalid: { $toNumber: "abc" }                    // NaN
};

// String conversion
const strings = {
  fromNumber: { $toString: 123 },                  // "123"
  fromBoolean: { $toString: true },                // "true"
  fromNull: { $toString: null }                    // "null"
};

// Extract date components
const dateInfo = {
  date: "2025-03-15T10:00:00Z",
  dayOfWeek: { $dayOfWeek: { date: "$date" } },        // 6 (Saturday)
  dayOfMonth: { $dayOfMonth: { date: "$date" } },      // 15
  dayOfYear: { $dayOfYear: { date: "$date" } },        // 74
  isWeekend: { $isWeekend: { date: "$date" } }         // true
};

// Business day handling
const businessDay = {
  scheduledDate: "2025-03-01",  // Saturday
  holidays: ["2025-03-03"],     // Monday is holiday
  executionDate: {
    $dateShift: {
      date: "$scheduledDate",
      strategy: "rollForward",    // Options: rollForward, rollBackward, keep
      holidays: "$holidays",
      weekends: [6, 0]           // Saturday, Sunday
    }
  }
  // Result: "2025-03-04" (Tuesday - skips weekend and holiday)
};

// Date arithmetic
const futureDate = {
  today: "2025-01-01",
  nextWeek: { $addDays: { date: "$today", days: 7 } },      // "2025-01-08"
  lastMonth: { $addDays: { date: "$today", days: -30 } }    // "2024-12-02"
};

// Transform array elements with $map
const doubled = {
  numbers: [1, 2, 3, 4, 5],
  doubled: {
    $map: {
      input: "$numbers",
      expression: { $multiply: ["$current", 2] }
    }
  }
  // Result: [2, 4, 6, 8, 10]
};

// Filter array with conditions
const adults = {
  users: [
    { name: "Alice", age: 25 },
    { name: "Bob", age: 17 },
    { name: "Charlie", age: 30 }
  ],
  adults: {
    $filter: {
      input: "$users",
      condition: { $gte: ["$current.age", 18] }
    }
  }
  // Result: [{ name: "Alice", age: 25 }, { name: "Charlie", age: 30 }]
};

// Aggregate with $reduce
const sum = {
  values: [1, 2, 3, 4, 5],
  total: {
    $reduce: {
      input: "$values",
      initialValue: 0,
      expression: { $add: ["$accumulated", "$current"] }
    }
  }
  // Result: 15
};

// Context variables in array operators
// $current - current element
// $index - current index (0-based)
// $accumulated - accumulated value (in $reduce)

// Access specific elements
const scores = {
  all: [85, 92, 78, 95, 88],
  first: { $arrayFirst: { input: "$all" } },          // 85
  last: { $arrayLast: { input: "$all" } },            // 88
  third: { $arrayAt: { input: "$all", index: 2 } },   // 78
  secondLast: { $arrayAt: { input: "$all", index: -2 } }  // 95 (negative indexing)
};

// Aggregate numbers
const stats = {
  values: [10, 20, 30, 40, 50],
  total: { $sum: { values: "$values" } },             // 150
  average: { $avg: { values: "$values" } },           // 30
  count: { $size: "$values" }                         // 5
};

// With fallback for safety
const safe = {
  maybeArray: null,
  first: { 
    $arrayFirst: { 
      input: "$maybeArray", 
      fallback: "default" 
    } 
  }  // "default"
};

// Type identification
const types = {
  stringType: { $type: "hello" },                  // "string"
  numberType: { $type: 123 },                      // "number"
  arrayType: { $type: [1, 2, 3] },                 // "array"
  objectType: { $type: { a: 1 } },                 // "object"
  nullType: { $type: null },                       // "null"
  undefinedType: { $type: undefined }              // "undefined"
};

// Type validation
const checks = {
  checkArray: { $isArray: [1, 2, 3] },             // true
  checkString: { $isString: "hello" },             // true
  checkBoolean: { $isBoolean: true },              // true
  checkDate: { $isDate: "2025-01-01" }             // true
};

// Use in conditionals
const conditional = {
  value: [1, 2, 3],
  result: {
    $cond: {
      if: { $isArray: "$value" },
      then: { $size: "$value" },
      else: 0
    }
  }  // 3
};

// Array operators with fallback
const safe = {
  maybeArray: null,
  
  // Returns fallback if input is not an array
  first: { 
    $arrayFirst: { 
      input: "$maybeArray", 
      fallback: "no data" 
    } 
  },  // "no data"
  
  // Math operators with fallback
  safeSqrt: { 
    $sqrt: { 
      value: "$negativeNumber", 
      fallback: 0 
    } 
  },  // 0 (if negative)
  
  // Sum with fallback for non-numeric values
  total: { 
    $sum: { 
      values: ["$invalidData"], 
      fallback: 0 
    } 
  }  // 0
};

// Fallback can be:
// - Static value: fallback: 0
// - Path reference: fallback: "$defaultValue"
// - Expression: fallback: { $add: [1, 2] }