import Foundation
import UserNotifications
import os.log

private let logger = Logger(subsystem: "com.albert.nasbackup", category: "BackupEngine")

@MainActor
final class BackupEngine: ObservableObject {
    static let shared = BackupEngine()

    @Published private(set) var job: BackupJob = BackupJob()

    private let photoService: PhotoLibraryProtocol
    private let transferFactory: (NASProtocol) -> any NASTransferProtocol
    private var activeTransfer: (any NASTransferProtocol)?
    private var isCancelled = false

    private init(
        photos: PhotoLibraryProtocol = PhotoLibraryService(),
        transferFactory: @escaping (NASProtocol) -> any NASTransferProtocol = { proto in
            switch proto {
            case .smb:  return SMBService()
            case .sftp: return SFTPService()
            }
        }
    ) {
        self.photoService = photos
        self.transferFactory = transferFactory
    }

    static func testInstance(
        transfer: any NASTransferProtocol,
        photos: PhotoLibraryProtocol
    ) -> BackupEngine {
        BackupEngine(photos: photos, transferFactory: { _ in transfer })
    }

    func run(
        connection: NASConnection,
        filter: BackupFilter,
        triggeredByLAN: Bool = false
    ) async throws -> BackupResult {
        isCancelled = false
        let startDate = Date()
        let store = ConnectionStore.shared
        let lan = LANMonitor.shared

        // Gate: block cellular unless user opted in (never block on LAN trigger)
        if !triggeredByLAN && lan.isOnCellular && !store.allowCellularBackup {
            throw BackupError.networkUnavailable
        }

        // Resolve effective host: use Tailscale when remote and tunnel is active
        let host = resolveHost(connection: connection, store: store, lan: lan)

        // 1. Fetch assets
        job.prepare()
        let assets = photoService.fetchAssets(filter: filter)

        // 2. Connect to NAS
        let transfer = transferFactory(connection.nasProtocol)

        try await transfer.connect(
            to: host,
            port: connection.port,
            username: connection.username,
            password: connection.password
        )
        activeTransfer = transfer

        defer {
            transfer.disconnect()
            activeTransfer = nil
        }

        // 3. Start job tracking
        job.start(totalFiles: assets.count, totalBytes: 0)

        var uploaded = 0
        var skipped = 0
        var failed = 0
        var totalBytes: Int64 = 0
        var speedTracker = SpeedTracker()
        var manifestEntries: [ManifestEntry] = []

        // 4. Transfer loop
        for asset in assets {
            if isCancelled { break }
            while case .paused = job.status {
                try await Task.sleep(nanoseconds: 500_000_000)
            }

            let remotePath = "\(connection.remotePath)/\(asset.filename)"

            if filter.newFilesOnly, (try? await transfer.fileExists(at: remotePath)) == true {
                job.fileCompleted(skipped: true)
                skipped += 1
                continue
            }

            do {
                let localURL = try await photoService.exportAsset(asset)
                defer { try? FileManager.default.removeItem(at: localURL) }

                let fileSize = (try? localURL.resourceValues(forKeys: [.fileSizeKey]).fileSize)
                    .flatMap { Int64($0) } ?? 0

                try await transfer.upload(localURL: localURL, remotePath: remotePath) { sent, total in
                    let speed = speedTracker.update(bytesSent: sent)
                    Task { @MainActor [weak self] in
                        self?.job.updateProgress(
                            fileName: asset.filename,
                            fileSize: total,
                            bytesTransferred: totalBytes + sent,
                            speed: speed
                        )
                    }
                }

                totalBytes += fileSize
                job.fileCompleted(skipped: false)
                uploaded += 1

                manifestEntries.append(ManifestEntry(
                    localIdentifier: asset.localIdentifier,
                    filename: asset.filename,
                    creationDate: asset.creationDate,
                    fileSize: fileSize,
                    remotePath: remotePath,
                    uploadedAt: Date()
                ))
            } catch {
                logger.error("Upload failed for \(asset.filename, privacy: .public): \(error.localizedDescription, privacy: .public)")
                job.fileFailed()
                failed += 1
            }
        }

        let duration = Date().timeIntervalSince(startDate)
        let result = BackupResult(
            uploadedCount: uploaded,
            skippedCount: skipped,
            failedCount: failed,
            duration: duration,
            totalBytes: totalBytes,
            date: startDate
        )

        job.finish(result: result)

        // Update manifest and dashboard status
        BackupStatusService.shared.refreshAfterBackup(entries: manifestEntries, connection: connection)

        let entry = BackupHistoryEntry(result: result, nasHost: host, triggeredByLAN: triggeredByLAN)
        store.appendHistoryEntry(entry)

        await sendCompletionNotification(result: result)

        return result
    }

    // Returns the Tailscale host when outside the trusted network and tunnel is up,
    // otherwise falls back to the saved local host.
    private func resolveHost(connection: NASConnection, store: ConnectionStore, lan: LANMonitor) -> String {
        let onTrustedLAN = store.trustedSSIDs.contains(lan.currentSSID ?? "")
        guard !onTrustedLAN,
              store.useTailscaleWhenRemote,
              !store.tailscaleHost.isEmpty,
              lan.isTailscaleActive else {
            return connection.host
        }
        return store.tailscaleHost
    }

    func cancel() {
        isCancelled = true
        job.cancel()
    }

    func pause()  { job.pause() }
    func resume() { job.resume() }

    private func sendCompletionNotification(result: BackupResult) async {
        let content = UNMutableNotificationContent()
        content.title = result.hasErrors ? "Backup completed with errors" : "Backup complete"
        content.body = "\(result.uploadedCount) uploaded · \(result.skippedCount) skipped · \(result.failedCount) errors"
        content.sound = .default
        let request = UNNotificationRequest(identifier: UUID().uuidString, content: content, trigger: nil)
        try? await UNUserNotificationCenter.current().add(request)
    }
}

private struct SpeedTracker {
    private var lastBytes: Int64 = 0
    private var lastTime: Date = Date()

    mutating func update(bytesSent: Int64) -> Double {
        let now = Date()
        let elapsed = now.timeIntervalSince(lastTime)
        guard elapsed > 0.1 else { return 0 }
        let speed = Double(bytesSent - lastBytes) / elapsed
        lastBytes = bytesSent
        lastTime = now
        return max(0, speed)
    }
}