loopfollow/LoopFollow/Remote/PushNotificationManager.swift

//
//  PushNotificationManager.swift
//  LoopFollow
//
//  Created by Jonas Björkert on 2024-08-27.
//  Copyright © 2024 Jon Fawcett. All rights reserved.
//

import Foundation
import SwiftJWT
import HealthKit

struct APNsJWTClaims: Claims {
    let iss: String
    let iat: Date
}

class PushNotificationManager {
    private var deviceToken: String
    private var sharedSecret: String
    private var productionEnvironment: Bool
    private var token: String
    private var teamId: String
    private var keyId: String
    private var user: String
    private var bundleId: String

    init() {
        self.deviceToken = Storage.shared.deviceToken.value
        self.sharedSecret = Storage.shared.sharedSecret.value
        self.productionEnvironment = Storage.shared.productionEnvironment.value
        self.token = Storage.shared.token.value
        self.teamId = Storage.shared.teamId.value
        self.keyId = Storage.shared.keyId.value
        self.user = Storage.shared.user.value
        self.bundleId = Storage.shared.bundleId.value
    }

    func sendBolusPushNotification(commandType: String, bolusAmount: HKQuantity, completion: @escaping (Bool, String?) -> Void) {
        let bolusAmount = Decimal(bolusAmount.doubleValue(for: .internationalUnit()))

        let message = PushMessage(
            user: user,
            commandType: commandType,
            bolusAmount: bolusAmount,
            sharedSecret: sharedSecret,
            timestamp: Date().timeIntervalSince1970
        )

        sendPushNotification(message: message, completion: completion)
    }

    func sendTempTargetPushNotification(target: HKQuantity, duration: HKQuantity, completion: @escaping (Bool, String?) -> Void) {
        let targetValue = Int(target.doubleValue(for: HKUnit.milligramsPerDeciliter))
        let durationValue = Int(duration.doubleValue(for: HKUnit.minute()))

        let message = PushMessage(
            user: user,
            commandType: "temp_target",
            bolusAmount: nil,
            target: targetValue,
            duration: durationValue,
            sharedSecret: sharedSecret,
            timestamp: Date().timeIntervalSince1970
        )

        sendPushNotification(message: message, completion: completion)
    }

    func sendCancelTempTargetPushNotification(completion: @escaping (Bool, String?) -> Void) {
        let message = PushMessage(
            user: user,
            commandType: "cancel_temp_target",
            sharedSecret: sharedSecret,
            timestamp: Date().timeIntervalSince1970
        )

        sendPushNotification(message: message, completion: completion)
    }

    func sendMealPushNotification(carbs: HKQuantity, protein: HKQuantity, fat: HKQuantity, completion: @escaping (Bool, String?) -> Void) {
        let carbsValue = Int(carbs.doubleValue(for: .gram()))
        let proteinValue = Int(protein.doubleValue(for: .gram()))
        let fatValue = Int(fat.doubleValue(for: .gram()))

        let message = PushMessage(
            user: user,
            commandType: "meal",
            carbs: carbsValue,
            protein: proteinValue,
            fat: fatValue,
            sharedSecret: sharedSecret,
            timestamp: Date().timeIntervalSince1970
        )

        sendPushNotification(message: message, completion: completion)
    }

    private func sendPushNotification(message: PushMessage, completion: @escaping (Bool, String?) -> Void) {
        print("Push message to send: \(message)")

        // Validate that all required fields are filled
        var missingFields = [String]()
        if deviceToken.isEmpty { missingFields.append("deviceToken") }
        if sharedSecret.isEmpty { missingFields.append("sharedSecret") }
        if token.isEmpty { missingFields.append("token") }
        if teamId.isEmpty { missingFields.append("teamId") }
        if keyId.isEmpty { missingFields.append("keyId") }
        if user.isEmpty { missingFields.append("user") }
        if bundleId.isEmpty { missingFields.append("bundleId") }

        if !missingFields.isEmpty {
            let errorMessage = "Missing required fields: \(missingFields.joined(separator: ", "))"
            print(errorMessage)
            completion(false, errorMessage)
            return
        }

        guard let url = constructAPNsURL() else {
            let errorMessage = "Failed to construct APNs URL"
            print(errorMessage)
            completion(false, errorMessage)
            return
        }

        guard let jwt = generateJWT() else {
            let errorMessage = "Failed to generate JWT, please check that the token is correct."
            print(errorMessage)
            completion(false, errorMessage)
            return
        }

        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("bearer \(jwt)", forHTTPHeaderField: "authorization")
        request.setValue("application/json", forHTTPHeaderField: "content-type")
        request.setValue("10", forHTTPHeaderField: "apns-priority")
        request.setValue("0", forHTTPHeaderField: "apns-expiration")
        request.setValue(bundleId, forHTTPHeaderField: "apns-topic")
        request.setValue("background", forHTTPHeaderField: "apns-push-type")

        do {
            let jsonData = try JSONEncoder().encode(message)
            request.httpBody = jsonData

            let task = URLSession.shared.dataTask(with: request) { data, response, error in
                if let error = error {
                    let errorMessage = "Failed to send push notification: \(error.localizedDescription)"
                    print(errorMessage)
                    completion(false, errorMessage)
                    return
                }

                if let httpResponse = response as? HTTPURLResponse {
                    print("Push notification sent. Status code: \(httpResponse.statusCode)")

                    switch httpResponse.statusCode {
                    case 200:
                        completion(true, nil)
                    case 400:
                        completion(false, "Bad request.")
                    case 403:
                        completion(false, "Authentication error. Check Token, Team ID and Key ID.")
                    case 405:
                        completion(false, "Method not allowed.")
                    case 413:
                        completion(false, "Payload too large.")
                    case 429:
                        completion(false, "Too many requests. Rate limit exceeded.")
                    case 500:
                        completion(false, "Internal server error at APNs.")
                    case 503:
                        completion(false, "Service unavailable. Try again later.")
                    default:
                        completion(false, "Unexpected status code: \(httpResponse.statusCode)")
                    }
                } else {
                    completion(false, "Failed to get a valid HTTP response.")
                }
            }
            task.resume()

        } catch {
            let errorMessage = "Failed to encode push message: \(error.localizedDescription)"
            print(errorMessage)
            completion(false, errorMessage)
        }
    }

    private func constructAPNsURL() -> URL? {
        let host = productionEnvironment ? "api.push.apple.com" : "api.sandbox.push.apple.com"
        let urlString = "https://\(host)/3/device/\(deviceToken)"
        return URL(string: urlString)
    }

    private func generateJWT() -> String? {
        let header = Header(kid: keyId)
        let claims = APNsJWTClaims(iss: teamId, iat: Date())

        var jwt = JWT(header: header, claims: claims)

        do {
            let privateKey = Data(token.utf8)
            let jwtSigner = JWTSigner.es256(privateKey: privateKey)
            let signedJWT = try jwt.sign(using: jwtSigner)
            return signedJWT
        } catch {
            print("Failed to sign JWT: \(error.localizedDescription)")
            return nil
        }
    }
}