// Optionals (like Dart's nullable types)
var name: String = "Ali"       // Non-optional
var nickname: String? = nil    // Optional
let length = nickname?.count ?? 0  // Optional chaining + nil coalescing
struct User: Codable { // Struct (value type — preferred over class for models)
    let id: Int
    let name: String
    let email: String
}
// Enum with associated values
enum Result<T> {
    case success(T)
    case failure(String)
}
// Async/await (Swift 5.5+)
func fetchUsers() async throws -> [User] {
    let (data, _) = try await URLSession.shared.data(from: url)
    return try JSONDecoder().decode([User].self, from: data)
}

struct UserCard: View {
    let user: User
    var onTap: () -> Void
    var body: some View {
        HStack(spacing: 12) {
            Image(systemName: "person.circle.fill")
                .font(.largeTitle)
                .foregroundColor(.blue)
            VStack(alignment: .leading) {
                Text(user.name)
                    .font(.headline)
                Text(user.email)
                    .font(.subheadline)
                    .foregroundColor(.secondary)
            }
            Spacer()
        }
        .padding()
        .background(Color(.systemBackground))\
        .shadow(radius: 4)
        .onTapGesture { onTap() }
    }
}

struct CounterView: View {
    @State private var count = 0

    var body: some View {
        VStack {
            Text("Count: \(count)")
                .font(.title)
            HStack {
                Button("−") { count -= 1 }
                    .padding().background(Color.red).foregroundColor(.white)
                    .cornerRadius(8)
                Button("+") { count += 1 }
                    .padding().background(Color.green).foregroundColor(.white)
                    .cornerRadius(8)
            }
        }
    }
}

// Observable pattern (like ChangeNotifier)
class UserStore: ObservableObject {
    @Published var users: [User] = []
    func load() async {
        users = try! await fetchUsers()
    }
}

class UserViewController: UIViewController {
    private let tableView = UITableView()
    private var users: [User] = []
    override func viewDidLoad() {
        super.viewDidLoad()
        title = "Users"
        view.addSubview(tableView)
        tableView.frame = view.bounds
        tableView.dataSource = self
        tableView.delegate = self
        loadUsers()
    }
    private func loadUsers() {
        Task {
            users = try await fetchUsers()
            tableView.reloadData()
        }
    }
}

extension UserViewController: UITableViewDataSource {
    func tableView(_ tableView: UITableView,
                   numberOfRowsInSection section: Int) -> Int {
        return users.count
    }
    func tableView(_ tableView: UITableView,
                   cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = tableView.dequeueReusableCell(withIdentifier: "cell",
                                                 for: indexPath)
        cell.textLabel?.text = users[indexPath.row].name
        return cell
    }
}

// Request permission
import AVFoundation

func requestCameraAccess() {
    AVCaptureDevice.requestAccess(for: .video) { granted in
        DispatchQueue.main.async {
            if granted {
                // Open camera
            } else {
                // Show denied message
            }
        }
    }
}

// Flutter side
const channel = MethodChannel('com.example/device');

Future<String> getDeviceModel() async {
  try {
    return await channel.invokeMethod<String>('getDeviceModel') ?? 'Unknown';
  } on PlatformException catch (e) {
    return 'Error: ${e.message}';
  }
}

// iOS side (AppDelegate.swift)
class AppDelegate: FlutterAppDelegate {
    override func application(_ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        let controller = window?.rootViewController as! FlutterViewController
        let channel = FlutterMethodChannel(
            name: "com.example/device",
            binaryMessenger: controller.binaryMessenger
        )
        channel.setMethodCallHandler { (call, result) in
            if call.method == "getDeviceModel" {
                let model = UIDevice.current.model
                result(model)
            } else {
                result(FlutterMethodNotImplemented)
            }
        }
        return super.application(application, didFinishLaunchingWithOptions: launchOptions)
    }
}