Реализация универсальных ссылок в iOS

func application(_ application: UIApplication, 
                continue userActivity: NSUserActivity, 
                restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {
    
    guard userActivity.activityType == NSUserActivityTypeBrowsingWeb,
          let url = userActivity.webpageURL else {
        return false
    }
    
    handleUniversalLink(url: url)
    return true
}

@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
                .onOpenURL { url in
                    handleUniversalLink(url: url)
                }
        }
    }
}

struct ProductView: View {
    var body: some View {
        VStack {
            // UI контент
        }
        .onOpenURL { url in
            if url.host == "example.com" && url.path.hasPrefix("/product/") {
                // Обработать открытие конкретного продукта
                loadProduct(from: url)
            }
        }
    }
}

func handleUniversalLink(url: URL) {
    guard let components = URLComponents(url: url, resolvingAgainstBaseURL: true) else {
        return
    }
    
    let path = components.path
    let queryItems = components.queryItems
    
    switch path {
    case let path where path.hasPrefix("/product/"):
        let productID = String(path.dropFirst("/product/".count))
        openProduct(id: productID, parameters: queryItems)
        
    case "/profile":
        openProfile(parameters: queryItems)
        
    default:
        openHome()
    }
}

extension Dictionary where Key == String, Value == String? {
    init(queryItems: [URLQueryItem]?) {
        self.init()
        queryItems?.forEach { item in
            self[item.name] = item.value
        }
    }
}
 
// Использование
let params = Dictionary<String, String?>(queryItems: components.queryItems)
let category = params["category"] ?? "all"

func openProduct(id: String, parameters: [URLQueryItem]?) {
    // Проверяем, что ID содержит только допустимые символы
    guard id.range(of: "^[a-zA-Z0-9-_]+$", options: .regularExpression) != nil else {
        showError("Invalid product ID")
        return
    }
    
    // Проверяем длину
    guard id.count <= 50 else {
        showError("Product ID too long")
        return
    }
    
    // Теперь безопасно использовать ID
    ProductService.shared.loadProduct(id: id)
}

@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
                .handlesExternalEvents(preferring: Set(arrayLiteral: "product", "profile"), allowing: Set(arrayLiteral: "*"))
        }
        .handlesExternalEvents(matching: Set(arrayLiteral: "product", "profile"))
    }
}

func handleUniversalLink(url: URL) {
    // Сохраняем текущее состояние навигации
    let previousState = navigationManager.currentState
    
    // Переходим по ссылке
    navigateToContent(from: url)
    
    // Предлагаем пользователю вернуться к предыдущему контенту
    showReturnToPreviousContentOption(state: previousState)
}

class AppCoordinator {
    private var childCoordinators: [Coordinator] = []
    
    func handleUniversalLink(_ url: URL) {
        guard let components = URLComponents(url: url, resolvingAgainstBaseURL: true) else {
            return
        }
        
        switch components.path {
        case let path where path.hasPrefix("/product/"):
            let coordinator = ProductCoordinator()
            coordinator.handleUniversalLink(url)
            childCoordinators.append(coordinator)
            
        case "/profile":
            let coordinator = ProfileCoordinator()
            coordinator.start()
            childCoordinators.append(coordinator)
        }
    }
}

struct TestApp: View {
    let testLinks = [
        "https://example.com/product/123",
        "https://example.com/profile",
        "https://example.com/search?q=test"
    ]
    
    var body: some View {
        List(testLinks, id: \.self) { link in
            Button(link) {
                if let url = URL(string: link) {
                    UIApplication.shared.open(url)
                }
            }
        }
    }
}

func handleUniversalLink(url: URL) {
    // Отправляем событие в аналитику до обработки ссылки
    AnalyticsManager.shared.trackUniversalLink(
        url: url.absoluteString,
        source: determineSource(from: url),
        timestamp: Date()
    )
    
    // Обычная обработка ссылки
    processUniversalLink(url)
}
 
private func determineSource(from url: URL) -> String {
    // Пытаемся определить источник по UTM параметрам
    if let components = URLComponents(url: url, resolvingAgainstBaseURL: true),
       let queryItems = components.queryItems {
        
        for item in queryItems {
            if item.name == "utm_source" {
                return item.value ?? "unknown"
            }
        }
    }
    
    return "direct"
}

class AppDelegate: UIResponder, UIApplicationDelegate {
    var pendingUniversalLink: URL?
    
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        
        // Предзагружаем базовые данные для быстрого старта
        CoreDataStack.shared.preloadEssentialData()
        NetworkService.shared.initializeSession()
        
        return true
    }
    
    func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {
        
        guard userActivity.activityType == NSUserActivityTypeBrowsingWeb,
              let url = userActivity.webpageURL else {
            return false
        }
        
        if !ApplicationStateManager.shared.isFullyInitialized {
            // Если приложение еще не готово, сохраняем ссылку
            pendingUniversalLink = url
            return true
        }
        
        handleUniversalLink(url: url)
        return true
    }
}

class NavigationManager {
    private var navigationQueue: [NavigationAction] = []
    private var isProcessing = false
    
    enum NavigationAction {
        case universalLink(URL)
        case pushNotification(payload: [String: Any])
        case shortcut(type: String)
    }
    
    func handleNavigation(_ action: NavigationAction) {
        navigationQueue.append(action)
        processNextIfPossible()
    }
    
    private func processNextIfPossible() {
        guard !isProcessing, !navigationQueue.isEmpty else { return }
        
        isProcessing = true
        let action = navigationQueue.removeFirst()
        
        executeNavigation(action) { [weak self] in
            self?.isProcessing = false
            self?.processNextIfPossible()
        }
    }
}

func handleAuthUniversalLink(url: URL) {
    guard let components = URLComponents(url: url, resolvingAgainstBaseURL: true),
          let code = components.queryItems?.first(where: { $0.name == "auth_code" })?.value else {
        showAuthError("Invalid authentication link")
        return
    }
    
    // Обмениваем временный код на токен через защищенный API
    AuthService.shared.exchangeCodeForToken(code: code) { result in
        switch result {
        case .success(let token):
            // Сохраняем токен в Keychain
            KeychainService.shared.saveToken(token)
            navigateToAuthenticatedArea()
            
        case .failure(let error):
            showAuthError(error.localizedDescription)
        }
    }
}

func safeHandleUniversalLink(_ url: URL) {
    do {
        try validateUniversalLinkFormat(url)
        try processValidUniversalLink(url)
    } catch UniversalLinkError.invalidFormat {
        // Показываем пользователю понятную ошибку
        showFriendlyError("The link appears to be corrupted. Please try again or contact support.")
        // Логируем для разработчиков
        Logger.shared.logError("Invalid Universal Link format: \(url)")
    } catch UniversalLinkError.expiredLink {
        showFriendlyError("This link has expired. Please request a new one.")
    } catch {
        showFriendlyError("Unable to open the link. Please try again later.")
        Logger.shared.logError("Unexpected error handling Universal Link: \(error)")
    }
}

struct UniversalLinkRouter {
    func route(url: URL) throws {
        let version = extractAPIVersion(from: url) ?? "v1"
        
        switch version {
        case "v1":
            try routeV1(url: url)
        case "v2":
            try routeV2(url: url)
        default:
            // Используем последнюю версию для неизвестных версий
            try routeLatest(url: url)
        }
    }
    
    private func extractAPIVersion(from url: URL) -> String? {
        return URLComponents(url: url, resolvingAgainstBaseURL: true)?
            .queryItems?
            .first { $0.name == "api_version" }?
            .value
    }
}

func handleProductUniversalLink(productID: String) {
    // Сразу показываем экран с индикатором загрузки
    let loadingViewController = ProductLoadingViewController(productID: productID)
    navigationController.pushViewController(loadingViewController, animated: true)
    
    // Параллельно загружаем данные
    Task {
        do {
            let product = try await ProductService.shared.loadProduct(id: productID)
            let reviews = try await ReviewService.shared.loadReviews(for: productID)
            let recommendations = try await RecommendationService.shared.loadRecommendations(for: productID)
            
            await MainActor.run {
                let productViewController = ProductViewController(
                    product: product,
                    reviews: reviews,
                    recommendations: recommendations
                )
                
                navigationController.setViewControllers(
                    navigationController.viewControllers.dropLast() + [productViewController],
                    animated: true
                )
            }
        } catch {
            await MainActor.run {
                showError("Failed to load product: \(error.localizedDescription)")
                navigationController.popViewController(animated: true)
            }
        }
    }
}

class UniversalLinkCache {
    private let cache = NSCache<NSString, CachedContent>()
    private let cacheQueue = DispatchQueue(label: "universal.link.cache", qos: .background)
    
    func cacheContent(for url: URL, content: Any, ttl: TimeInterval = 300) {
        let key = url.absoluteString as NSString
        let cachedItem = CachedContent(content: content, expiryDate: Date().addingTimeInterval(ttl))
        
        cacheQueue.async { [weak self] in
            self?.cache.setObject(cachedItem, forKey: key)
        }
    }
    
    func getCachedContent(for url: URL) -> Any? {
        let key = url.absoluteString as NSString
        
        return cacheQueue.sync { [weak self] in
            guard let cachedItem = self?.cache.object(forKey: key),
                  cachedItem.expiryDate > Date() else {
                return nil
            }
            
            return cachedItem.content
        }
    }
}

func announceUniversalLinkNavigation(to destination: String) {
    DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
        UIAccessibility.post(notification: .screenChanged, argument: "Opened \(destination)")
    }
}

// Мок-сервер для тестирования Universal Links
class UniversalLinkTestServer {
    func startServer() {
        let server = HttpServer()
        
        server[".well-known/apple-app-site-association"] = { request in
            return .ok(.data(self.generateTestAssociationFile()))
        }
        
        server["/test/product/:id"] = { request in
            let productId = request.params[":id"] ?? "unknown"
            return .ok(.text("Product page for ID: \(productId)"))
        }
        
        try? server.start(8080)
    }
}

struct UniversalLinkParser {
    let url: URL
    
    var pathComponents: [String] {
        url.pathComponents.filter { $0 != "/" }
    }
    
    var queryParameters: [String: String] {
        guard let components = URLComponents(url: url, resolvingAgainstBaseURL: true) else {
            return [:]
        }
        
        var params: [String: String] = [:]
        components.queryItems?.forEach { item in
            params[item.name] = item.value ?? ""
        }
        return params
    }
    
    func extractID(from pattern: String) -> String? {
        let pathString = "/" + pathComponents.joined(separator: "/")
        
        // Преобразуем паттерн в регулярное выражение
        let regexPattern = pattern
            .replacingOccurrences(of: "*", with: "([^/]+)")
            .replacingOccurrences(of: "/", with: "\\/")
        
        guard let regex = try? NSRegularExpression(pattern: regexPattern) else {
            return nil
        }
        
        let range = NSRange(pathString.startIndex..., in: pathString)
        guard let match = regex.firstMatch(in: pathString, range: range) else {
            return nil
        }
        
        let matchRange = match.range(at: 1)
        return String(pathString[Range(matchRange, in: pathString)!])
    }
}

func handleUniversalLink(_ url: URL) {
    let parser = UniversalLinkParser(url: url)
    
    if let productId = parser.extractID(from: "/product/*") {
        openProduct(id: productId, filters: parser.queryParameters)
    } else if let userId = parser.extractID(from: "/user/*/profile") {
        openUserProfile(userId: userId)
    } else if parser.pathComponents.first == "search" {
        performSearch(query: parser.queryParameters["q"] ?? "")
    }
}

class NavigationCoordinator {
    private var navigationStack: [String] = []
    
    func navigateToContent(from link: UniversalLinkParser) {
        if let productId = link.extractID(from: "/product/*") {
            navigateToProduct(id: productId)
        } else if link.pathComponents.first == "cart" {
            navigateToCart()
        }
    }
    
    private func navigateToProduct(id: String) {
        // Если уже на экране продукта, заменяем
        if navigationStack.last?.hasPrefix("product") == true {
            replaceCurrentScreen(with: "product/\(id)")
        }
        // Если в корзине или профиле, показываем модально
        else if ["cart", "profile"].contains(navigationStack.last) {
            presentModal(screen: "product/\(id)")
        }
        // В остальных случаях - обычный push
        else {
            pushScreen("product/\(id)")
        }
    }
    
    private func pushScreen(_ screen: String) {
        navigationStack.append(screen)
        // Реальная навигация через UIKit или SwiftUI
    }
}

struct UniversalLinkTester: View {
    let testCases = [
        ("Product Page", "https://myapp.com/product/123?color=red"),
        ("User Profile", "https://myapp.com/user/456/profile"),
        ("Search Results", "https://myapp.com/search?q=iphone&category=electronics"),
        ("Deep Category", "https://myapp.com/category/electronics/phones/smartphones")
    ]
    
    @State private var testResults: [String: String] = [:]
    
    var body: some View {
        NavigationView {
            List {
                ForEach(testCases, id: \.0) { testCase in
                    VStack(alignment: .leading, spacing: 8) {
                        HStack {
                            Text(testCase.0)
                                .font(.headline)
                            Spacer()
                            Button("Test") {
                                testUniversalLink(testCase.1)
                            }
                            .buttonStyle(.bordered)
                        }
                        
                        Text(testCase.1)
                            .font(.caption)
                            .foregroundColor(.secondary)
                        
                        if let result = testResults[testCase.0] {
                            Text("Result: \(result)")
                                .font(.caption)
                                .foregroundColor(result.contains("Success") ? .green : .red)
                        }
                    }
                    .padding(.vertical, 4)
                }
            }
            .navigationTitle("Universal Links Test")
        }
    }
    
    private func testUniversalLink(_ urlString: String) {
        guard let url = URL(string: urlString) else { return }
        
        UIApplication.shared.open(url) { success in
            DispatchQueue.main.async {
                testResults[urlString] = success ? "Success" : "Failed"
            }
        }
    }
}

class UniversalLinkContentCache {
    private let imageCache = NSCache<NSString, UIImage>()
    private let dataCache = NSCache<NSString, NSData>()
    private let metadataCache = NSCache<NSString, ContentMetadata>()
    
    func preloadContent(for url: URL) async {
        let parser = UniversalLinkParser(url: url)
        
        if let productId = parser.extractID(from: "/product/*") {
            await preloadProduct(id: productId)
        } else if let categoryId = parser.extractID(from: "/category/*") {
            await preloadCategory(id: categoryId)
        }
    }
    
    private func preloadProduct(id: String) async {
        do {
            // Загружаем основную информацию о продукте
            let productData = try await APIClient.shared.fetchProduct(id: id)
            let key = "product_\(id)" as NSString
            dataCache.setObject(productData, forKey: key)
            
            // Предзагружаем главное изображение
            if let imageURL = extractMainImageURL(from: productData) {
                let image = try await ImageLoader.shared.loadImage(from: imageURL)
                imageCache.setObject(image, forKey: imageURL.absoluteString as NSString)
            }
            
            // Кэшируем метаданные для быстрого доступа
            let metadata = ContentMetadata(
                title: extractTitle(from: productData),
                description: extractDescription(from: productData),
                cachedAt: Date()
            )
            metadataCache.setObject(metadata, forKey: key)
            
        } catch {
            print("Preload failed for product \(id): \(error)")
        }
    }
}

extension UniversalLinkContentCache {
    func shouldRefreshCache(for key: String) -> Bool {
        guard let metadata = metadataCache.object(forKey: key as NSString) else {
            return true
        }
        
        // Кэш продукта живет 5 минут
        let cacheLifetime: TimeInterval = 300
        return Date().timeIntervalSince(metadata.cachedAt) > cacheLifetime
    }
    
    func invalidateCache(for productId: String) {
        let key = "product_\(productId)" as NSString
        dataCache.removeObject(forKey: key)
        metadataCache.removeObject(forKey: key)
        
        // Удаляем связанные изображения
        // (требует дополнительной логики для отслеживания связей)
    }
}

enum UniversalLinkError: LocalizedError {
    case productNotFound(id: String)
    case categoryNotAvailable
    case networkError
    case invalidLink
    
    var errorDescription: String? {
        switch self {
        case .productNotFound(let id):
            return "Товар \(id) не найден или больше не доступен"
        case .categoryNotAvailable:
            return "Эта категория временно недоступна"
        case .networkError:
            return "Проблемы с подключением. Проверьте интернет и попробуйте снова"
        case .invalidLink:
            return "Ссылка повреждена или устарела"
        }
    }
    
    var recoverySuggestion: String? {
        switch self {
        case .productNotFound:
            return "Попробуйте найти товар через поиск или каталог"
        case .categoryNotAvailable:
            return "Попробуйте позже или перейдите в главный каталог"
        case .networkError:
            return "Повторить попытку"
        case .invalidLink:
            return "Обратитесь в службу поддержки"
        }
    }
}

struct UniversalLinkRoute {
    let pattern: String
    let handler: (UniversalLinkParser) async throws -> Void
    let requiresAuth: Bool
    let cachingStrategy: CachingStrategy
}
 
class UniversalLinkRouter {
    private var routes: [UniversalLinkRoute] = []
    
    func register(_ route: UniversalLinkRoute) {
        routes.append(route)
    }
    
    func setupRoutes() {
        register(UniversalLinkRoute(
            pattern: "/product/*",
            handler: handleProduct,
            requiresAuth: false,
            cachingStrategy: .aggressive
        ))
        
        register(UniversalLinkRoute(
            pattern: "/order/*",
            handler: handleOrder,
            requiresAuth: true,
            cachingStrategy: .none
        ))
        
        register(UniversalLinkRoute(
            pattern: "/profile",
            handler: handleProfile,
            requiresAuth: true,
            cachingStrategy: .minimal
        ))
    }
    
    func route(_ url: URL) async {
        let parser = UniversalLinkParser(url: url)
        
        for route in routes {
            if parser.matches(pattern: route.pattern) {
                if route.requiresAuth && !AuthManager.shared.isAuthenticated {
                    await handleAuthRequired(for: url)
                    return
                }
                
                do {
                    try await route.handler(parser)
                } catch {
                    await handleRoutingError(error, for: url)
                }
                return
            }
        }
        
        // Fallback для неизвестных ссылок
        await handleUnknownLink(url)
    }
}

struct UniversalLinkAnalytics {
    static func trackLinkOpened(_ url: URL, source: String = "unknown") {
        let parser = UniversalLinkParser(url: url)
        
        var properties: [String: Any] = [
            "url": url.absoluteString,
            "path": url.path,
            "source": source,
            "timestamp": ISO8601DateFormatter().string(from: Date())
        ]
        
        // Добавляем специфичные для контента свойства
        if let productId = parser.extractID(from: "/product/*") {
            properties["content_type"] = "product"
            properties["product_id"] = productId
            properties["category"] = parser.queryParameters["category"]
        } else if parser.pathComponents.first == "search" {
            properties["content_type"] = "search"
            properties["search_query"] = parser.queryParameters["q"]
        }
        
        Analytics.track("universal_link_opened", properties: properties)
    }
    
    static func trackLinkConversion(_ url: URL, action: String) {
        Analytics.track("universal_link_conversion", properties: [
            "url": url.absoluteString,
            "conversion_action": action,
            "timestamp": ISO8601DateFormatter().string(from: Date())
        ])
    }
}

struct CrossPlatformLinkGenerator {
    static func generateProductLink(id: String, platform: Platform = .auto) -> String {
        let baseURL = "https://myapp.com"
        let path = "/product/\(id)"
        
        var queryItems: [URLQueryItem] = []
        
        switch platform {
        case .ios:
            queryItems.append(URLQueryItem(name: "platform", value: "ios"))
        case .android:
            queryItems.append(URLQueryItem(name: "platform", value: "android"))
        case .auto:
            // Платформа определится автоматически
            break
        }
        
        // UTM параметры для аналитики
        queryItems.append(URLQueryItem(name: "utm_source", value: "app"))
        queryItems.append(URLQueryItem(name: "utm_medium", value: "universal_link"))
        
        var components = URLComponents(string: baseURL + path)!
        components.queryItems = queryItems.isEmpty ? nil : queryItems
        
        return components.string ?? "\(baseURL)\(path)"
    }
}

class NavigationEventManager {
    private var eventQueue: [NavigationEvent] = []
    private var isProcessing = false
    
    enum NavigationEvent {
        case universalLink(URL, priority: Int = 1)
        case pushNotification([String: Any], priority: Int = 2)
        case deepLink(URL, priority: Int = 1)
        case shortcut(String, priority: Int = 3)
    }
    
    func handle(_ event: NavigationEvent) {
        eventQueue.append(event)
        eventQueue.sort { $0.priority > $1.priority }
        processNext()
    }
    
    private func processNext() {
        guard !isProcessing, !eventQueue.isEmpty else { return }
        
        isProcessing = true
        let event = eventQueue.removeFirst()
        
        Task {
            await process(event)
            await MainActor.run {
                isProcessing = false
                processNext()
            }
        }
    }
}

class UniversalLinkPreloader {
    func preload(for url: URL) async {
        let parser = UniversalLinkParser(url: url)
        
        await withTaskGroup(of: Void.self) { group in
            // Параллельная загрузка разных типов данных
            group.addTask {
                await self.preloadImages(for: parser)
            }
            
            group.addTask {
                await self.preloadAPIData(for: parser)
            }
            
            group.addTask {
                await self.preloadUserPreferences(for: parser)
            }
        }
    }
    
    private func preloadImages(for parser: UniversalLinkParser) async {
        if let productId = parser.extractID(from: "/product/*") {
            // Загружаем только главное изображение продукта
            do {
                let imageURL = try await APIClient.shared.fetchProductMainImage(id: productId)
                _ = try await ImageCache.shared.preloadImage(from: imageURL)
            } catch {
                // Не критичная ошибка - продолжаем без изображения
            }
        }
    }
}

class UniversalLinkDebugger {
  static func logLinkAttempt(_ url: URL, source: String) {
      let timestamp = DateFormatter.iso8601.string(from: Date())
      print(" [\(timestamp)] Universal Link attempt:")
      print("   URL: \(url.absoluteString)")
      print("   Source: \(source)")
      print("   Host: \(url.host ?? "nil")")
      print("   Path: \(url.path)")
      print("   Query: \(url.query ?? "none")")
  }
  
  static func logLinkResult(_ success: Bool, error: Error? = nil) {
      if success {
          print("Universal Link handled successfully")
      } else {
          print("Universal Link failed: \(error?.localizedDescription ?? "unknown error")")
      }
  }
}

class UniversalLinkFailureAnalytics {
  static func trackFailure(_ url: URL, reason: String, context: [String: Any] = [:]) {
      var properties = context
      properties["failed_url"] = url.absoluteString
      properties["failure_reason"] = reason
      properties["device_model"] = UIDevice.current.model
      properties["ios_version"] = UIDevice.current.systemVersion
      properties["app_version"] = Bundle.main.object(forInfoDictionaryKey: "CFBundleShortVersionString")
      
      Analytics.track("universal_link_failure", properties: properties)
  }
}

// Тест для проверки файла ассоциации
func testAppleAppSiteAssociation() {
  let url = URL(string: "https://example.com/.well-known/apple-app-site-association")!
  let expectation = self.expectation(description: "AASA file validation")
  
  URLSession.shared.dataTask(with: url) { data, response, error in
      XCTAssertNil(error)
      
      guard let httpResponse = response as? HTTPURLResponse else {
          XCTFail("Invalid response type")
          return
      }
      
      XCTAssertEqual(httpResponse.statusCode, 200)
      
      guard let data = data else {
          XCTFail("No data received")
          return
      }
      
      // Проверяем валидность JSON
      do {
          let json = try JSONSerialization.jsonObject(with: data)
          guard let dict = json as? [String: Any],
                let applinks = dict["applinks"] as? [String: Any] else {
              XCTFail("Invalid AASA structure")
              return
          }
          
          // Проверяем наличие обязательных полей
          XCTAssertNotNil(applinks["details"])
          
      } catch {
          XCTFail("JSON parsing failed: \(error)")
      }
      
      expectation.fulfill()
  }.resume()
  
  waitForExpectations(timeout: 10)
}

import SwiftUI
import Combine
 
// MARK: - App Entry Point
@main
struct ShopApp: App {
    @StateObject private var appCoordinator = AppCoordinator()
    
    var body: some Scene {
        WindowGroup {
            appCoordinator.rootView
                .onOpenURL { url in
                    Task {
                        await appCoordinator.handleUniversalLink(url)
                    }
                }
        }
    }
}
 
// MARK: - Coordinator Pattern Implementation
@MainActor
class AppCoordinator: ObservableObject {
    @Published var currentRoute: Route = .home
    @Published var navigationPath = NavigationPath()
    @Published var isLoading = false
    
    private let linkProcessor = UniversalLinkProcessor()
    private let contentCache = UniversalLinkContentCache()
    
    enum Route {
        case home
        case product(String)
        case category(String)
        case search(String)
        case user(String)
        case cart
    }
    
    var rootView: some View {
        NavigationStack(path: $navigationPath) {
            HomeView()
                .navigationDestination(for: Route.self) { route in
                    destinationView(for: route)
                }
        }
        .overlay {
            if isLoading {
                LoadingOverlay()
            }
        }
    }
    
    @ViewBuilder
    private func destinationView(for route: Route) -> some View {
        switch route {
        case .home:
            HomeView()
        case .product(let id):
            ProductView(productId: id)
        case .category(let id):
            CategoryView(categoryId: id)
        case .search(let query):
            SearchResultsView(query: query)
        case .user(let id):
            UserProfileView(userId: id)
        case .cart:
            CartView()
        }
    }
    
    func handleUniversalLink(_ url: URL) async {
        isLoading = true
        
        do {
            let route = try await linkProcessor.processLink(url)
            
            // Предзагружаем контент
            await contentCache.preloadContent(for: route)
            
            // Обновляем навигацию
            navigationPath.removeLast(navigationPath.count)
            navigationPath.append(route)
            currentRoute = route
            
            // Отправляем аналитику
            UniversalLinkAnalytics.trackLinkOpened(url)
            
        } catch {
            handleLinkError(error, url: url)
        }
        
        isLoading = false
    }
    
    private func handleLinkError(_ error: Error, url: URL) {
        UniversalLinkAnalytics.trackLinkError(url, error: error)
        
        // Показываем пользователю понятную ошибку
        if let linkError = error as? UniversalLinkError {
            showErrorAlert(linkError.localizedDescription)
        } else {
            showErrorAlert("Не удалось открыть ссылку")
        }
    }
    
    private func showErrorAlert(_ message: String) {
        // В реальном приложении здесь будет показ алерта
        print("Error: \(message)")
    }
}
 
// MARK: - Universal Link Processing
class UniversalLinkProcessor {
    func processLink(_ url: URL) async throws -> AppCoordinator.Route {
        let parser = UniversalLinkParser(url: url)
        
        // Валидируем домен
        guard url.host == "myshop.com" else {
            throw UniversalLinkError.invalidDomain
        }
        
        // Роутинг по путям
        if let productId = parser.extractID(from: "/product/*") {
            // Проверяем существование продукта
            try await validateProductExists(productId)
            return .product(productId)
            
        } else if let categoryId = parser.extractID(from: "/category/*") {
            try await validateCategoryExists(categoryId)
            return .category(categoryId)
            
        } else if parser.pathComponents.first == "search" {
            let query = parser.queryParameters["q"] ?? ""
            guard !query.isEmpty else {
                throw UniversalLinkError.invalidSearchQuery
            }
            return .search(query)
            
        } else if let userId = parser.extractID(from: "/user/*") {
            return .user(userId)
            
        } else if parser.pathComponents.first == "cart" {
            return .cart
            
        } else {
            return .home
        }
    }
    
    private func validateProductExists(_ productId: String) async throws {
        // Здесь была бы проверка через API
        if productId == "invalid" {
            throw UniversalLinkError.productNotFound(productId)
        }
    }
    
    private func validateCategoryExists(_ categoryId: String) async throws {
        // Проверка категории через API
        if categoryId == "invalid" {
            throw UniversalLinkError.categoryNotFound(categoryId)
        }
    }
}
 
// MARK: - Content Cache
actor UniversalLinkContentCache {
    private var cache: [String: CachedContent] = [:]
    
    struct CachedContent {
        let data: Any
        let cachedAt: Date
        let expiresAt: Date
    }
    
    func preloadContent(for route: AppCoordinator.Route) async {
        switch route {
        case .product(let id):
            await preloadProduct(id: id)
        case .category(let id):
            await preloadCategory(id: id)
        case .search(let query):
            await preloadSearchResults(query: query)
        default:
            break
        }
    }
    
    private func preloadProduct(id: String) async {
        let key = "product_\(id)"
        
        if let cached = cache[key], cached.expiresAt > Date() {
            return // Уже закэшировано
        }
        
        do {
            // Имитация загрузки данных
            try await Task.sleep(nanoseconds: 100_000_000) // 0.1 сек
            let productData = ProductData(id: id, name: "Product \(id)", price: 999.99)
            
            cache[key] = CachedContent(
                data: productData,
                cachedAt: Date(),
                expiresAt: Date().addingTimeInterval(300) // 5 минут
            )
        } catch {
            print("Failed to preload product \(id): \(error)")
        }
    }
    
    private func preloadCategory(id: String) async {
        // Аналогичная логика для категорий
    }
    
    private func preloadSearchResults(query: String) async {
        // Предзагрузка результатов поиска
    }
}
 
// MARK: - Views
struct HomeView: View {
    var body: some View {
        ScrollView {
            VStack(spacing: 20) {
                Text("Интернет-магазин")
                    .font(.largeTitle)
                    .fontWeight(.bold)
                
                LazyVGrid(columns: [
                    GridItem(.flexible()),
                    GridItem(.flexible())
                ], spacing: 16) {
                    ForEach(1...6, id: \.self) { index in
                        ProductCard(productId: "\(index)")
                    }
                }
            }
            .padding()
        }
        .navigationTitle("Главная")
    }
}
 
struct ProductView: View {
    let productId: String
    @State private var isLoading = true
    
    var body: some View {
        ScrollView {
            VStack(alignment: .leading, spacing: 16) {
                if isLoading {
                    ProgressView("Загрузка продукта...")
                        .frame(maxWidth: .infinity, maxHeight: .infinity)
                } else {
                    AsyncImage(url: URL(string: "https://via.placeholder.com/300x300")) { image in
                        image
                            .resizable()
                            .aspectRatio(contentMode: .fit)
                    } placeholder: {
                        Rectangle()
                            .fill(Color.gray.opacity(0.3))
                            .aspectRatio(1, contentMode: .fit)
                    }
                    .frame(height: 300)
                    
                    VStack(alignment: .leading, spacing: 8) {
                        Text("Продукт №\(productId)")
                            .font(.title2)
                            .fontWeight(.semibold)
                        
                        Text("999,99 ₽")
                            .font(.title3)
                            .foregroundColor(.green)
                        
                        Text("Описание продукта с подробными характеристиками и особенностями.")
                            .font(.body)
                            .foregroundColor(.secondary)
                    }
                    
                    Button("Добавить в корзину") {
                        // Действие добавления в корзину
                    }
                    .buttonStyle(.borderedProminent)
                }
            }
            .padding()
        }
        .navigationTitle("Продукт")
        .navigationBarTitleDisplayMode(.inline)
        .task {
            await loadProduct()
        }
    }
    
    private func loadProduct() async {
        try? await Task.sleep(nanoseconds: 500_000_000) // 0.5 сек имитация загрузки
        isLoading = false
    }
}
 
struct CategoryView: View {
    let categoryId: String
    
    var body: some View {
        ScrollView {
            LazyVGrid(columns: [
                GridItem(.flexible()),
                GridItem(.flexible())
            ], spacing: 16) {
                ForEach(1...10, id: \.self) { index in
                    ProductCard(productId: "cat_\(categoryId)_\(index)")
                }
            }
            .padding()
        }
        .navigationTitle("Категория \(categoryId)")
    }
}
 
struct SearchResultsView: View {
    let query: String
    
    var body: some View {
        List {
            ForEach(1...5, id: \.self) { index in
                HStack {
                    AsyncImage(url: URL(string: "https://via.placeholder.com/60x60")) { image in
                        image
                            .resizable()
                            .aspectRatio(contentMode: .fit)
                    } placeholder: {
                        Rectangle()
                            .fill(Color.gray.opacity(0.3))
                    }
                    .frame(width: 60, height: 60)
                    
                    VStack(alignment: .leading) {
                        Text("Результат поиска \(index)")
                            .font(.headline)
                        Text("Найдено по запросу: \(query)")
                            .font(.caption)
                            .foregroundColor(.secondary)
                    }
                    
                    Spacer()
                }
                .padding(.vertical, 4)
            }
        }
        .navigationTitle("Поиск: \(query)")
    }
}
 
struct UserProfileView: View {
    let userId: String
    
    var body: some View {
        VStack(spacing: 20) {
            Circle()
                .fill(Color.gray.opacity(0.3))
                .frame(width: 100, height: 100)
            
            Text("Пользователь \(userId)")
                .font(.title2)
                .fontWeight(.semibold)
            
            VStack(alignment: .leading, spacing: 12) {
                ProfileRow(title: "Email", value: "user\(userId)@example.com")
                ProfileRow(title: "Телефон", value: "+7 999 123-45-67")
                ProfileRow(title: "Город", value: "Москва")
            }
        }
        .padding()
        .navigationTitle("Профиль")
    }
}
 
struct CartView: View {
    var body: some View {
        VStack {
            Text("Корзина пуста")
                .font(.title3)
                .foregroundColor(.secondary)
            
            Button("Перейти к покупкам") {
                // Навигация к каталогу
            }
            .buttonStyle(.borderedProminent)
        }
        .navigationTitle("Корзина")
    }
}
 
// MARK: - Helper Views
struct ProductCard: View {
    let productId: String
    
    var body: some View {
        VStack {
            AsyncImage(url: URL(string: "https://via.placeholder.com/150x150")) { image in
                image
                    .resizable()
                    .aspectRatio(contentMode: .fit)
            } placeholder: {
                Rectangle()
                    .fill(Color.gray.opacity(0.3))
                    .aspectRatio(1, contentMode: .fit)
            }
            .frame(height: 120)
            
            Text("Продукт \(productId)")
                .font(.caption)
                .lineLimit(2)
        }
        .padding(8)
        .background(Color.gray.opacity(0.1))
        .cornerRadius(8)
    }
}
 
struct ProfileRow: View {
    let title: String
    let value: String
    
    var body: some View {
        HStack {
            Text(title)
                .foregroundColor(.secondary)
            Spacer()
            Text(value)
        }
    }
}
 
struct LoadingOverlay: View {
    var body: some View {
        Color.black.opacity(0.3)
            .ignoresSafeArea()
        
        VStack {
            ProgressView()
                .scaleEffect(1.5)
            Text("Загрузка...")
                .padding(.top)
        }
        .padding(20)
        .background(Color(.systemBackground))
        .cornerRadius(10)
    }
}
 
// MARK: - Data Models
struct ProductData {
    let id: String
    let name: String
    let price: Double
}
 
// MARK: - Analytics
class UniversalLinkAnalytics {
    static func trackLinkOpened(_ url: URL) {
        print("Universal Link opened: \(url.absoluteString)")
    }
    
    static func trackLinkError(_ url: URL, error: Error) {
        print("Universal Link error for \(url.absoluteString): \(error)")
    }
}