#if PHONE_LINK
import AppKit
import CloudKit
import Combine

// MARK: - iPhone plan, step 8: Mochi leaves for the iPhone
//
// When the Mac locks while an agent is working, Mochi moves to the iPhone's
// Dynamic Island and Lock Screen (a Live Activity), and comes back when the
// Mac unlocks. Live Activity pushes need the APNs key, which can't ship in the
// app, so they go through the user's relay (relay/ in this repo, a stateless
// Cloudflare Worker). The iPhone's push tokens come from iCloud (`PhoneToken`
// records, written by LiveActivityLink on the iPhone).
//
// Sent to the relay: the iPhone's token and MochiActivityState (agent, state,
// counts). Never a project name, a step, a command or a path.
// Runs only while the Mac is locked with an agent going: lock notifications
// and AppState changes, no timer at rest.

@MainActor
final class LiveActivityRelay {
    static let shared = LiveActivityRelay()

    static let enabledKey = "iPhoneLiveActivityEnabled"
    /// Overrides the relay address (defaults write fr.louisraille.NotchBuddy phoneRelayURL <url>).
    static let relayURLKey = "phoneRelayURL"
    /// The deployed relay (relay/README.md).
    static let defaultRelayURL = "https://coucou-relay.raillelouis.workers.dev"

    static var isEnabled: Bool { UserDefaults.standard.bool(forKey: enabledKey) }

    private struct Phone {
        var env: String
        var startToken: String
        var updateToken: String
        var updatedAt: Date
    }

    private var database: CKDatabase { CKContainer(identifier: CloudProbe.containerID).privateCloudDatabase }
    private var observers: [NSObjectProtocol] = []
    private var cancellable: AnyCancellable?
    private var phones: [String: Phone] = [:]
    private var changeToken: CKServerChangeToken?

    private var locked = false
    private var latest: MochiActivityState?
    /// Set while a Live Activity runs on the iPhone(s).
    private var startedAt: Date?
    /// Sent with every push of an activity, so the iPhone shows the time since.
    private var activitySince: Int?
    /// The startedAt whose start push actually went out.
    private var startSent: Date?
    private var sent: MochiActivityState?
    private var sending = false
    private var retryTask: Task<Void, Never>?
    private var retries = 0
    /// The phase a start was sent again for, so it is only tried once each.
    private var restartedFor: String?
    /// A start waiting to see if the Mac stays locked, and an end waiting to
    /// see if it stays unlocked: iOS allows only so many starts an hour, so a
    /// quick lock and unlock doesn't spend one.
    private var lockTask: Task<Void, Never>?
    private var unlockTask: Task<Void, Never>?
    /// Ends the activity 10 minutes after the agents are done, if nothing restarts.
    private var doneTask: Task<Void, Never>?

    private var relayURL: URL? {
        let value = UserDefaults.standard.string(forKey: Self.relayURLKey) ?? Self.defaultRelayURL
        return value.isEmpty ? nil : URL(string: value)?.appendingPathComponent("v1/live-activity")
    }

    // MARK: Lifecycle

    func setEnabled(_ on: Bool) {
        UserDefaults.standard.set(on, forKey: Self.enabledKey)
        if on && CloudProbe.isEnabled { start() } else { stop() }
    }

    func startIfEnabled() {
        if Self.isEnabled { start() }
    }

    func start() {
        guard cancellable == nil else { return }
        let center = DistributedNotificationCenter.default()
        observers = [
            center.addObserver(forName: NSNotification.Name("com.apple.screenIsLocked"), object: nil, queue: .main) { [weak self] _ in
                MainActor.assumeIsolated { self?.lockChanged(true) }
            },
            center.addObserver(forName: NSNotification.Name("com.apple.screenIsUnlocked"), object: nil, queue: .main) { [weak self] _ in
                MainActor.assumeIsolated { self?.lockChanged(false) }
            },
        ]
        let state = AppState.shared
        cancellable = state.$tasks
            .combineLatest(state.$pendingApproval)
            .map { tasks, approval in Self.leadState(tasks: tasks, approval: approval) }
            .removeDuplicates()
            .debounce(for: .seconds(1), scheduler: RunLoop.main)
            .sink { [weak self] lead in
                MainActor.assumeIsolated { self?.stateChanged(lead) }
            }
        log(relayURL == nil ? "on, but no relay address yet (relay/README.md)" : "on")
    }

    func stop() {
        guard cancellable != nil else { return }
        observers.forEach { DistributedNotificationCenter.default().removeObserver($0) }
        observers = []
        cancellable = nil
        lockTask?.cancel(); lockTask = nil
        unlockTask?.cancel(); unlockTask = nil
        if startedAt != nil { finish(dismissAfter: 0) }
        log("off")
    }

    // MARK: Events

    private func lockChanged(_ isLocked: Bool) {
        locked = isLocked
        if isLocked {
            log("Mac locked")
            unlockTask?.cancel(); unlockTask = nil
            if startedAt != nil {
                // Locked again before the activity left: it carries on.
                flush()
                return
            }
            if let latest, latest.isActive { beginSoon(latest) }
        } else {
            log("Mac unlocked")
            lockTask?.cancel(); lockTask = nil
            guard startedAt != nil else { return }
            // Mochi comes back to the notch, unless the Mac locks again within 30 s.
            unlockTask = Task {
                try? await Task.sleep(for: .seconds(30))
                guard !Task.isCancelled, !locked else { return }
                unlockTask = nil
                finish(dismissAfter: 0)
            }
        }
    }

    /// Starts right away when an agent needs you; otherwise once the Mac has
    /// stayed locked for 20 s.
    private func beginSoon(_ state: MochiActivityState) {
        if state.tone == "waiting" || state.tone == "question" {
            lockTask?.cancel(); lockTask = nil
            begin(state)
            return
        }
        guard lockTask == nil else { return }
        lockTask = Task {
            try? await Task.sleep(for: .seconds(20))
            lockTask = nil
            guard !Task.isCancelled, locked, startedAt == nil, let latest, latest.isActive else { return }
            begin(latest)
        }
    }

    private func stateChanged(_ lead: MochiActivityState?) {
        if lead?.tone != latest?.tone, let lead { log("phase: \(lead.agent) \(lead.statusText)\(locked ? "" : " (Mac unlocked, stays on the Mac)")") }
        latest = lead
        guard locked else { return }
        if startedAt == nil {
            if let lead, lead.isActive { beginSoon(lead) }
            return
        }
        if let lead, lead.isActive {
            // Back to work: the same activity carries on.
            doneTask?.cancel(); doneTask = nil
            flush()
        } else if doneTask == nil {
            // Nothing going any more: show "done" for 10 minutes, then leave,
            // unless an agent starts again meanwhile.
            if lead != nil { flush() }
            doneTask = Task {
                try? await Task.sleep(for: .seconds(10 * 60))
                guard !Task.isCancelled else { return }
                doneTask = nil
                finish(dismissAfter: 0)
            }
        }
    }

    // MARK: Sending

    private func begin(_ state: MochiActivityState) {
        let start = Date()
        activitySince = Int(start.timeIntervalSince1970)
        startedAt = start
        sent = state
        retries = 0
        Task {
            await refreshPhones()
            // The Mac unlocked meanwhile: don't leave.
            guard startedAt == start, locked else { return }
            startSent = start
            let targets = phones.filter { !$0.value.startToken.isEmpty }
            if targets.isEmpty {
                log("no iPhone token yet: open Coucou on the iPhone once, with Live Activities allowed")
                return
            }
            var reached = 0
            for (id, phone) in targets {
                if await post(event: "start", token: phone.startToken, env: phone.env, state: state, phoneID: id) {
                    reached += 1
                }
            }
            if reached > 0 {
                log("Mochi left for the iPhone (\(state.agent), \(state.statusText))")
            } else {
                log("Mochi couldn't reach the iPhone (see the relay line above)")
            }
        }
    }

    /// Sends the latest state if it changed, one request at a time.
    private func flush() {
        guard !sending, let startedAt, let state = latest, state != sent else { return }
        sending = true
        Task {
            let targets = await updateTargets(since: startedAt)
            guard !targets.isEmpty else {
                sending = false
                // No update token: iOS didn't bring the activity up (it can hold
                // back starts after many in a row). When an agent needs you, start
                // it again with that state, once per request.
                let key = state.approval ?? "\(state.tone)|\(state.statusText)"
                if state.tone == "waiting" || state.tone == "question", restartedFor != key,
                   let sentAt = startSent, Date().timeIntervalSince(sentAt) > 15 {
                    restartedFor = key
                    log("the Live Activity isn't on the iPhone: starting it again for \(state.statusText)")
                    begin(state)
                    return
                }
                log("update \(state.tone) waits: no update token from the iPhone yet")
                scheduleRetry()
                return
            }
            retries = 0
            let urgent = state.tone == "waiting" || state.tone == "question"
            for (id, phone) in targets {
                let ok = await post(event: "update", token: phone.updateToken, env: phone.env, state: state,
                                    urgent: urgent, phoneID: id)
                // Every change of phase is logged; step counts only when they fail.
                if ok && (urgent || sent?.tone != state.tone) {
                    log("update sent: \(state.agent) \(state.statusText)\(state.approval == nil ? "" : " (with Allow / Deny)")")
                }
            }
            sent = state
            sending = false
            // Something changed while this one was on its way.
            if latest != sent { flush() }
        }
    }

    private func finish(dismissAfter: Int) {
        guard let startedAt else { return }
        self.startedAt = nil
        retryTask?.cancel(); retryTask = nil
        doneTask?.cancel(); doneTask = nil
        let last = latest ?? sent ?? .placeholder
        sent = nil
        guard startSent == startedAt else {
            // The start never went out: nothing to end on the iPhone.
            log("Mochi is back on the Mac")
            return
        }
        Task {
            // A start sent a moment ago: its update token is still on its way.
            var targets = await updateTargets(since: startedAt)
            for _ in 0..<6 where targets.isEmpty {
                try? await Task.sleep(for: .seconds(3))
                targets = await updateTargets(since: startedAt)
            }
            if targets.isEmpty { log("can't end the Live Activity: no update token from the iPhone") }
            for (id, phone) in targets {
                await post(event: "end", token: phone.updateToken, env: phone.env, state: last,
                           dismissAfter: dismissAfter, phoneID: id)
            }
            log(dismissAfter == 0 ? "Mochi is back on the Mac" : "agents done, the iPhone shows it for \(dismissAfter / 60) min")
        }
    }

    /// The update token arrives a moment after the start (the iPhone gets it
    /// from iOS, then writes it to iCloud): retry a few times.
    private func scheduleRetry() {
        guard retryTask == nil, retries < 10 else { return }
        retries += 1
        retryTask = Task {
            try? await Task.sleep(for: .seconds(3))
            retryTask = nil
            guard !Task.isCancelled else { return }
            flush()
        }
    }

    private func updateTargets(since date: Date) async -> [String: Phone] {
        func fresh() -> [String: Phone] {
            phones.filter { !$0.value.updateToken.isEmpty && $0.value.updatedAt >= date.addingTimeInterval(-2) }
        }
        if fresh().isEmpty { await refreshPhones() }
        return fresh()
    }

    /// Sends one push through the relay. Returns true when Apple accepted it.
    @discardableResult
    private func post(event: String, token: String, env: String, state: MochiActivityState,
                      urgent: Bool = false, dismissAfter: Int? = nil, phoneID: String) async -> Bool {
        guard let url = relayURL else { return false }
        var state = state
        if state.since == nil { state.since = activitySince }
        var body: [String: Any] = ["token": token, "env": env, "event": event, "urgent": urgent]
        if let dismissAfter { body["dismissAfter"] = dismissAfter }
        guard let stateData = try? JSONEncoder().encode(state),
              let stateObject = try? JSONSerialization.jsonObject(with: stateData) else { return false }
        body["state"] = stateObject
        var request = URLRequest(url: url, timeoutInterval: 10)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.httpBody = try? JSONSerialization.data(withJSONObject: body)
        do {
            let (data, response) = try await URLSession.shared.data(for: request)
            let status = (response as? HTTPURLResponse)?.statusCode ?? 0
            if status == 200 { return true }
            let reason = String(data: data, encoding: .utf8) ?? ""
            if reason.contains("BadDeviceToken") {
                // A token only works on one of Apple's two push servers (sandbox for
                // builds run from Xcode, production for TestFlight and the App Store).
                // Try the other one once and keep it if it works.
                let other = env == "production" ? "development" : "production"
                if phones[phoneID]?.env == env {
                    phones[phoneID]?.env = other
                    log("relay \(event): token not valid on \(env), trying \(other)")
                    return await post(event: event, token: token, env: other, state: state,
                                      urgent: urgent, dismissAfter: dismissAfter, phoneID: phoneID)
                }
            }
            if status == 410 {
                // That token is gone (activity ended on the iPhone, app deleted…).
                if event == "start" { phones[phoneID]?.startToken = "" } else { phones[phoneID]?.updateToken = "" }
            }
            log("relay \(event) on \(env) → \(status) \(reason.prefix(120))")
        } catch {
            log("relay \(event) failed: \(error.localizedDescription)")
        }
        return false
    }

    // MARK: Tokens

    private func refreshPhones() async {
        do {
            var more = true
            while more {
                let changes = try await database.recordZoneChanges(inZoneWith: CloudProbe.zoneID, since: changeToken)
                for (id, result) in changes.modificationResultsByID {
                    guard case .success(let mod) = result, mod.record.recordType == "PhoneToken" else { continue }
                    let record = mod.record
                    phones[id.recordName] = Phone(
                        env: record["env"] as? String ?? "production",
                        startToken: record.encryptedValues["startToken"] as? String ?? "",
                        updateToken: record.encryptedValues["updateToken"] as? String ?? "",
                        updatedAt: record["updatedAt"] as? Date ?? .distantPast)
                }
                for deletion in changes.deletions where deletion.recordType == "PhoneToken" {
                    phones[deletion.recordID.recordName] = nil
                }
                changeToken = changes.changeToken
                more = changes.moreComing
            }
        } catch let error as CKError where error.code == .changeTokenExpired {
            changeToken = nil
        } catch {
            log("token fetch failed: \(error.localizedDescription)")
        }
    }

    // MARK: State

    /// The most urgent session, as the iPhone's Live Activity shows it.
    nonisolated static func leadState(tasks: [AgentTask], approval: ApprovalInfo?) -> MochiActivityState? {
        let ranked = tasks
            .filter { $0.source != .n8n && PillCatalog.isSession($0.id) }   // same sessions as SessionPublisher
            .map { task -> (AgentTask, Int) in
                let urgency = MochiActivityState.urgency(state: task.state,
                                                         waitingForOK: approval?.pillId == task.id,
                                                         hasQuestion: task.state == .question)
                return (task, urgency)
            }
        guard let lead = ranked.min(by: { $0.1 < $1.1 }) else { return nil }
        let (task, urgency) = lead
        let others = ranked.filter { $0.0.id != task.id && $0.1 <= 3 }.count
        return MochiActivityState(
            pillId: task.id,
            agent: PillCatalog.definition(for: task.id)?.name ?? "Agent",
            color: task.color,
            state: (urgency == 0 ? BotState.approval : task.state).rawValue,
            statusText: MochiActivityState.statusText(state: task.state, urgency: urgency,
                                                      stepIndex: task.stepIndex, stepCount: task.steps.count),
            tone: MochiActivityState.tone(urgency: urgency),
            stepIndex: max(0, task.stepIndex),
            stepCount: task.steps.count,
            others: others,
            approval: approval?.pillId == task.id ? approval.map(ApprovalRelay.fingerprint) : nil)
    }

    private func log(_ message: String) {
        CloudProbe.shared.log("[live] \(message)")
    }
}
#endif