SwiftUI Data Flow: Передача данных между представлениями

struct ToggleView: View {
    @State private var isToggled = false
    
    var body: some View {
        Toggle("Включить функцию", isOn: $isToggled)
            .padding()
    }
}

struct ParentView: View {
    @State private var text = "Привет"
    
    var body: some View {
        VStack {
            Text(text).padding()
            ChildView(text: $text)
        }
    }
}
 
struct ChildView: View {
    @Binding var text: String
    
    var body: some View {
        TextField("Введите текст", text: $text)
            .padding()
    }
}

struct SliderView: View {
    @Binding var percentage: Double
    
    var body: some View {
        VStack {
            Text("\(Int(percentage * 100))%")
            Slider(value: $percentage)
        }
    }
}
 
struct ParentView: View {
    @State private var value = 0.0
    
    var body: some View {
        VStack {
            SliderView(percentage: $value)
            // Создание биндинга с трансформацией
            Toggle("Больше половины", isOn: Binding(
                get: { value > 0.5 },
                set: { newValue in value = newValue ? 0.75 : 0.25 }
            ))
        }
    }
}

class UserSettings: ObservableObject {
    @Published var username = "Гость"
    @Published var isDarkModeEnabled = false
}
 
struct ProfileView: View {
    @StateObject private var settings = UserSettings()
    
    var body: some View {
        VStack {
            TextField("Имя пользователя", text: $settings.username)
            Toggle("Темная тема", isOn: $settings.isDarkModeEnabled)
            
            DetailView()
                .environmentObject(settings)
        }
        .padding()
    }
}
 
struct DetailView: View {
    @EnvironmentObject var settings: UserSettings
    
    var body: some View {
        Text("Привет, \(settings.username)")
            .padding()
    }
}

@Observable
class UserSettings {
    var username = "Гость"
    var isDarkModeEnabled = false
}
 
struct ProfileView: View {
    @State private var settings = UserSettings()
    
    var body: some View {
        VStack {
            TextField("Имя пользователя", text: $settings.username)
            Toggle("Темная тема", isOn: $settings.isDarkModeEnabled)
        }
        .padding()
    }
}

// В корневом представлении
struct RootView: View {
    @StateObject private var userManager = UserManager()
    
    var body: some View {
        ContentView()
            .environmentObject(userManager)
    }
}
 
// В любом дочернем представлении - даже глубоко в иерархии
struct DeepChildView: View {
    @EnvironmentObject var userManager: UserManager
    
    var body: some View {
        Text("Текущий пользователь: \(userManager.username)")
    }
}

class CartManager: ObservableObject {
    @Published var items: [CartItem] = []
    @Published var totalPrice: Double = 0.0
    
    var itemCount: Int {
        items.count
    }
    
    func addItem(_ item: CartItem) {
        items.append(item)
        totalPrice += item.price
    }
}

func markItemAsPurchased(at index: Int) {
    var updatedItems = items
    updatedItems[index].isPurchased = true
    items = updatedItems  // Это вызовет обновление UI
}

@Observable
class CartManager {
    var items: [CartItem] = []
    var totalPrice: Double = 0.0
    
    func addItem(_ item: CartItem) {
        items.append(item)
        totalPrice += item.price
        // UI обновится при изменении любого отслеживаемого свойства
    }
}

struct SettingsView: View {
    @AppStorage("username") private var username: String = "Гость"
    @AppStorage("isNotificationsEnabled") private var areNotificationsEnabled = true
    
    var body: some View {
        Form {
            TextField("Имя пользователя", text: $username)
            Toggle("Уведомления", isOn: $areNotificationsEnabled)
        }
    }
}

struct ComplexSettings: Codable {
    var theme: String
    var fontScale: Double
    var privacyOptions: [String: Bool]
}
 
struct AdvancedSettingsView: View {
    @AppStorage("complexSettings") private var complexSettingsData: Data = {
        let defaultSettings = ComplexSettings(
            theme: "system",
            fontScale: 1.0,
            privacyOptions: ["analytics": true, "personalization": false]
        )
        return try! JSONEncoder().encode(defaultSettings)
    }()
    
    private var settings: ComplexSettings {
        get {
            try! JSONDecoder().decode(ComplexSettings.self, from: complexSettingsData)
        }
        set {
            complexSettingsData = try! JSONEncoder().encode(newValue)
        }
    }
    
    var body: some View {
        VStack {
            Text("Текущая тема: \(settings.theme)")
            // ... другие элементы интерфейса
        }
    }
}

struct DocumentEditorView: View {
    @SceneStorage("documentText") private var documentText = ""
    @SceneStorage("cursorPosition") private var cursorPosition = 0
    
    var body: some View {
        TextEditor(text: $documentText)
            // ... логика для отслеживания и восстановления позиции курсора
    }
}

struct RegistrationForm: View {
    @State private var username = ""
    @State private var email = ""
    @State private var password = ""
    @State private var passwordConfirm = ""
    @State private var agreedToTerms = false
    
    // Состояние валидации
    @State private var isUsernameValid = true
    @State private var isEmailValid = true
    @State private var doPasswordsMatch = true
    
    var canSubmit: Bool {
        !username.isEmpty && isUsernameValid &&
        !email.isEmpty && isEmailValid &&
        !password.isEmpty && password == passwordConfirm &&
        agreedToTerms
    }
    
    var body: some View {
        Form {
            Section(header: Text("Информация профиля")) {
                TextField("Имя пользователя", text: $username)
                    .onChange(of: username) { validateUsername() }
                if !isUsernameValid {
                    Text("Имя должно содержать не менее 3 символов")
                        .foregroundColor(.red)
                }
                
                TextField("Email", text: $email)
                    .onChange(of: email) { validateEmail() }
                if !isEmailValid {
                    Text("Некорректный формат email")
                        .foregroundColor(.red)
                }
            }
            
            Section(header: Text("Безопасность")) {
                SecureField("Пароль", text: $password)
                    .onChange(of: password) { validatePasswords() }
                SecureField("Подтвердите пароль", text: $passwordConfirm)
                    .onChange(of: passwordConfirm) { validatePasswords() }
                if !doPasswordsMatch {
                    Text("Пароли не совпадают")
                        .foregroundColor(.red)
                }
            }
            
            Toggle("Я согласен с условиями", isOn: $agreedToTerms)
            
            Button("Зарегистрироваться") {
                submitRegistration()
            }
            .disabled(!canSubmit)
        }
    }
    
    private func validateUsername() {
        isUsernameValid = username.count >= 3
    }
    
    private func validateEmail() {
        // Упрощенная проверка email
        isEmailValid = email.contains("@") && email.contains(".")
    }
    
    private func validatePasswords() {
        doPasswordsMatch = password == passwordConfirm
    }
    
    private func submitRegistration() {
        // Отправка данных на сервер
    }
}

@Observable
class RegistrationModel {
    var username = ""
    var email = ""
    var password = ""
    var passwordConfirm = ""
    var agreedToTerms = false
    
    var isUsernameValid: Bool {
        username.count >= 3
    }
    
    var isEmailValid: Bool {
        email.contains("@") && email.contains(".")
    }
    
    var doPasswordsMatch: Bool {
        password == passwordConfirm
    }
    
    var canSubmit: Bool {
        !username.isEmpty && isUsernameValid &&
        !email.isEmpty && isEmailValid &&
        !password.isEmpty && doPasswordsMatch &&
        agreedToTerms
    }
}
 
struct RegistrationForm: View {
    @State private var model = RegistrationModel()
    
    var body: some View {
        Form {
            TextField("Имя пользователя", text: $model.username)
            if !model.isUsernameValid && !model.username.isEmpty {
                Text("Имя должно содержать не менее 3 символов")
                    .foregroundColor(.red)
            }
            
            // Остальные поля...
            
            Button("Зарегистрироваться") {
                // Отправка данных
            }
            .disabled(!model.canSubmit)
        }
    }
}

@Observable
class ExpenseModel {
    var transactions: [Transaction] = []
    var categories: [Category] = []
    
    func addTransaction(_ transaction: Transaction) {
        transactions.append(transaction)
    }
    
    func updateTransaction(_ transaction: Transaction, at index: Int) {
        transactions[index] = transaction
    }
    
    func deleteTransaction(at index: Int) {
        transactions.remove(at: index)
    }
}
 
struct ExpensesApp: View {
    @State private var expenseModel = ExpenseModel()
    @State private var showingAddForm = false
    
    var body: some View {
        NavigationStack {
            TransactionListView(transactions: $expenseModel.transactions)
                .navigationTitle("Мои расходы")
                .toolbar {
                    Button("Добавить") {
                        showingAddForm = true
                    }
                }
                .sheet(isPresented: $showingAddForm) {
                    TransactionFormView(
                        categories: expenseModel.categories,
                        onSave: { transaction in
                            expenseModel.addTransaction(transaction)
                            showingAddForm = false
                        }
                    )
                }
        }
        .environment(expenseModel)
    }
}
 
struct TransactionListView: View {
    @Binding var transactions: [Transaction]
    
    var body: some View {
        List {
            ForEach(transactions.indices, id: \.self) { index in
                NavigationLink {
                    TransactionDetailView(transaction: $transactions[index])
                } label: {
                    TransactionRow(transaction: transactions[index])
                }
            }
            .onDelete { indexSet in
                transactions.remove(atOffsets: indexSet)
            }
        }
    }
}

struct TransactionListView: View {
    @Environment(ExpenseModel.self) private var expenseModel
    
    var body: some View {
        List {
            ForEach(expenseModel.transactions) { transaction in
                NavigationLink {
                    TransactionDetailView(transactionId: transaction.id)
                } label: {
                    TransactionRow(transaction: transaction)
                }
            }
            .onDelete { indexSet in
                for index in indexSet {
                    expenseModel.deleteTransaction(at: index)
                }
            }
        }
    }
}
 
struct TransactionDetailView: View {
    let transactionId: UUID
    @Environment(ExpenseModel.self) private var expenseModel
    
    private var transactionBinding: Binding<Transaction> {
        Binding(
            get: {
                expenseModel.transactions.first { $0.id == transactionId }!
            },
            set: { newValue in
                if let index = expenseModel.transactions.firstIndex(where: { $0.id == transactionId }) {
                    expenseModel.updateTransaction(newValue, at: index)
                }
            }
        )
    }
    
    var body: some View {
        TransactionForm(transaction: transactionBinding)
            .navigationTitle("Детали транзакции")
    }
}

@Observable
class WeatherViewModel {
    var temperature: Double?
    var humidity: Double?
    var isLoading = false
    var errorMessage: String?
    
    func fetchWeather(for city: String) async {
        isLoading = true
        errorMessage = nil
        
        do {
            // Имитация сетевого запроса
            try await Task.sleep(for: .seconds(1))
            
            // В реальном приложении здесь был бы API-запрос
            let weatherData = try await WeatherService.fetchWeather(for: city)
            
            // Обновляем UI в основном потоке
            await MainActor.run {
                temperature = weatherData.temperature
                humidity = weatherData.humidity
                isLoading = false
            }
        } catch {
            await MainActor.run {
                errorMessage = "Ошибка загрузки: \(error.localizedDescription)"
                isLoading = false
            }
        }
    }
}
 
struct WeatherView: View {
    @State private var city = ""
    @State private var viewModel = WeatherViewModel()
    
    var body: some View {
        VStack {
            TextField("Введите город", text: $city)
                .textFieldStyle(RoundedBorderTextFieldStyle())
                .padding()
            
            Button("Посмотреть погоду") {
                Task {
                    await viewModel.fetchWeather(for: city)
                }
            }
            .disabled(city.isEmpty || viewModel.isLoading)
            .padding()
            
            if viewModel.isLoading {
                ProgressView()
            } else if let errorMessage = viewModel.errorMessage {
                Text(errorMessage)
                    .foregroundColor(.red)
            } else if let temperature = viewModel.temperature,
                      let humidity = viewModel.humidity {
                VStack(spacing: 10) {
                    Text("Температура: \(temperature, specifier: "%.1f")°C")
                    Text("Влажность: \(humidity, specifier: "%.0f")%")
                }
            }
            
            Spacer()
        }
        .padding()
    }
}

func fetchWeatherData(for city: String) async throws -> WeatherData {
    return try await withCheckedThrowingContinuation { continuation in
        weatherService.fetchWeather(for: city) { result in
            switch result {
            case .success(let data):
                continuation.resume(returning: data)
            case .failure(let error):
                continuation.resume(throwing: error)
            }
        }
    }
}

// Неправильно
struct DetailView: View {
    let item: TodoItem // Копия, изменения не будут синхронизированы
    
    var body: some View {
        // ...
    }
}
 
// Правильно
struct DetailView: View {
    @Binding var item: TodoItem // Ссылка на оригинальные данные
    
    var body: some View {
        // ...
    }
}

// Неэффективно
@Observable
class UserPreferences {
    var allSettings: [String: Any] = [:]  // Изменение любого значения обновит весь UI
}
 
// Более эффективно
@Observable
class UserPreferences {
    var appearance: AppearanceSettings = .default
    var notifications: NotificationSettings = .default
    var privacy: PrivacySettings = .default
}

struct ContentView: View {
    @State private var tasks: [Task] = []
    
    var body: some View {
        List {
            // Плохо: ID основан на индексе, который может измениться
            ForEach(0..<tasks.count, id: \.self) { index in
                TaskRow(task: tasks[index])
            }
            
            // Хорошо: ID основан на уникальном идентификаторе
            ForEach(tasks) { task in
                TaskRow(task: task)
            }
        }
    }
}

// Определение сервиса
protocol AuthenticationService {
    var currentUser: User? { get }
    func signIn(username: String, password: String) async throws -> User
    func signOut() async throws
}
 
// Реализация
class DefaultAuthService: AuthenticationService {
    @Published var currentUser: User?
    
    func signIn(username: String, password: String) async throws -> User {
        // Реализация
    }
    
    func signOut() async throws {
        // Реализация
    }
}
 
// Ключ для доступа к сервису через окружение
struct AuthServiceKey: EnvironmentKey {
    static let defaultValue: AuthenticationService = DefaultAuthService()
}
 
// Расширение для удобного доступа
extension EnvironmentValues {
    var authService: AuthenticationService {
        get { self[AuthServiceKey.self] }
        set { self[AuthServiceKey.self] = newValue }
    }
}
 
// Использование в приложении
struct MyApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
                .environment(\.authService, DefaultAuthService())
        }
    }
}
 
// Доступ к сервису
struct LoginView: View {
    @Environment(\.authService) private var authService
    @State private var username = ""
    @State private var password = ""
    
    var body: some View {
        // ...
    }
}

// Тестируемое представление
struct ProfileEditor: View {
    @Binding var profile: UserProfile
    
    var body: some View {
        Form {
            TextField("Имя", text: $profile.name)
            TextField("Фамилия", text: $profile.surname)
            DatePicker("Дата рождения", selection: $profile.birthDate)
        }
    }
}
 
// Тестирование с помощью PreviewProvider
struct ProfileEditor_Previews: PreviewProvider {
    static var previews: some View {
        @State var profile = UserProfile.sample
        return ProfileEditor(profile: $profile)
    }
}

func testProfileEditor() throws {
    // Создаем тестовый профиль
    let profile = UserProfile.sample
    
    // Создаем тестовое представление
    let profileEditor = ProfileEditor(
        profile: .constant(profile)
    )
    
    // Проверяем текстовые поля
    let namePredicate = "TextField where label == 'Имя' && text == '\(profile.name)'"
    XCTAssert(try viewController.inspect().find(viewWithId: namePredicate).isTextField())
    
    // Имитируем редактирование поля
    try viewController.inspect().find(viewWithId: namePredicate).textField().setInput("Новое имя")
    
    // Проверяем обновление модели
    XCTAssertEqual(profile.name, "Новое имя")
}

let testView = MyView()
    .environment(\.locale, Locale(identifier: "ru"))
    .environmentObject(MockDataModel())

struct ViewFactory {
    let dataModel: DataModel
    let settings: AppSettings
    
    func makeHomeView() -> some View {
        HomeView()
            .environment(\.appSettings, settings)
            .environmentObject(dataModel)
    }
    
    // Другие фабричные методы
}
 
// В тестах
let factory = ViewFactory(
    dataModel: MockDataModel(...),
    settings: TestSettings(...)
)
let view = factory.makeHomeView()

struct ViewContextKey: EnvironmentKey {
    static let defaultValue: ViewContext = .global
}
 
extension EnvironmentValues {
    var viewContext: ViewContext {
        get { self[ViewContextKey.self] }
        set { self[ViewContextKey.self] = newValue }
    }
}
 
enum ViewContext {
    case global
    case limited(permissions: [Permission])
    case preview
    
    var canEditContent: Bool {
        switch self {
        case .global:
            return true
        case .limited(let permissions):
            return permissions.contains(.edit)
        case .preview:
            return false
        }
    }
}
 
struct ContentEditor: View {
    @Environment(\.viewContext) private var context
    @Binding var content: String
    
    var body: some View {
        if context.canEditContent {
            TextField("Редактировать", text: $content)
        } else {
            Text(content)
        }
    }
}

class EditableModel<T>: ObservableObject where T: Equatable {
    @Published private(set) var original: T
    @Published var draft: T
    
    var hasChanges: Bool {
        original != draft
    }
    
    init(value: T) {
        self.original = value
        self.draft = value
    }
    
    func commit() {
        original = draft
    }
    
    func discard() {
        draft = original
    }
}
 
struct EditView<Content: View, T: Equatable>: View {
    @StateObject private var model: EditableModel<T>
    @Environment(\.dismiss) private var dismiss
    private let content: (Binding<T>) -> Content
    
    init(value: T, @ViewBuilder content: @escaping (Binding<T>) -> Content) {
        self._model = StateObject(wrappedValue: EditableModel(value: value))
        self.content = content
    }
    
    var body: some View {
        NavigationStack {
            content($model.draft)
                .toolbar {
                    ToolbarItem(placement: .cancellationAction) {
                        Button("Отмена") {
                            dismiss()
                        }
                    }
                    
                    ToolbarItem(placement: .confirmationAction) {
                        Button("Сохранить") {
                            model.commit()
                            dismiss()
                        }
                        .disabled(!model.hasChanges)
                    }
                }
        }
    }
}

// Вместо этого
@Observable class AppState {
    var user: User = .anonymous
    var settings: Settings = .default
    var documents: [Document] = []
    var networkStatus: NetworkStatus = .disconnected
}
 
// Лучше использовать
@Observable class UserState {
    var user: User = .anonymous
}
 
@Observable class AppSettings {
    var settings: Settings = .default
}
 
@Observable class DocumentStore {
    var documents: [Document] = []
}
 
@Observable class NetworkMonitor {
    var status: NetworkStatus = .disconnected
}

struct ExpensiveView: View {
    let data: ComplexData
    
    var body: some View {
        // Сложные вычисления на основе data
        VStack {
            // ... множество дочерних компонентов
        }
    }
    
    static func == (lhs: Self, rhs: Self) -> Bool {
        lhs.data.id == rhs.data.id && lhs.data.version == rhs.data.version
    }
}

struct ChartView: View, Equatable {
    let data: ChartData
    @State private var internalData: ProcessedChartData?
    
    var body: some View {
        Group {
            if let internalData {
                // Отрисовка на основе обработанных данных
            } else {
                ProgressView()
            }
        }
        .task(id: data.id) {
            // Отложенная обработка для предотвращения зависаний UI
            let processed = await processData(data)
            internalData = processed
        }
    }
    
    static func == (lhs: Self, rhs: Self) -> Bool {
        lhs.data.id == rhs.data.id
    }
    
    private func processData(_ data: ChartData) async -> ProcessedChartData {
        // Тяжелые вычисления в фоновом потоке
        await Task.yield() // Даем возможность другим задачам выполниться
        return // ... результат обработки
    }
}

struct SearchView: View {
    @State private var searchText = ""
    @State private var results: [SearchResult] = []
    @State private var isLoading = false
    
    // Издатель для дебаунсинга поисковых запросов
    private let searchSubject = PassthroughSubject<String, Never>()
    
    var body: some View {
        VStack {
            TextField("Поиск", text: $searchText)
                .onChange(of: searchText) {
                    searchSubject.send(searchText)
                }
            
            if isLoading {
                ProgressView()
            } else {
                List(results) { result in
                    Text(result.title)
                }
            }
        }
        .onAppear {
            setupSearchPipeline()
        }
    }
    
    private func setupSearchPipeline() {
        searchSubject
            .debounce(for: .seconds(0.5), scheduler: RunLoop.main)
            .removeDuplicates()
            .filter { !$0.isEmpty }
            .handleEvents(receiveOutput: { _ in isLoading = true })
            .flatMap { term in
                Future<[SearchResult], Error> { promise in
                    Task {
                        do {
                            let results = try await performSearch(term)
                            promise(.success(results))
                        } catch {
                            promise(.failure(error))
                        }
                    }
                }
                .catch { error -> Just<[SearchResult]> in
                    print("Ошибка поиска: \(error)")
                    return Just([])
                }
            }
            .receive(on: RunLoop.main)
            .sink { results in
                self.results = results
                self.isLoading = false
            }
            .store(in: &cancellables)
    }
}

let userDataPublisher = fetchUserData()
let friendsPublisher = fetchFriendsList()
let postsPublisher = fetchRecentPosts()
 
Publishers.CombineLatest3(userDataPublisher, friendsPublisher, postsPublisher)
    .receive(on: RunLoop.main)
    .sink { userData, friends, posts in
        // Обновление UI с полным набором данных
        updateProfileView(userData: userData, friends: friends, posts: posts)
    }
    .store(in: &cancellables)