//
//  DependencyContainer.swift
//  LearnMapKit
//
//  Dependency injection container for the app
//

import Foundation

@MainActor
class DependencyContainer {

    // MARK: - Singletons
    lazy var configurationManager: ConfigurationManager = DefaultConfigurationManager()
    lazy var aircraftRepository: AircraftRepository = DefaultAircraftRepository(tracker: aircraftTracker)
    lazy var dataSourceFactory: DataSourceFactory = DefaultDataSourceFactory()
    lazy var aircraftTracker: AircraftTracker = DefaultAircraftTracker()

    // MARK: - ViewModels
    func makeAircraftTrackingViewModel() -> AircraftTrackingViewModel {
        AircraftTrackingViewModel(
            configurationManager: configurationManager,
            aircraftRepository: aircraftRepository,
            dataSourceFactory: dataSourceFactory
        )
    }

    func makeSettingsViewModel() -> SettingsViewModel {
        SettingsViewModel(configurationManager: configurationManager)
    }

    // MARK: - Data Sources (Factory Methods)
    func makeFileDataSource(configuration: FileDataSourceConfiguration) -> FileADSBDataSource {
        FileADSBDataSource(
            configuration: configuration,
            tracker: aircraftTracker
        )
    }

    func makeNetworkDataSource(configuration: NetworkDataSourceConfiguration) -> NetworkADSBDataSource {
        NetworkADSBDataSource(
            configuration: configuration,
            tracker: aircraftTracker
        )
    }
}

// MARK: - Settings ViewModel
@MainActor
class SettingsViewModel: ObservableObject {
    @Published var configuration: AppConfiguration
    @Published var hasUnsavedChanges: Bool = false
    @Published var validationErrors: [String] = []
    @Published var isValid: Bool = true

    private let configurationManager: ConfigurationManager
    private var cancellables = Set<AnyCancellable>()

    init(configurationManager: ConfigurationManager) {
        self.configurationManager = configurationManager
        self.configuration = configurationManager.getCurrentConfiguration()

        setupBindings()
    }

    func saveSettings() async {
        let validation = configurationManager.validateConfiguration(configuration)
        validationErrors = validation.errors
        isValid = validation.isValid

        if validation.isValid {
            do {
                await configurationManager.updateConfiguration(configuration)
                try await configurationManager.saveConfiguration()
            } catch {
                validationErrors = ["Failed to save: \(error.localizedDescription)"]
                isValid = false
            }
        }
    }

    func resetToDefaults() async {
        configuration = AppConfiguration.default
        await configurationManager.resetToDefaults()
    }

    func validateCurrentSettings() {
        let validation = configurationManager.validateConfiguration(configuration)
        validationErrors = validation.errors
        isValid = validation.isValid
    }

    private func setupBindings() {
        configurationManager.hasUnsavedChanges
            .receive(on: DispatchQueue.main)
            .assign(to: &$hasUnsavedChanges)

        $configuration
            .removeDuplicates()
            .sink { [weak self] _ in
                self?.validateCurrentSettings()
            }
            .store(in: &cancellables)
    }
}

// MARK: - Missing Protocol Implementations (Stubs)
protocol ADSBMessageDecoder {
    func decode(_ message: String) -> ADSBDataEvent?
}

class DefaultADSBMessageDecoder: ADSBMessageDecoder {
    func decode(_ message: String) -> ADSBDataEvent? {
        // This would contain the actual decoding logic
        // For now, return nil as a stub
        return nil
    }
}