import UserNotifications

class AppDelegate: UIResponder, UIApplicationDelegate {
    
    func application(_ application: UIApplication, 
                     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        
        // 1. Notification Center 가져오기
        let center = UNUserNotificationCenter.current()
        
        // 2. 델리게이트 설정
        center.delegate = self
        
        // 3. 권한 요청 (alert, badge, sound)
        center.requestAuthorization(options: [.alert, .badge, .sound]) { granted, error in
            if granted {
                print("알림 권한 허용됨! 🎉")
            } else {
                print("알림 권한 거부됨 😢")
            }
            
            if let error = error {
                print("에러 발생: \(error.localizedDescription)")
            }
        }
        
        // 4. 원격 알림 등록
        application.registerForRemoteNotifications()
        
        return true
    }
}

extension AppDelegate {
    
    // Device Token 받기 성공
    func application(_ application: UIApplication, 
                     didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
        
        // Data를 String으로 변환
        let tokenParts = deviceToken.map { data in String(format: "%02.2hhx", data) }
        let token = tokenParts.joined()
        
        print("Device Token: \(token)")
        
        // 이 토큰을 서버로 전송해야 함!
        sendTokenToServer(token)
    }
    
    // Device Token 받기 실패
    func application(_ application: UIApplication, 
                     didFailToRegisterForRemoteNotificationsWithError error: Error) {
        print("Device Token 받기 실패: \(error.localizedDescription)")
        
        // 시뮬레이터에서는 항상 실패함 (실제 기기에서만 작동)
    }
    
    func sendTokenToServer(_ token: String) {
        // 여기서 너의 서버 API를 호출해서 토큰 저장
        // 예: POST /api/device-tokens
        let url = URL(string: "https://yourserver.com/api/device-tokens")!
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        
        let body: [String: Any] = [
            "device_token": token,
            "platform": "ios",
            "user_id": getCurrentUserId() // 현재 로그인한 사용자 ID
        ]
        
        request.httpBody = try? JSONSerialization.data(withJSONObject: body)
        
        URLSession.shared.dataTask(with: request) { data, response, error in
            if let error = error {
                print("토큰 전송 실패: \(error)")
                return
            }
            print("토큰 서버 전송 완료! ✅")
        }.resume()
    }
    
    func getCurrentUserId() -> String {
        // 실제로는 UserDefaults나 Keychain에서 가져와야 함
        return "user123"
    }
}

extension AppDelegate: UNUserNotificationCenterDelegate {
    
    // 앱이 포그라운드에 있을 때 알림 도착
    func userNotificationCenter(_ center: UNUserNotificationCenter, 
                                willPresent notification: UNNotification, 
                                withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
        
        let userInfo = notification.request.content.userInfo
        print("포그라운드 알림 수신: \(userInfo)")
        
        // 앱이 실행 중일 때도 알림을 표시할지 결정
        // iOS 14 이상
        if #available(iOS 14.0, *) {
            completionHandler([.banner, .sound, .badge])
        } else {
            completionHandler([.alert, .sound, .badge])
        }
    }
    
    // 사용자가 알림을 탭했을 때
    func userNotificationCenter(_ center: UNUserNotificationCenter, 
                                didReceive response: UNNotificationResponse, 
                                withCompletionHandler completionHandler: @escaping () -> Void) {
        
        let userInfo = response.notification.request.content.userInfo
        print("알림 탭됨: \(userInfo)")
        
        // 알림 데이터에 따라 적절한 화면으로 이동
        if let screenName = userInfo["screen"] as? String {
            navigateToScreen(screenName)
        }
        
        // 액션 버튼 처리
        switch response.actionIdentifier {
        case "ACCEPT_ACTION":
            print("수락 버튼 탭됨")
            handleAcceptAction(userInfo)
        case "DECLINE_ACTION":
            print("거절 버튼 탭됨")
            handleDeclineAction(userInfo)
        case UNNotificationDefaultActionIdentifier:
            print("알림 자체를 탭함")
        case UNNotificationDismissActionIdentifier:
            print("알림을 스와이프로 닫음")
        default:
            break
        }
        
        completionHandler()
    }
    
    func navigateToScreen(_ screenName: String) {
        // 화면 이동 로직
        DispatchQueue.main.async {
            // 예: 채팅 화면으로 이동
            if screenName == "chat" {
                // NavigationController를 통해 화면 이동
            }
        }
    }
    
    func handleAcceptAction(_ userInfo: [AnyHashable: Any]) {
        // 수락 액션 처리
    }
    
    func handleDeclineAction(_ userInfo: [AnyHashable: Any]) {
        // 거절 액션 처리
    }
}

// 서버에서 보내는 푸시 페이로드 예시 (JSON)
{
    "aps": {
        "alert": {
            "title": "새로운 사진이 도착했어요!",
            "body": "친구가 사진을 공유했습니다"
        },
        "sound": "default",
        "mutable-content": 1  // 중요! 이게 있어야 Notification Service Extension 작동
    },
    "attachment-url": "https://example.com/images/photo.jpg",
    "category": "PHOTO_CATEGORY"
}

// 1. Xcode에서 File > New > Target > Notification Service Extension 추가

// 2. NotificationService.swift 파일이 생성됨

import UserNotifications

class NotificationService: UNNotificationServiceExtension {
    
    var contentHandler: ((UNNotificationContent) -> Void)?
    var bestAttemptContent: UNMutableNotificationContent?
    
    override func didReceive(_ request: UNNotificationRequest, 
                             withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void) {
        self.contentHandler = contentHandler
        bestAttemptContent = (request.content.mutableCopy() as? UNMutableNotificationContent)
        
        guard let bestAttemptContent = bestAttemptContent else {
            return
        }
        
        // 이미지 URL 가져오기
        if let urlString = request.content.userInfo["attachment-url"] as? String,
           let url = URL(string: urlString) {
            
            // 이미지 다운로드
            downloadImage(from: url) { localURL in
                if let localURL = localURL {
                    // 첨부파일 추가
                    if let attachment = try? UNNotificationAttachment(identifier: "image", 
                                                                       url: localURL, 
                                                                       options: nil) {
                        bestAttemptContent.attachments = [attachment]
                    }
                }
                
                // 알림 표시
                contentHandler(bestAttemptContent)
            }
        } else {
            contentHandler(bestAttemptContent)
        }
    }
    
    override func serviceExtensionTimeWillExpire() {
        // 시간 초과 시 (30초 제한)
        if let contentHandler = contentHandler, 
           let bestAttemptContent = bestAttemptContent {
            contentHandler(bestAttemptContent)
        }
    }
    
    func downloadImage(from url: URL, completion: @escaping (URL?) -> Void) {
        let task = URLSession.shared.downloadTask(with: url) { localURL, response, error in
            guard let localURL = localURL, error == nil else {
                completion(nil)
                return
            }
            
            // 임시 파일로 복사 (Extension은 30초 후 종료되므로)
            let tempDirectory = FileManager.default.temporaryDirectory
            let tempFile = tempDirectory.appendingPathComponent(url.lastPathComponent)
            
            try? FileManager.default.removeItem(at: tempFile)
            try? FileManager.default.copyItem(at: localURL, to: tempFile)
            
            completion(tempFile)
        }
        task.resume()
    }
}

// AppDelegate에서 카테고리와 액션 등록

func registerNotificationCategories() {
    // 액션 정의
    let acceptAction = UNNotificationAction(
        identifier: "ACCEPT_ACTION",
        title: "수락",
        options: [.foreground]  // 앱을 포그라운드로 가져옴
    )
    
    let declineAction = UNNotificationAction(
        identifier: "DECLINE_ACTION",
        title: "거절",
        options: [.destructive]  // 빨간색으로 표시
    )
    
    let replyAction = UNTextInputNotificationAction(
        identifier: "REPLY_ACTION",
        title: "답장",
        options: [],
        textInputButtonTitle: "전송",
        textInputPlaceholder: "메시지를 입력하세요..."
    )
    
    // 카테고리 생성
    let inviteCategory = UNNotificationCategory(
        identifier: "INVITE_CATEGORY",
        actions: [acceptAction, declineAction],
        intentIdentifiers: [],
        options: []
    )
    
    let messageCategory = UNNotificationCategory(
        identifier: "MESSAGE_CATEGORY",
        actions: [replyAction],
        intentIdentifiers: [],
        options: []
    )
    
    // 등록
    let center = UNUserNotificationCenter.current()
    center.setNotificationCategories([inviteCategory, messageCategory])
}

// didFinishLaunchingWithOptions에서 호출
func application(_ application: UIApplication, 
                 didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    // ... 기존 코드 ...
    registerNotificationCategories()
    return true
}

{
    "aps": {
        "alert": {
            "title": "친구 요청",
            "body": "철수님이 친구 요청을 보냈습니다"
        },
        "category": "INVITE_CATEGORY",  // 여기!
        "sound": "default"
    },
    "user_id": "user456"
}

extension AppDelegate: UNUserNotificationCenterDelegate {
    
    func userNotificationCenter(_ center: UNUserNotificationCenter, 
                                didReceive response: UNNotificationResponse, 
                                withCompletionHandler completionHandler: @escaping () -> Void) {
        
        // 텍스트 입력 액션 처리
        if let textResponse = response as? UNTextInputNotificationResponse {
            let userText = textResponse.userText
            print("사용자가 입력한 텍스트: \(userText)")
            
            // 서버로 메시지 전송
            sendMessageToServer(userText, userInfo: response.notification.request.content.userInfo)
        }
        
        completionHandler()
    }
    
    func sendMessageToServer(_ message: String, userInfo: [AnyHashable: Any]) {
        // API 호출해서 메시지 전송
        guard let recipientId = userInfo["user_id"] as? String else { return }
        
        let url = URL(string: "https://yourserver.com/api/messages")!
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        
        let body: [String: Any] = [
            "recipient_id": recipientId,
            "message": message,
            "sent_from_notification": true
        ]
        
        request.httpBody = try? JSONSerialization.data(withJSONObject: body)
        
        URLSession.shared.dataTask(with: request) { data, response, error in
            if error == nil {
                print("메시지 전송 완료! 📤")
            }
        }.resume()
    }
}

// Node.js + apn 라이브러리 사용 예제

const apn = require('apn');

// APNs Provider 설정
const options = {
    token: {
        key: './AuthKey_XXXXXXXXXX.p8',  // .p8 파일 경로
        keyId: 'XXXXXXXXXX',              // Key ID
        teamId: 'YYYYYYYYYY'              // Team ID
    },
    production: false  // 개발: false, 프로덕션: true
};

const apnProvider = new apn.Provider(options);

// 푸시 알림 보내기 함수
async function sendPushNotification(deviceToken, title, body, data = {}) {
    const notification = new apn.Notification();
    
    // 알림 내용 설정
    notification.alert = {
        title: title,
        body: body
    };
    
    notification.sound = 'default';
    notification.badge = 1;
    notification.topic = 'com.yourcompany.yourapp';  // Bundle ID
    
    // 커스텀 데이터 추가
    notification.payload = data;
    
    // Rich Notification을 위한 설정
    if (data.imageUrl) {
        notification.mutableContent = 1;
        notification.payload['attachment-url'] = data.imageUrl;
    }
    
    // 카테고리 설정 (액션 버튼)
    if (data.category) {
        notification.category = data.category;
    }
    
    try {
        const result = await apnProvider.send(notification, deviceToken);
        console.log('푸시 전송 결과:', result);
        
        if (result.failed.length > 0) {
            console.error('전송 실패:', result.failed);
            // 실패한 토큰은 DB에서 삭제하거나 비활성화 처리
        }
        
        return result;
    } catch (error) {
        console.error('푸시 전송 에러:', error);
        throw error;
    }
}

// 사용 예시
const deviceToken = '사용자의_디바이스_토큰';

sendPushNotification(
    deviceToken,
    '새 메시지 도착!',
    '친구가 메시지를 보냈습니다',
    {
        screen: 'chat',
        chatId: '12345',
        category: 'MESSAGE_CATEGORY'
    }
);

# Python + PyAPNs2 라이브러리

from apns2.client import APNsClient
from apns2.payload import Payload
from apns2.credentials import TokenCredentials

# 인증 정보 설정
token_credentials = TokenCredentials(
    auth_key_path='./AuthKey_XXXXXXXXXX.p8',
    auth_key_id='XXXXXXXXXX',
    team_id='YYYYYYYYYY'
)

# APNs 클라이언트 생성
client = APNsClient(
    credentials=token_credentials,
    use_sandbox=True  # 개발: True, 프로덕션: False
)

# 푸시 알림 보내기
def send_push(device_token, title, body, custom_data=None):
    payload = Payload(
        alert={
            'title': title,
            'body': body
        },
        sound='default',
        badge=1,
        custom=custom_data or {}
    )
    
    topic = 'com.yourcompany.yourapp'  # Bundle ID
    
    try:
        client.send_notification(device_token, payload, topic)
        print(f'푸시 전송 성공: {device_token}')
    except Exception as e:
        print(f'푸시 전송 실패: {e}')

# 사용 예시
send_push(
    '사용자의_디바이스_토큰',
    '새 메시지',
    '안녕하세요!',
    {
        'screen': 'chat',
        'chat_id': '12345'
    }
)

// iOS 앱 - 메시지 수신 처리

extension AppDelegate: UNUserNotificationCenterDelegate {
    
    func userNotificationCenter(_ center: UNUserNotificationCenter, 
                                didReceive response: UNNotificationResponse, 
                                withCompletionHandler completionHandler: @escaping () -> Void) {
        
        let userInfo = response.notification.request.content.userInfo
        
        // 채팅방으로 이동
        if let chatId = userInfo["chat_id"] as? String {
            DispatchQueue.main.async {
                self.navigateToChatRoom(chatId)
            }
        }
        
        // 텍스트 입력 액션 (빠른 답장)
        if let textResponse = response as? UNTextInputNotificationResponse {
            let replyText = textResponse.userText
            
            // 백그라운드에서 메시지 전송
            sendQuickReply(replyText, chatId: userInfo["chat_id"] as? String)
        }
        
        completionHandler()
    }
    
    func navigateToChatRoom(_ chatId: String) {
        // 채팅 화면으로 네비게이션
        if let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene,
           let window = windowScene.windows.first,
           let rootVC = window.rootViewController {
            
            // 채팅 뷰컨트롤러 생성 및 표시
            let chatVC = ChatViewController(chatId: chatId)
            
            if let navController = rootVC as? UINavigationController {
                navController.pushViewController(chatVC, animated: true)
            }
        }
    }
    
    func sendQuickReply(_ message: String, chatId: String?) {
        guard let chatId = chatId else { return }
        
        // API 호출
        let url = URL(string: "https://api.yourapp.com/messages")!
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        
        let body: [String: Any] = [
            "chat_id": chatId,
            "message": message,
            "timestamp": Date().timeIntervalSince1970
        ]
        
        request.httpBody = try? JSONSerialization.data(withJSONObject: body)
        
        URLSession.shared.dataTask(with: request).resume()
    }
}

// 서버 코드 - 주문 상태 변경 시 푸시 전송

async function updateOrderStatus(orderId, newStatus, userId) {
    // DB에서 주문 상태 업데이트
    await db.orders.update(orderId, { status: newStatus });
    
    // 사용자의 디바이스 토큰 가져오기
    const user = await db.users.findById(userId);
    const deviceTokens = user.deviceTokens || [];
    
    // 상태별 메시지 정의
    const statusMessages = {
        'accepted': {
            title: '주문이 접수되었습니다! 🎉',
            body: '맛있는 음식을 준비하고 있어요'
        },
        'cooking': {
            title: '조리가 시작되었습니다 👨‍🍳',
            body: '곧 맛있는 음식이 완성됩니다'
        },
        'delivering': {
            title: '배달이 시작되었습니다! 🛵',
            body: '라이더님이 음식을 가지고 출발했어요'
        },
        'delivered': {
            title: '배달이 완료되었습니다! 🎊',
            body: '맛있게 드세요!'
        }
    };
    
    const message = statusMessages[newStatus];
    
    // 모든 디바이스에 푸시 전송
    for (const token of deviceTokens) {
        await sendPushNotification(
            token,
            message.title,
            message.body,
            {
                order_id: orderId,
                status: newStatus,
                screen: 'order_detail',
                sound: 'notification.wav'
            }
        );
    }
}

// 서버 - 이벤트 알림 전송

async function sendEventNotification(userIds, eventData) {
    const notification = {
        title: eventData.title,
        body: eventData.description,
        imageUrl: eventData.bannerImage,  // 이벤트 배너 이미지
        data: {
            event_id: eventData.id,
            screen: 'event_detail',
            category: 'EVENT_CATEGORY',
            'attachment-url': eventData.bannerImage,
            'mutable-content': 1
        }
    };
    
    // 대량 전송
    for (const userId of userIds) {
        const user = await db.users.findById(userId);
        
        // 사용자 설정 확인 (알림 수신 동의 여부)
        if (!user.notificationSettings.events) {
            continue;  // 이벤트 알림 거부한 사용자는 스킵
        }
        
        for (const token of user.deviceTokens) {
            await sendPushNotification(
                token,
                notification.title,
                notification.body,
                notification.data
            );
        }
    }
}

// 서버 DB 스키마 예시 (MongoDB)

{
    user_id: "user123",
    device_tokens: [
        {
            token: "abc123...",
            platform: "ios",
            environment: "production",
            created_at: ISODate("2024-01-15"),
            last_used: ISODate("2024-01-20"),
            device_info: {
                model: "iPhone 14 Pro",
                os_version: "17.2"
            }
        },
        {
            token: "def456...",
            platform: "ios",
            environment: "production",
            created_at: ISODate("2024-01-10"),
            last_used: ISODate("2024-01-20"),
            device_info: {
                model: "iPad Pro",
                os_version: "17.1"
            }
        }
    ],
    notification_settings: {
        enabled: true,
        messages: true,
        events: false,
        marketing: false
    }
}

// 알림 빈도 제한 로직 예시

class NotificationThrottler {
    private let maxNotificationsPerHour = 5;
    private let maxNotificationsPerDay = 20;
    
    async function canSendNotification(userId: string): Promise<boolean> {
        const now = Date.now();
        const oneHourAgo = now - (60 * 60 * 1000);
        const oneDayAgo = now - (24 * 60 * 60 * 1000);
        
        // 최근 1시간 내 알림 개수 확인
        const hourlyCount = await db.notifications.count({
            user_id: userId,
            sent_at: { $gte: oneHourAgo }
        });
        
        if (hourlyCount >= this.maxNotificationsPerHour) {
            console.log(`사용자 ${userId}: 시간당 알림 제한 초과`);
            return false;
        }
        
        // 최근 24시간 내 알림 개수 확인
        const dailyCount = await db.notifications.count({
            user_id: userId,
            sent_at: { $gte: oneDayAgo }
        });
        
        if (dailyCount >= this.maxNotificationsPerDay) {
            console.log(`사용자 ${userId}: 일일 알림 제한 초과`);
            return false;
        }
        
        return true;
    }
}

// 알림 분석 데이터 수집 예시

async function trackNotificationMetrics(notificationId, userId, event) {
    await db.notification_analytics.insert({
        notification_id: notificationId,
        user_id: userId,
        event: event,  // 'sent', 'delivered', 'opened', 'dismissed'
        timestamp: new Date(),
        device_info: {
            platform: 'ios',
            os_version: '17.2'
        }
    });
    
    // 실시간 대시보드 업데이트
    await updateDashboard(event);
}

// 사용 예시
await trackNotificationMetrics('notif_123', 'user456', 'sent');
await trackNotificationMetrics('notif_123', 'user456', 'delivered');
await trackNotificationMetrics('notif_123', 'user456', 'opened');

// Node.js - 대량 전송 예시

const async = require('async');

async function sendBulkNotifications(notifications) {
    // 100개씩 배치로 나누기
    const batches = [];
    for (let i = 0; i < notifications.length; i += 100) {
        batches.push(notifications.slice(i, i + 100));
    }
    
    console.log(`총 ${batches.length}개 배치로 전송 시작`);
    
    // 병렬로 5개 배치씩 처리
    await async.eachLimit(batches, 5, async (batch) => {
        await Promise.all(batch.map(async (notif) => {
            try {
                await sendPushNotification(
                    notif.deviceToken,
                    notif.title,
                    notif.body,
                    notif.data
                );
                
                await trackNotificationMetrics(notif.id, notif.userId, 'sent');
            } catch (error) {
                console.error(`전송 실패: ${notif.id}`, error);
                
                // 재시도 큐에 추가
                await addToRetryQueue(notif);
            }
        }));
    });
    
    console.log('대량 전송 완료!');
}