Swift: Deep Dive into Swift Properties

class UserProfile {
    var avatarUrl: String
    func displayAvatar() {
        // Downloads avatar from network every time
        downloadImage(from: avatarUrl) { image in
            // Display image
        }
    }
}

class UserProfile {
    var avatarUrl: String
    lazy var cachedAvatar: UIImage? = {
        // Executes only once — downloads on first access
        return downloadImage(from: avatarUrl)
    }()
}

// ============================================
// Basic stored property usage
// ============================================
struct User {
    let id: Int           // Constant stored property
    var name: String       // Variable stored property
    var email: String
}
var user = User(id: 1, name: "Alice", email: "alice@example.com")
user.name = "Alice Smith"  // Variable property can be modified
// user.id = 2             // Compile error! Constant property cannot be modified
print("\(user.name) (\(user.email))")

// ============================================
// Computed property — Celsius/Fahrenheit conversion
// ============================================
struct Temperature {
    var celsius: Double
    // Computed property — calculates fahrenheit from celsius
    var fahrenheit: Double {
        get {
            return celsius * 9 / 5 + 32
        }
        set(newFahrenheit) {
            celsius = (newFahrenheit - 32) * 5 / 9
        }
    }
}
var temp = Temperature(celsius: 25)
print("Celsius: \(temp.celsius)°C")
print("Fahrenheit: \(temp.fahrenheit)°F")
// Setting fahrenheit indirectly modifies celsius
temp.fahrenheit = 100
print("After setting to 100°F:")
print("Celsius: \(temp.celsius)°C")

// ============================================
// Property observers monitoring score changes
// ============================================
class Player {
    var name: String
    var score: Int = 0 {
        willSet {
            print("Score will change from \(score) to \(newValue)")
        }
        didSet {
            print("Score changed from \(oldValue) to \(score)")
            if score > 100 {
                print("Congrats \(name) on the high score!")
            }
        }
    }
    var level: Int {
        // Read-only computed property based on score
        switch score {
        case 0..<50: return 1
        case 50..<100: return 2
        default: return 3
        }
    }
    init(name: String) {
        self.name = name
    }
}
let player = Player(name: "Alice")
player.score = 60
print("Level: \(player.level)")
player.score = 120
print("Level: \(player.level)")

// ============================================
// lazy loading: Database configuration
// ============================================
class DatabaseManager {
    let configFile: String
    // Lazy — only initializes connection when a query is executed
    lazy var connection: String = {
        print("Establishing database connection (one-time only)...")
        // Simulate establishing a connection
        return "Connected to \(configFile)"
    }()
    init(configFile: String) {
        self.configFile = configFile
    }
    func query(_ sql: String) {
        print("Using connection: \(connection) executing query: \(sql)")
    }
}
let db = DatabaseManager(configFile: "app.db")
print("DatabaseManager created, connection not initialized")
db.query("SELECT * FROM users")
db.query("SELECT * FROM orders")
// Second access to connection does not re-initialize

// ============================================
// static type properties
// ============================================
struct AppConfig {
    static let appName = "MySwiftApp"
    static var version = "1.0"
    static var launchCount = 0
    static func incrementLaunch() {
        launchCount += 1
    }
}
// Access directly via type name, no instance needed
print(AppConfig.appName)
AppConfig.version = "1.1"
AppConfig.incrementLaunch()
AppConfig.incrementLaunch()
print("Version: \(AppConfig.version), Launches: \(AppConfig.launchCount)")

// ============================================
// Complete example: Profile management system
// Features: Stored/computed properties + observers + lazy + static
// ============================================
import Foundation
// 1. Global configuration (type properties)
struct Config {
    static let maxAvatarSizeMB = 5.0
    static var apiBaseURL = "https://api.example.com"
    static var userCount = 0
}
// 2. User profile
class UserProfile {
    // Stored properties
    let id: Int
    var name: String {
        didSet {
            print("Name updated: \(oldValue) -> \(name)")
        }
    }
    var avatarUrl: String
    // Computed property — generate initials from name
    var initials: String {
        name.split(separator: " ").compactMap { $0.first }.map { String($0) }.joined()
    }
    // Lazy — compute age description on first access
    lazy var ageDescription: String = {
        print("Computing age description for the first time...")
        return "\(name)'s profile"
    }()
    // Property observer
    var email: String {
        willSet {
            print("Updating email...")
        }
        didSet {
            print("Email updated to \(email)")
        }
    }
    init(id: Int, name: String, email: String, avatarUrl: String) {
        self.id = id
        self.name = name
        self.email = email
        self.avatarUrl = avatarUrl
        Config.userCount += 1
    }
    deinit {
        Config.userCount -= 1
    }
}
// 3. Usage
let profile = UserProfile(
    id: 1,
    name: "Alice Johnson",
    email: "alice@example.com",
    avatarUrl: "https://example.com/avatar.jpg"
)
print("Initials: \(profile.initials)")
print("Age: \(profile.ageDescription)")
print("Active users: \(Config.userCount)")
// Triggers observers
profile.email = "alice@newdomain.com"
profile.name = "Alice Smith"