Swift: Swift Extensions and Access Control

func timeAgo(from date: Date) -> String {
    let seconds = Date().timeIntervalSince(date)
    if seconds < 60 { return "\(Int(seconds))s ago" }
    if seconds < 3600 { return "\(Int(seconds / 60))m ago" }
    return "\(Int(seconds / 3600))h ago"
}
// Must pass the date as argument every time
print(timeAgo(from: someDate))

extension Date {
    func timeAgo() -> String {
        let seconds = Date().timeIntervalSince(self)
        if seconds < 60 { return "\(Int(seconds))s ago" }
        if seconds < 3600 { return "\(Int(seconds / 60))m ago" }
        return "\(Int(seconds / 3600))h ago"
    }
}
// Looks like a built-in Date method
print(someDate.timeAgo())

// ============================================
// Adding practical extensions to String
// ============================================
extension String {
    // Computed property -- check if this is a valid email
    var isValidEmail: Bool {
        return contains("@") && contains(".")
    }
    // Method -- truncate to first N characters
    func prefix(_ maxLength: Int) -> String {
        guard count > maxLength else { return self }
        return String(self.prefix(maxLength)) + "..."
    }
    // Method -- reverse the string
    func reversed() -> String {
        return String(self.reversed())
    }
}
let email = "alice@example.com"
print("\(email) is valid: \(email.isValidEmail)")
let longText = "This is a very long string that needs truncation"
print(longText.prefix(20))
print("Hello".reversed())

// ============================================
// Conforming to protocols via extensions
// ============================================
// 1. Define the base type
struct User {
    let id: Int
    let name: String
    let email: String
}
// 2. Conform to Hashable via extension (for Set and Dictionary keys)
extension User: Hashable {
    func hash(into hasher: inout Hasher) {
        hasher.combine(id)
    }
}
// 3. Conform to Equatable via extension
extension User: Equatable {
    static func == (lhs: User, rhs: User) -> Bool {
        return lhs.id == rhs.id
    }
}
// 4. Usage
let users: Set<User> = [
    User(id: 1, name: "Alice", email: "alice@example.com"),
    User(id: 1, name: "Alice", email: "alice@example.com"),  // Duplicate -- deduplicated
    User(id: 2, name: "Bob", email: "bob@example.com")
]
print("Users count: \(users.count)")  // 2

// ============================================
// Using the five access levels
// ============================================
// Public class available to all modules
public class BankAccount {
    // Publicly readable, privately writable
    public private(set) var balance: Double
    // Private field -- only accessible within this class
    private var accountNumber: String
    private var transactionHistory: [String] = []
    // Accessible within this file -- for logging
    fileprivate var lastTransactionDate: Date?
    // Accessible within this module -- for internal auditing
    internal var branchCode: String
    public init(accountNumber: String, balance: Double, branchCode: String) {
        self.accountNumber = accountNumber
        self.balance = balance
        self.branchCode = branchCode
    }
    public func deposit(amount: Double) {
        balance += amount
        transactionHistory.append("Deposit: \(amount)")
        lastTransactionDate = Date()
    }
    // Private helper method
    private func log(_ message: String) {
        print("[Private] \(message)")
    }
}
let account = BankAccount(accountNumber: "123-456", balance: 1000, branchCode: "BR-001")
print("Balance: \(account.balance)")    // public getter is readable
// account.balance = 2000               // Compile error! public private(set) prevents external writes
// print(account.accountNumber)         // Compile error! private property
// print(account.lastTransactionDate)   // Compile error! fileprivate, inaccessible from another file
print("Branch: \(account.branchCode)")  // internal, accessible within the same module

// ============================================
// Visibility of private in extensions
// ============================================
struct UserAccount {
    private var token: String = "secret-token"
    let name: String
    func getToken() -> String {
        return token
    }
}
// Extensions in the same file can access private members
extension UserAccount {
    func resetToken() {
        token = "new-token"  // Accessible! Same file
    }
}
var account = UserAccount(name: "Alice")
print(account.getToken())
account.resetToken()
print(account.getToken())

// Core data definition
struct Product {
    let id: Int
    let name: String
    let price: Double
}
// MARK: - Equatable Conformance
extension Product: Equatable {
    static func == (lhs: Product, rhs: Product) -> Bool {
        return lhs.id == rhs.id
    }
}
// MARK: - Codable Conformance
extension Product: Codable { }
// MARK: - Utility Methods
extension Product {
    func formattedPrice() -> String {
        return "$\(String(format: "%.2f", price))"
    }
    var priceWithTax: Double {
        return price * 1.08
    }
}

// ============================================
// Adding nested types and convenience initializers via extensions
// ============================================
// Base type
struct Book {
    let title: String
    let author: String
    let year: Int
}
// Extension: add nested types and convenience initializers
extension Book {
    // Nested enum -- genres
    enum Genre: String {
        case fiction = "Fiction"
        case nonfiction = "Non-fiction"
        case science = "Science"
        case history = "History"
    }
    // Nested struct -- reading stats
    struct ReadingStats {
        var pagesRead: Int
        var totalPages: Int
        var progress: Double {
            totalPages > 0 ? Double(pagesRead) / Double(totalPages) * 100 : 0
        }
    }
    // Convenience initializer -- create from a JSON dictionary
    init?(from dict: [String: Any]) {
        guard let title = dict["title"] as? String,
              let author = dict["author"] as? String,
              let year = dict["year"] as? Int else {
            return nil
        }
        self.init(title: title, author: author, year: year)
    }
}
// Usage
let book1 = Book(title: "Swift Programming", author: "Apple", year: 2024)
let genre = Book.Genre.science
print("\(book1.title) - Genre: \(genre.rawValue)")
let stats = Book.ReadingStats(pagesRead: 120, totalPages: 350)
print("Reading progress: \(String(format: "%.1f", stats.progress))%")
// Create from dictionary
let dict = ["title": "Advanced Swift", "author": "Alice", "year": 2025] as [String: Any]
if let book2 = Book(from: dict) {
    print("Created from dictionary: \(book2.title) (\(book2.author), \(book2.year))")
}

// ============================================
// Full example: User management system
// Features: comprehensive use of extension + access control
// ============================================
import Foundation
// 1. Core user type
public class User {
    public let id: Int
    public let name: String
    public let email: String
    // Publicly readable, internally writable
    public private(set) var score: Int = 0
    public private(set) var isActive: Bool = true
    // Accessible within the module
    internal var lastLogin: Date?
    // Private
    private var loginHistory: [Date] = []
    public init(id: Int, name: String, email: String) {
        self.id = id
        self.name = name
        self.email = email
    }
    public func login() {
        let now = Date()
        lastLogin = now
        loginHistory.append(now)
        isActive = true
    }
    public func addScore(_ points: Int) {
        // Internal validation
        guard points > 0 else { return }
        score += points
    }
}
// MARK: - Description Extension
extension User {
    public func description() -> String {
        return "User(\(id): \(name), score: \(score), active: \(isActive))"
    }
    // Determine based on last login time
    public var isOnline: Bool {
        guard let last = lastLogin else { return false }
        return Date().timeIntervalSince(last) < 300
    }
}
// MARK: - Activity Log Extension
extension User {
    // fileprivate -- accessible only within this file
    fileprivate func generateActivityReport() -> String {
        return """
        User Report - \(name)
        =================
        Score: \(score)
        Active: \(isActive)
        Last Login: \(lastLogin?.description ?? "Never")
        """
    }
    public func printReport() {
        print(generateActivityReport())
    }
}
// 3. Usage example
let user = User(id: 1, name: "Alice", email: "alice@example.com")
user.login()
user.addScore(50)
user.addScore(30)
print(user.description())
print("Online: \(user.isOnline)")
user.printReport()
// user.score = 100        // Compile error -- public private(set)
// user.loginHistory        // Compile error -- private