import Foundation
import UserNotifications
import OSLog

private let logger = Logger(subsystem: "nahbar", category: "AftermathNotification")

// MARK: - AftermathNotificationManager
// Verwaltet Push-Notifications für die verzögerte Nachwirkungs-Bewertung.
// Pattern analog zu CallWindowManager (UNUserNotificationCenter).

final class AftermathNotificationManager {
    static let shared = AftermathNotificationManager()
    private init() {}

    static let categoryID    = "AFTERMATH_RATING"
    static let actionID      = "RATE_NOW"
    static let momentIDKey   = "momentID"    // V5 – primärer Key
    static let personNameKey = "personName"

    // MARK: - Setup

    /// Registriert die Notification-Kategorie mit „Jetzt bewerten"-Action.
    /// Muss beim App-Start einmalig aufgerufen werden.
    func registerCategory() {
        let rateNow = UNNotificationAction(
            identifier: Self.actionID,
            title: String(localized: "Jetzt bewerten"),
            options: .foreground
        )
        let category = UNNotificationCategory(
            identifier: Self.categoryID,
            actions: [rateNow],
            intentIdentifiers: [],
            options: []
        )
        UNUserNotificationCenter.current().setNotificationCategories([category])
    }

    // MARK: - Schedule

    /// Plant eine Nachwirkungs-Erinnerung für den angegebenen Treffen-Moment.
    /// - Parameters:
    ///   - momentID: UUID des Moment-Objekts
    ///   - personName: Name der Person (für Notification-Text)
    ///   - delay: Verzögerung in Sekunden (Standard: 36 Stunden)
    func scheduleAftermath(momentID: UUID, personName: String, delay: TimeInterval = 36 * 3600) {
        UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
            guard granted else {
                logger.warning("Notification-Berechtigung abgelehnt – keine Nachwirkungs-Erinnerung.")
                return
            }
            if let error {
                logger.error("Berechtigung-Fehler: \(error.localizedDescription)")
            }
            self.createNotification(momentID: momentID, personName: personName, delay: delay)
        }
    }

    private func createNotification(momentID: UUID, personName: String, delay: TimeInterval) {
        let content = UNMutableNotificationContent()
        // Wärmerer, gesprächigerer Titel statt klinischem "Nachwirkung: [Name]"
        content.title = String.localizedStringWithFormat(String(localized: "Wie war's mit %@?"), personName)
        // Persönlichkeitsgerechter Body-Text via PersonalityEngine
        content.body = PersonalityEngine.aftermathCopy(profile: PersonalityStore.shared.profile)
        content.sound = .default
        content.categoryIdentifier = Self.categoryID
        content.userInfo = [
            Self.momentIDKey: momentID.uuidString,
            Self.personNameKey: personName
        ]

        let trigger = UNTimeIntervalNotificationTrigger(timeInterval: delay, repeats: false)
        let request = UNNotificationRequest(
            identifier: notificationID(for: momentID),
            content: content,
            trigger: trigger
        )

        UNUserNotificationCenter.current().add(request) { error in
            if let error {
                logger.error("Notification konnte nicht geplant werden: \(error.localizedDescription)")
            } else {
                logger.info("Nachwirkungs-Erinnerung geplant für Moment \(momentID.uuidString) in \(Int(delay / 3600))h.")
            }
        }
    }

    // MARK: - Cancel

    /// Entfernt eine geplante Nachwirkungs-Erinnerung.
    func cancelAftermath(momentID: UUID) {
        UNUserNotificationCenter.current().removePendingNotificationRequests(
            withIdentifiers: [notificationID(for: momentID)]
        )
        logger.info("Nachwirkungs-Erinnerung abgebrochen für Moment \(momentID.uuidString).")
    }

    // MARK: - Helpers

    private func notificationID(for momentID: UUID) -> String {
        "aftermath_\(momentID.uuidString)"
    }
}
