//
//  NetworkADSBDataSource.swift
//  LearnMapKit
//
//  Network-based ADSB data source implementation
//

import Foundation
import Combine

@MainActor
class NetworkADSBDataSource: ADSBDataSource {

    // MARK: - ADSBDataSource Protocol
    var dataStream: AnyPublisher<ADSBDataEvent, Never> {
        dataSubject.eraseToAnyPublisher()
    }

    var connectionState: AnyPublisher<DataSourceState, Never> {
        stateSubject.eraseToAnyPublisher()
    }

    private(set) var configuration: DataSourceConfiguration

    // MARK: - Private Properties
    private let dataSubject = PassthroughSubject<ADSBDataEvent, Never>()
    private let stateSubject = CurrentValueSubject<DataSourceState, Never>(.idle)

    private var netRunner: ADSBNetRunner?
    private var processingTask: Task<Void, Error>?
    private var timer: Timer?
    private var reconnectAttempts = 0

    // MARK: - Dependencies
    private let decoder: ADSBMessageDecoder
    private let tracker: AircraftTracker

    init(configuration: NetworkDataSourceConfiguration,
         decoder: ADSBMessageDecoder = DefaultADSBMessageDecoder(),
         tracker: AircraftTracker = DefaultAircraftTracker()) {
        self.configuration = configuration
        self.decoder = decoder
        self.tracker = tracker
    }

    // MARK: - ADSBDataSource Implementation
    func configure(with config: DataSourceConfiguration) async {
        guard let networkConfig = config as? NetworkDataSourceConfiguration else {
            stateSubject.send(.error("Invalid configuration type for NetworkADSBDataSource"))
            return
        }

        stateSubject.send(.configuring)
        self.configuration = networkConfig
        reconnectAttempts = 0
        stateSubject.send(.idle)
    }

    func start() async throws {
        guard let networkConfig = configuration as? NetworkDataSourceConfiguration else {
            throw ADSBDataSourceError.invalidConfiguration
        }

        stateSubject.send(.connecting)

        do {
            // Initialize network runner
            netRunner = ADSBNetRunner(address: networkConfig.hostname, port: networkConfig.port)

            // Start network processing
            try await startNetworkProcessing()

            stateSubject.send(.connected)
            reconnectAttempts = 0
        } catch {
            stateSubject.send(.error(error.localizedDescription))
            await handleConnectionError(error: error)
            throw error
        }
    }

    func stop() async {
        timer?.invalidate()
        timer = nil

        processingTask?.cancel()
        processingTask = nil

        await netRunner?.stop()
        netRunner = nil
        stateSubject.send(.disconnected)
        reconnectAttempts = 0
    }

    func reconnect() async throws {
        guard let networkConfig = configuration as? NetworkDataSourceConfiguration else {
            throw ADSBDataSourceError.invalidConfiguration
        }

        // Check if we should attempt reconnection
        guard reconnectAttempts < networkConfig.reconnectAttempts else {
            stateSubject.send(.error("Maximum reconnection attempts reached"))
            return
        }

        reconnectAttempts += 1
        await stop()

        // Wait before reconnecting
        try await Task.sleep(nanoseconds: UInt64(2_000_000_000 * reconnectAttempts)) // Exponential backoff

        try await start()
    }

    // MARK: - Private Methods
    private func startNetworkProcessing() async throws {
        guard let runner = netRunner else {
            throw ADSBDataSourceError.initializationFailed
        }

        // Start network connection
        processingTask = Task {
            do {
                try await runner.start()
                await startDataConsumption(runner: runner)
            } catch {
                await MainActor.run {
                    dataSubject.send(.error(error))
                    stateSubject.send(.error(error.localizedDescription))
                }
            }
        }
    }

    private func startDataConsumption(runner: ADSBNetRunner) async {
        await MainActor.run {
            timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
                self?.processDataBatch(from: runner)
            }
        }
    }

    private func processDataBatch(from runner: ADSBNetRunner) {
        guard runner.getCount() > 0 else { return }

        Task {
            for _ in 0..<runner.adsb_tag_stream.getCount() {
                let nextTag = runner.adsb_tag_stream.getNextTag()

                switch nextTag {
                case .ADSB_ICAO:
                    let icao = runner.adsb_tag_stream.getIcaoName()
                    await tracker.updateIdentification(address: icao.address, icaoName: icao.ICAOname)
                    dataSubject.send(.aircraftIdentification(address: icao.address, icaoName: icao.ICAOname))

                case .ADSB_LOCATION:
                    let location = runner.adsb_tag_stream.getLocation()
                    await tracker.updatePosition(address: location.address,
                                               latitude: location.lat,
                                               longitude: location.long)
                    dataSubject.send(.aircraftPosition(address: location.address,
                                                     latitude: location.lat,
                                                     longitude: location.long))

                case .ADSB_ALTITUDE:
                    let altitude = runner.adsb_tag_stream.getAltitude()
                    await tracker.updateAltitude(address: altitude.address, altitude: altitude.altitude)
                    dataSubject.send(.aircraftAltitude(address: altitude.address, altitude: altitude.altitude))

                case .EMPTY:
                    break
                }
            }
        }
    }

    private func handleConnectionError(error: Error) async {
        guard let networkConfig = configuration as? NetworkDataSourceConfiguration else { return }

        // Attempt automatic reconnection for network errors
        if reconnectAttempts < networkConfig.reconnectAttempts {
            Task {
                do {
                    try await reconnect()
                } catch {
                    // Final failure after all attempts
                    stateSubject.send(.error("Connection failed after \(networkConfig.reconnectAttempts) attempts"))
                }
            }
        }
    }
}

// MARK: - Extensions
extension ADSBNetRunner {
    func stop() async {
        // Add proper cleanup method to ADSBNetRunner
        timer?.invalidate()
        timer = nil
    }
}