override func viewDidLoad() {
    super.viewDidLoad()
    setupTableView()
    generateFeedData()
    startVideoAdPreloading() // Start preloading video ad immediately
}

private func startVideoAdPreloading() {
    // Find video ad and start preloading immediately
    for (index, item) in feedItems.enumerated() {
        if case .videoAd(let vastURL) = item {
            let indexPath = IndexPath(row: index, section: 0)
            preloadVideoAd(at: indexPath, vastURL: vastURL)
            break
        }
    }

private func preloadVideoAd(at indexPath: IndexPath, vastURL: String) {
    let wrapper = CriteoVideoAdWrapper(vastURL: "https://raw.githubusercontent.com/criteo/interview-ios/refs/heads/main/server/sample_vast_app.xml", identifier: nil,
        configuration: .init(
            autoLoad: false,
            startsMuted: true, // Video starts muted
            backgroundColor: .white,
            cornerRadius: 8
        )
    )

    // Enable logging for this wrapper instance (same as single video controller)
    wrapper.enableLogs = [.network, .beacon]

    // Set up callbacks
    setupWrapperCallbacks(wrapper, for: indexPath)

    // Start preloading
    wrapper.preloadAssets()

    // Store wrapper
    videoAdWrappers[indexPath] = wrapper
}

/// Handles play/pause logic based on video cell visibility in the table view.
private func handleVideoVisibility(at indexPath: IndexPath, isVisible: Bool) {
    guard let wrapper = videoAdWrappers[indexPath] else {
        CriteoLogger.warning("⚠️ No wrapper found for \(indexPath)", category: .video)
        return
    }
    if isVisible {
        wrapper.resumePlayback()
    } else {
        wrapper.pauseAndDetach()
    }
}

override func tableView(_ tableView: UITableView, willDisplay cell: UITableViewCell, forRowAt indexPath: IndexPath) {
    // Handle video visibility when cell becomes visible
    if case .videoAd = feedItems[indexPath.row], videoAdWrappers[indexPath] != nil {
        handleVideoVisibility(at: indexPath, isVisible: true)
    }
}

override func tableView(_ tableView: UITableView, didEndDisplaying cell: UITableViewCell, forRowAt indexPath: IndexPath) {
    // Handle video visibility when cell goes out of view
    if case .videoAd = feedItems[indexPath.row], videoAdWrappers[indexPath] != nil {
        handleVideoVisibility(at: indexPath, isVisible: false)
    }
}

deinit {
    // Clean up all video wrappers
    videoAdWrappers.removeAll()
  }

// SwiftUI list using a shared wrapper from a view model; ad row inserted at index 12.
struct CriteoAdSwiftUIListView_Sample: View {
    @StateObject private var viewModel = VideoAdViewModel(vastURL: "https://raw.githubusercontent.com/criteo/interview-ios/refs/heads/main/server/sample_vast_app.xml")

    var body: some View {
        NavigationView {
            List(0..<20, id: \.self) { index in
                if index == 12 { // Video ad at position 12
                    VideoAdCell(wrapper: viewModel.wrapper)
                        .frame(height: 200)
                        .listRowInsets(EdgeInsets())

        // Preload once on appear; broadcast a cleanup notification when the view disappears.
        .onAppear {
            // Start preloading immediately when view appears (like UIKit viewDidLoad)
            viewModel.startVideoPreloading()
        }
        .onDisappear {
            // Cleanup when entire view disappears (navigating back)
            NotificationCenter.default.post(name: NSNotification.Name("SwiftUIViewDisappeared"), object: nil)
        }

// Ad cell: embeds the wrapper via a UIViewRepresentable and posts visibility notifications.
struct VideoAdCell: View {
    let wrapper: CriteoVideoAdWrapper

    var body: some View {
        ZStack {
            // Simple video player - use preloaded shared wrapper
            CriteoVideoAdSwiftUIView(wrapper: wrapper)
        }
        .onAppear {
            // Signal that cell appeared - start playing if loaded
            NotificationCenter.default.post(name: NSNotification.Name("VideoCellAppeared"), object: nil)
        }
        .onDisappear {
            // Signal that cell disappeared (don't cleanup yet, just pause)
            NotificationCenter.default.post(name: NSNotification.Name("VideoCellDisappeared"), object: nil)
        }
    }
}
                  
// UIViewRepresentable: returns the wrapper and hooks up callbacks through a coordinator.
struct CriteoVideoAdSwiftUIView: UIViewRepresentable {
    let wrapper: CriteoVideoAdWrapper

    func makeUIView(context: Context) -> CriteoVideoAdWrapper {
        context.coordinator.wrapper = wrapper
        setupWrapperCallbacks(wrapper, coordinator: context.coordinator)
        return wrapper
    }

// Coordinator: subscribes to notifications for appear/disappear and reacts.
class Coordinator {
    var wrapper: CriteoVideoAdWrapper?

    init() {
        // Listen for visibility notifications
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(handleCellAppeared),
            name: NSNotification.Name("VideoCellAppeared"),
            object: nil
        )

        NotificationCenter.default.addObserver(
            self,
            selector: #selector(handleCellDisappeared),
            name: NSNotification.Name("VideoCellDisappeared"),
            object: nil
        )

// On cell appear: resume playback via the wrapper.
@objc private func handleCellAppeared() {
    CriteoLogger.debug("Video cell appeared - resuming playback", category: .video)
    if let wrapper = wrapper {
        CriteoLogger.debug("Wrapper exists, attempting to resume playback...", category: .video)
        // Always resume when cell appears (mirror UIKit behavior)
        wrapper.resumePlayback()
        CriteoLogger.debug("resumePlayback() called", category: .video)
    } else {
        CriteoLogger.error("No wrapper available for resume", category: .video)
    }
}

// On cell disappear: pause and detach to free UI resources.
@objc private func handleCellDisappeared() {
    CriteoLogger.debug("Video cell disappeared - pausing and detaching", category: .video)
    if let wrapper = wrapper {
        // This properly cleans up resources without marking as user-paused
        wrapper.pauseAndDetach()
    }
}

// On view disappear: perform full cleanup and clear callbacks.
@objc private func handleViewDisappeared() {
    CriteoLogger.debug("View disappeared - full cleanup", category: .video)
    if let wrapper = wrapper {
        // Stop playback and clean up
        wrapper.pauseAndDetach()
        wrapper.removeFromSuperview()

        // Clear all callbacks to prevent retain cycles
        wrapper.onVideoLoaded = nil
        wrapper.onVideoError = nil
        wrapper.onVideoStarted = nil
        wrapper.onVideoPaused = nil
        wrapper.onUserPauseStateChanged = nil
        wrapper.onPlaybackProgress = nil
    }
    wrapper = nil
}

// View model: owns the shared wrapper and preloads once on demand.
final class VideoAdViewModel: ObservableObject {
    let wrapper: CriteoVideoAdWrapper
    private var hasStartedPreloading = false

    init(vastURL: String) {
        // Create a single shared wrapper without persistence
        let config = CriteoVideoAdConfiguration(
            autoLoad: false,
            startsMuted: true,
            backgroundColor: .white,
            cornerRadius: 8
        )
        self.wrapper = CriteoVideoAdWrapper(
            vastURL: vastURL,
            identifier: nil,
            configuration: config
        )
    }
}