Swift: صفوف Swift والاختياريات: دليل عملي لـ Tuple وOptional

// Simulated API response data
let jsonName: String? = nil    // Username is null
let jsonAge: Int? = 28
let jsonEmail: String? = nil   // Email is null
// Using it directly — won't compile
let displayName = "Name: " + jsonName  // Compilation error!

// Forced unwrap — runtime crash
let displayName = "Name: \(jsonName!)"  // ❌ fatal error

var userName = "Unknown"
var userAge = 0
var userEmail = "Not provided"
if let name = jsonName {
    userName = name
}
if let age = jsonAge {
    userAge = age
}
if let email = jsonEmail {
    userEmail = email
}
print("Name: \(userName), Age: \(userAge), Email: \(userEmail)")

// Unlabeled tuple
let httpStatus = (404, "Not Found")
print(httpStatus.0)  // 404
print(httpStatus.1)  // "Not Found"
// Labeled tuple (recommended)
let user = (name: "Alice", age: 28, isActive: true)
print(user.name)      // Alice
print(user.age)       // 28
print(user.isActive)  // true

let product = (id: 1001, name: "MacBook Pro", price: 1999.99)
// Method 1: By index
print(product.0)   // 1001
print(product.1)   // MacBook Pro
// Method 2: By label
print(product.id)    // 1001
print(product.name)  // MacBook Pro
// Method 3: Destructuring
let (id, name, price) = product
print("\(id): \(name) - $\(price)")

// ============================================
// Simulate API responses returning user and order data
// Demonstrates tuple creation, labels, and destructuring
// ============================================
// Simulate fetching a user profile summary
let userSummary = (id: 1001, name: "Alice Johnson", age: 28, country: "US")
print("User: \(userSummary.name) (ID: \(userSummary.id))")
print("Age: \(userSummary.age), Country: \(userSummary.country)")
// Simulate fetching order statistics
let orderStats = (totalOrders: 15, totalSpent: 3450.0, lastOrderDate: "2026-07-15")
// Destructure the tuple
let (orderCount, totalSpent, lastDate) = orderStats
print("Orders: \(orderCount), Total: $\(totalSpent), Last: \(lastDate)")
// Tuple as a function return value
func getCoordinates() -> (Double, Double) {
    return (40.7128, -74.0060)
}
let (lat, lng) = getCoordinates()
print("Location: \(lat), \(lng)")

var middleName: String? = nil     // Initially nil
var age: Int? = 28                // Has a value
var email: String? = "alice@example.com"  // Has a value
// Assign nil
middleName = "Marie"  // Now has a value
middleName = nil      // Back to no value
// Optional is fundamentally an enum
let name: Optional<String> = "Alice"  // Full syntax
let name2: String? = "Alice"          // Shorthand (recommended)

let notSet: Int? = nil    // Not set
let zero: Int = 0         // Value is 0 (not nil)
let empty: String? = ""   // Has a value, an empty string (not nil)
// Check for nil
if notSet == nil {
    print("Value is not set")
}

// ============================================
// Simulate querying user info from a database
// Demonstrates Optional declaration and nil checking
// ============================================
// Simulated query results (some fields may be empty)
var dbUserName: String? = "Alice Johnson"
var dbUserAge: Int? = 28
var dbUserEmail: String? = nil  // Email is null in database
var dbUserPhone: String? = nil  // Phone not provided
// Output each field using nil checks
print("=== User Profile ===")
print("Name: \(dbUserName ?? "Unknown")")
if dbUserAge != nil {
    print("Age: \(dbUserAge!)")  // Confirmed has value, safe to force-unwrap
} else {
    print("Age: Not provided")
}
if dbUserEmail == nil {
    print("Email: Not provided")
}
if dbUserPhone == nil {
    print("Phone: Not provided")
}

let optionalName: String? = "Alice"
if let name = optionalName {
    print("Hello, \(name)")  // name is String, not Optional
} else {
    print("Name is nil")
}
// Unwrap multiple optionals at once
let a: Int? = 10
let b: Int? = 20
if let x = a, let y = b {
    print("Sum: \(x + y)")  // 30
} else {
    print("One or both values are nil")
}
// Add conditions
if let x = a, x > 5 {
    print("\(x) is greater than 5")  // 10 > 5
}

func processUser(name: String?, age: Int?) {
    guard let validName = name else {
        print("Name is required")
        return
    }
    guard let validAge = age, validAge >= 18 else {
        print("Must be at least 18")
        return
    }
    print("Processing: \(validName), age \(validAge)")
}
processUser(name: "Alice", age: 28)  // Processing: Alice, age 28
processUser(name: nil, age: 20)      // Name is required
processUser(name: "Bob", age: 15)    // Must be at least 18

// ✅ Reasonable use case
let optionalNumber: Int? = 42
if optionalNumber != nil {
    // Already checked, safe to force-unwrap
    print("Number is \(optionalNumber!)")
}
// ❌ Dangerous: crashes if nil
let badNumber: Int? = nil
// print(badNumber!)  // fatal error

// ============================================
// Read app configuration, demonstrating three unwrapping methods
// ============================================
import Foundation
// Simulate reading a config file (some keys may be missing)
let configTimeout: Int? = 30
let configRetry: Int? = nil         // Missing retry config
let configAPIKey: String? = "abc-123-def"
let configEnv: String? = nil        // Missing environment config
// 1. if-let for safe access
if let timeout = configTimeout {
    print("Timeout: \(timeout) seconds")
}
// 2. guard-let for early exit
func validateConfig() {
    guard let apiKey = configAPIKey else {
        print("Error: API Key is missing")
        return
    }
    print("API Key: \(apiKey.prefix(3))...")
}
validateConfig()
// 3. Nil-coalescing operator provides defaults
let retryCount = configRetry ?? 3
let envName = configEnv ?? "development"
print("Retry: \(retryCount) times")
print("Environment: \(envName)")
// 4. if-let with combined conditions
if let timeout = configTimeout, timeout > 0 {
    print("Valid timeout: \(timeout)s")
} else {
    print("Invalid or missing timeout")
}

// ============================================
// User registration form validation
// Combines tuples for data bundling + Optional for safe unwrapping
// ============================================
import Foundation
// 1. Simulate form input (may be empty)
let inputName: String? = "Alice Johnson"
let inputEmail: String? = "alice@example.com"
let inputAge: String? = "28"
let inputPhone: String? = nil  // Phone is optional
// 2. Use tuple to return multiple validation results
func validateRegistration(name: String?, email: String?, age: String?) -> (isValid: Bool, message: String) {
    guard let name = name, name.count >= 2 else {
        return (false, "Name must be at least 2 characters")
    }
    guard let email = email, email.contains("@") else {
        return (false, "Invalid email address")
    }
    guard let ageStr = age, let ageInt = Int(ageStr), ageInt >= 18 else {
        return (false, "Must be at least 18 years old")
    }
    return (true, "Registration successful!")
}
// 3. Run validation
let result = validateRegistration(name: inputName, email: inputEmail, age: inputAge)
if result.isValid {
    print("Status: \(result.message)")
    // 4. Safely unwrap and use the data
    if let name = inputName, let email = inputEmail {
        let welcome = "Welcome \(name)! Confirmation sent to \(email)"
        print(welcome)
    }
    // 5. Nil-coalescing operator for optional info
    let phoneInfo = inputPhone ?? "Not provided"
    print("Phone: \(phoneInfo)")
} else {
    print("Error: \(result.message)")
}