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)")

import Foundation

// Определяем перечисление (enum) для времён года
enum Season {
    case spring
    case summer
    case autumn
    case winter
    
    // Дополнительный метод, который возвращает описание сезона
    func description() -> String {
        switch self {
        case .spring:
            return "Весна 🌱"
        case .summer:
            return "Лето ☀️"
        case .autumn:
            return "Осень 🍂"
        case .winter:
            return "Зима ❄️"
        }
    }
}

// Использование enum
let currentSeason: Season = .summer

print("Сейчас: \(currentSeason.description())")

import Foundation

enum Direction {
    case north, south, east, west

    // Обычный метод
    func description() -> String {
        switch self {
        case .north: return "⬆️ North"
        case .south: return "⬇️ South"
        case .east:  return "➡️ East"
        case .west:  return "⬅️ West"
        }
    }

    // Статический метод
    static func allDirections() -> [Direction] {
        return [.north, .south, .east, .west]
    }

    // Вычисляемое свойство
    var isVertical: Bool {
        return self == .north || self == .south
    }
}

// Использование
let dir = Direction.east
print(dir.description())     // East
print(dir.isVertical)        // false
print(Direction.allDirections()) // [north, south, east, west]

import Foundation

enum TestEnum: Int {
    case first   // автоматически = 0
    case second  // автоматически = 1
    case third   // автоматически = 2
}

print("first =", TestEnum.first.rawValue)   // 0
print("second =", TestEnum.second.rawValue) // 1
print("third =", TestEnum.third.rawValue)   // 2

// Тест: 🧪 Можно ли задать строковый rawValue для case в enum❓🤔

enum SomeEnum: String {
    case one = "Первый"
    case two = "Второй"
}

// Проверим
print(SomeEnum.one.rawValue)   // "Первый"
print(SomeEnum.two.rawValue)   // "Второй"

// Попробуем восстановить enum по rawValue
if let value = SomeEnum(rawValue: "Второй") {
    print("Нашли case:", value) // Нашли case: two
}

enum Message {
    case text(String) // хранит строку
    case photo(url: String) // хранит ссылку
    case video(length: Int) // хранит длительность видео
}

let msg1 = Message.text("Привет 👋")
let msg2 = Message.photo(url: "https://some.com/photo.jpg")
let msg3 = Message.video(length: 120)

// Распаковка через switch
func handleMessage(_ message: Message) {
    switch message {
    case .text(let text):
        print("Текстовое сообщение: \(text)")
    case .photo(let url):
        print("Фото по ссылке: \(url)")
    case .video(let length):
        print("Видео, длительность: \(length) секунд")
    }
}

handleMessage(msg1)
handleMessage(msg2)
handleMessage(msg3)

import Foundation

// Enum с поддержкой CaseIterable
enum Direction: CaseIterable {
    case north
    case south
    case east
    case west
}

// Проверим результат работы allCases
print("Количество элементов: \(Direction.allCases.count)")
print("Список всех case: \(Direction.allCases)")

// Перебор всех вариантов
for direction in Direction.allCases {
    print("Направление: \(direction)")
}

import Foundation

// Рекурсивное перечисление с использованием `indirect`
enum LinkedList {
    case empty
    indirect case node(Int, next: LinkedList)
}

// Пример использования
let list = LinkedList.node(1, next: .node(2, next: .node(3, next: .empty)))

// Рекурсивная функция для печати значений
func printList(_ list: LinkedList) {
    switch list {
    case .empty:
        print("nil")
    case .node(let value, let next):
        print(value, terminator: " -> ")
        printList(next)
    }
}

printList(list)
// Вывод: 1 -> 2 -> 3 -> nil