import Foundation
import PlaygroundSupport
PlaygroundPage.current.needsIndefiniteExecution = true

// Функция без @escaping — замыкание вызывается сразу
func runNow(action: () -> Void) {
    print("Сейчас выполню:")
    action()
}

runNow {
    print("→ Замыкание внутри runNow")
}

// Функция с @escaping — замыкание выполнится позже
func runLater(action: @escaping @Sendable () -> Void) {
    DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
        print("Через 1 секунду:")
        action()
        PlaygroundPage.current.finishExecution()
    }
}

runLater {
    print("→ Замыкание внутри runLater (отложено)")
}

import Foundation

final class Downloader: Sendable {
    // Замыкание, которое вызывается после завершения "загрузки"
    var onComplete: (() -> Void)?

    func load() {
        // Эмулируем асинхронную работу с небольшой задержкой (0.5 сек)
        // DispatchQueue.global() запускает код в фоновом потоке
        DispatchQueue.global().asyncAfter(deadline: .now() + 0.5) { [weak self] in
            // [weak self] — захватываем self слабо, чтобы избежать retain cycle
            // Без weak self объект Downloader мог бы остаться в памяти, даже если все ссылки на него исчезнут
            self?.onComplete?() // безопасно вызываем замыкание, если self ещё жив
        }
    }
}

// Тест
let downloader = Downloader()

downloader.onComplete = {
    print("Download finished!") // Этот код выполнится через 0.5 сек
}

downloader.load()

import Foundation

// Замыкание, которое принимает два Int и возвращает их сумму (Int)
let sumClosure: (Int, Int) -> Int = { a, b in
    return a + b
}

// Замыкание, которое принимает имя и возвращает приветствие (String)
let greetingClosure: (String) -> String = { name in
    return "Привет, \(name)!"
}

// Замыкание без параметров, которое возвращает текущее время (Date)
let dateClosure: () -> Date = {
    return Date()
}

// Примеры использования
let result1 = sumClosure(5, 7)           // 12
let result2 = greetingClosure("Sergei")   // "Привет, Sergei!"
let result3 = dateClosure()               // Текущая дата и время

print(result1)
print(result2)
print(result3)

import Foundation

// Переменная объявлена вне функции (пока без значения)
var operation: ((Int, Int) -> Int)?

// Функция, внутри которой мы присваиваем переменной замыкание
@MainActor func setupClosure() {
    // Присваиваем замыкание в переменную
    operation = { a, b in
        return a + b
    }
    print("Замыкание присвоено переменной 'operation'")
}

// Сначала вызываем настройку
setupClosure()

// Теперь можно использовать переменную с замыканием
if let op = operation {
    let result = op(4, 6)
    print("4 + 6 = \(result)") // 4 + 6 = 10
}

import Foundation

// Переменная closure — замыкание без параметров и возвращаемого значения
var closure: () -> Void = {
    print("Замыкание вызвано!")
}

// Вызов замыкания
closure()   // правильный вызов

import Foundation

// Функция, принимающая замыкание
func testClosure(action: (Int, Int) -> Int) {
    let result = action(5, 3)
    print("Результат: \(result)")
}

// Вызов функции с замыканием
testClosure { (a: Int, b: Int) -> Int in
    // ключевое слово "in" отделяет список параметров и возвращаемый тип от тела замыкания
    return a + b
}

// Можно еще короче (Swift умеет выводить типы)
testClosure { a, b in
    a * b
}

import Foundation

class TestLazy {
    // lazy переменная, вычисляется замыканием
    lazy var value: String = {
        print("⚡ Замыкание выполнено!")
        return "Результат"
    }()
}

print("👉 Создали объект TestLazy")
let test = TestLazy()

print("👉 Доступ к lazy переменной:")
print("value =", test.value) // здесь произойдёт выполнение замыкания

print("👉 Повторный доступ к value:")
print("value =", test.value) // замыкание больше не вызывается, берётся сохранённое значение

import Foundation

// У нас есть массив чисел
let numbers = [1, 2, 3, 4, 5]

// Используем замыкание, чтобы удвоить каждое число
let doubled = numbers.map { (number: Int) -> Int in
    return number * 2
}
print("Удвоенные числа: \(doubled)")

// Ещё короче — Swift позволяет опускать типы и использовать $0
let tripled = numbers.map { $0 * 3 }
print("Утроенные числа: \(tripled)")

// Другой пример: фильтрация
let evenNumbers = numbers.filter { $0 % 2 == 0 }
print("Чётные числа: \(evenNumbers)")

// Сортировка с замыканием
let sortedDescending = numbers.sorted { $0 > $1 }
print("Сортировка по убыванию: \(sortedDescending)")