// Pure data models
struct IPTVStream: Codable, Identifiable {
    let id: UUID
    let name: String
    let url: URL
    let category: StreamCategory
}

// Business logic protocols
protocol StreamService {
    func fetchStreams() async throws -> [IPTVStream]
    func validateStream(_ stream: IPTVStream) async throws -> Bool
}

struct StreamListView: View {
    @StateObject private var viewModel = StreamListViewModel()
    
    var body: some View {
        PlatformNavigationView {
            StreamGridView(streams: viewModel.streams)
                .searchable(text: $viewModel.searchText)
        }
        .task {
            await viewModel.loadStreams()
        }
    }
}

@MainActor
class StreamListViewModel: ObservableObject {
    @Published var streams: [IPTVStream] = []
    @Published var searchText: String = ""
    @Published var isLoading: Bool = false
    
    private let streamService: StreamService
    
    init(streamService: StreamService = StreamManager.shared) {
        self.streamService = streamService
    }
    
    func loadStreams() async {
        isLoading = true
        defer { isLoading = false }
        
        do {
            streams = try await streamService.fetchStreams()
        } catch {
            // Handle error
        }
    }
}

actor StreamManager {
    private var activeStreams: [UUID: AVPlayer] = [:]
    private var httpProxyServer: HTTPProxyServer?
    
    func loadStream(_ url: URL) async throws -> UUID {
        let streamId = UUID()
        let proxiedURL = try await setupProxy(for: url)
        let player = AVPlayer(url: proxiedURL)
        
        activeStreams[streamId] = player
        return streamId
    }
    
    nonisolated func getCurrentPlayer(for id: UUID) -> AVPlayer? {
        // Safe access to actor-isolated data
        return activeStreams[id]
    }
}

actor DownloadManager {
    private var activeDownloads: [UUID: URLSessionDownloadTask] = [:]
    private var downloadProgress: [UUID: Double] = [:]
    
    func startDownload(for item: DownloadableItem) async throws -> UUID {
        let downloadId = UUID()
        let task = URLSession.shared.downloadTask(with: item.downloadURL)
        
        activeDownloads[downloadId] = task
        task.resume()
        
        return downloadId
    }
    
    func getProgress(for downloadId: UUID) async -> Double {
        return downloadProgress[downloadId] ?? 0.0
    }
}

actor HTTPProxyServer {
    private var server: NWListener?
    private let port: NWEndpoint.Port
    
    func start() async throws {
        let parameters = NWParameters.tcp
        server = try NWListener(using: parameters, on: port)
        
        server?.newConnectionHandler = { [weak self] connection in
            await self?.handleConnection(connection)
        }
        
        server?.start(queue: .global())
    }
    
    private func handleConnection(_ connection: NWConnection) async {
        // Handle incoming HTTP requests
        // Proxy to IPTV endpoints with custom headers
    }
}

extension StreamManager {
    func resolveStreamURL(_ originalURL: URL) async throws -> URL {
        // 1. Check for redirects
        let resolvedURL = try await followRedirects(originalURL)
        
        // 2. Determine if proxy is needed
        if requiresProxy(resolvedURL) {
            return try await setupProxy(for: resolvedURL)
        }
        
        // 3. Return direct URL if no proxy needed
        return resolvedURL
    }
    
    private func requiresProxy(_ url: URL) -> Bool {
        // Logic to determine if URL needs HTTP proxy
        return url.scheme == "http" || hasCustomHeaders(url)
    }
}

struct iOSNavigationView: View {
    var body: some View {
        TabView {
            LiveTVView()
                .tabItem { Label("Live TV", systemImage: "tv") }
            
            MoviesView()
                .tabItem { Label("Movies", systemImage: "film") }
            
            DownloadsView()
                .tabItem { Label("Downloads", systemImage: "arrow.down.circle") }
        }
    }
}

struct macOSNavigationView: View {
    var body: some View {
        NavigationSplitView {
            SidebarView()
        } detail: {
            ContentView()
        }
        .toolbar {
            TouchBarControls()
        }
    }
}

struct tvOSNavigationView: View {
    @FocusState private var focusedTab: Tab?
    
    var body: some View {
        TabView(selection: $focusedTab) {
            LiveTVView()
                .tag(Tab.liveTV)
                .focused($focusedTab, equals: .liveTV)
        }
        .focusGuide(.automatic)
    }
}

extension NSTouchBarItem.Identifier {
    static let playPause = NSTouchBarItem.Identifier("com.mks.iptv.playPause")
    static let volume = NSTouchBarItem.Identifier("com.mks.iptv.volume")
    static let search = NSTouchBarItem.Identifier("com.mks.iptv.search")
}

class TouchBarManager: NSObject, NSTouchBarDelegate {
    @MainActor
    func makeTouchBar() -> NSTouchBar {
        let touchBar = NSTouchBar()
        touchBar.delegate = self
        touchBar.defaultItemIdentifiers = [.playPause, .volume, .search]
        return touchBar
    }
}

// Core Data for complex relationships
@Model
class DownloadedContent {
    @Attribute(.unique) var id: UUID
    var title: String
    var localPath: URL
    var originalURL: URL
    var downloadDate: Date
    var fileSize: Int64
}

// UserDefaults for simple settings
extension UserDefaults {
    @objc dynamic var preferredQuality: String {
        get { string(forKey: "preferredQuality") ?? "auto" }
        set { set(newValue, forKey: "preferredQuality") }
    }
}

// File system for downloaded content
actor FileManager {
    static let downloadsDirectory = FileManager.default
        .urls(for: .documentDirectory, in: .userDomainMask)
        .first!
        .appendingPathComponent("Downloads")
    
    func saveDownload(_ data: Data, filename: String) async throws -> URL {
        let fileURL = Self.downloadsDirectory.appendingPathComponent(filename)
        try data.write(to: fileURL)
        return fileURL
    }
}

// Centralized app state
@MainActor
class AppState: ObservableObject {
    @Published var selectedTab: Tab = .liveTV
    @Published var isDownloading: Bool = false
    @Published var currentlyPlaying: IPTVStream?
    
    // Computed properties
    var hasActiveDownloads: Bool {
        // Logic to check for active downloads
    }
}

// View models subscribe to app state
@MainActor
class ContentViewModel: ObservableObject {
    @Published var content: [ContentItem] = []
    
    private let appState: AppState
    private var cancellables = Set<AnyCancellable>()
    
    init(appState: AppState) {
        self.appState = appState
        
        // React to app state changes
        appState.$selectedTab
            .sink { [weak self] tab in
                Task { await self?.loadContent(for: tab) }
            }
            .store(in: &cancellables)
    }
}

// Service protocols for dependency injection
protocol StreamServiceProtocol {
    func fetchStreams() async throws -> [IPTVStream]
}

// Mock implementations for testing
class MockStreamService: StreamServiceProtocol {
    var mockStreams: [IPTVStream] = []
    var shouldThrowError = false
    
    func fetchStreams() async throws -> [IPTVStream] {
        if shouldThrowError {
            throw StreamError.networkError
        }
        return mockStreams
    }
}

// Testable view models
@MainActor
class StreamListViewModel: ObservableObject {
    private let streamService: StreamServiceProtocol
    
    init(streamService: StreamServiceProtocol = StreamManager.shared) {
        self.streamService = streamService
    }
}

#if os(iOS)
    // iOS-specific implementations
    import UIKit
    typealias PlatformViewController = UIViewController
#elseif os(macOS)
    // macOS-specific implementations
    import AppKit
    typealias PlatformViewController = NSViewController
#elseif os(tvOS)
    // tvOS-specific implementations
    import TVUIKit
    typealias PlatformViewController = UIViewController
#endif

// Shared interface
protocol PlatformAdaptable {
    func configureForPlatform()
}

@MainActor
class ServiceContainer: ObservableObject {
    static let shared = ServiceContainer()
    
    lazy var streamManager = StreamManager()
    lazy var downloadManager = DownloadManager()
    lazy var httpServer = HTTPStreamServer()
    
    private init() {}
    
    // Factory methods for testing
    func makeStreamService() -> StreamServiceProtocol {
        #if DEBUG
        if ProcessInfo.processInfo.environment["TESTING"] == "1" {
            return MockStreamService()
        }
        #endif
        return streamManager
    }
}