import UserNotifications

// 싱글톤 인스턴스로 접근
let center = UNUserNotificationCenter.current()

// 알림 권한 요청
center.requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
    if granted {
        print("알림 권한 획득! 🎉")
    } else {
        print("알림 권한 거부됨 😢")
    }
}

// 델리게이트 설정 (중요!)
center.delegate = self

// 알림 콘텐츠 생성
let content = UNMutableNotificationContent()
content.title = "재능넷 알림"
content.body = "새로운 재능 거래 요청이 도착했습니다!"
content.sound = .default
content.badge = 1

// 트리거 설정 (5초 후 발동)
let trigger = UNTimeIntervalNotificationTrigger(timeInterval: 5, repeats: false)

// 요청 생성
let request = UNNotificationRequest(
    identifier: "talent-request-001",
    content: content,
    trigger: trigger
)

// 알림 예약
center.add(request) { error in
    if let error = error {
        print("알림 예약 실패: \(error)")
    }
}

// 1. 시간 간격 트리거 (5분 후)
let timeInterval = UNTimeIntervalNotificationTrigger(
    timeInterval: 300,
    repeats: false
)

// 2. 캘린더 트리거 (매일 오전 9시)
var dateComponents = DateComponents()
dateComponents.hour = 9
dateComponents.minute = 0
let calendar = UNCalendarNotificationTrigger(
    dateMatching: dateComponents,
    repeats: true
)

// 3. 위치 트리거 (특정 위치 도착 시)
let center = CLLocationCoordinate2D(latitude: 37.5665, longitude: 126.9780)
let region = CLCircularRegion(
    center: center,
    radius: 100,
    identifier: "Seoul"
)
region.notifyOnEntry = true
let location = UNLocationNotificationTrigger(
    region: region,
    repeats: false
)

extension AppDelegate: UNUserNotificationCenterDelegate {
    
    // 앱이 포그라운드에 있을 때 알림이 도착하면
    func userNotificationCenter(
        _ center: UNUserNotificationCenter,
        willPresent notification: UNNotification,
        withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void
    ) {
        // 포그라운드에서도 알림 표시
        completionHandler([.banner, .sound, .badge])
    }
    
    // 사용자가 알림을 탭했을 때
    func userNotificationCenter(
        _ center: UNUserNotificationCenter,
        didReceive response: UNNotificationResponse,
        withCompletionHandler completionHandler: @escaping () -> Void
    ) {
        let userInfo = response.notification.request.content.userInfo
        
        // 알림 데이터 처리
        if let talentId = userInfo["talentId"] as? String {
            // 해당 재능 상세 화면으로 이동
            navigateToTalentDetail(talentId: talentId)
        }
        
        completionHandler()
    }
}

import UIKit
import UserNotifications

@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    
    func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        
        // 알림 센터 델리게이트 설정
        UNUserNotificationCenter.current().delegate = self
        
        // 알림 권한 요청
        requestNotificationAuthorization()
        
        return true
    }
    
    func requestNotificationAuthorization() {
        let center = UNUserNotificationCenter.current()
        center.requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
            
            if let error = error {
                print("권한 요청 에러: \(error.localizedDescription)")
                return
            }
            
            if granted {
                print("알림 권한 승인됨! ✅")
                
                // 메인 스레드에서 APNs 등록
                DispatchQueue.main.async {
                    UIApplication.shared.registerForRemoteNotifications()
                }
            } else {
                print("알림 권한 거부됨 ❌")
            }
        }
    }
    
    // Device Token 수신 성공
    func application(
        _ application: UIApplication,
        didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data
    ) {
        let token = deviceToken.map { String(format: "%02.2hhx", $0) }.joined()
        print("Device Token: \(token)")
        
        // 서버로 토큰 전송
        sendTokenToServer(token: token)
    }
    
    // Device Token 수신 실패
    func application(
        _ application: UIApplication,
        didFailToRegisterForRemoteNotificationsWithError error: Error
    ) {
        print("APNs 등록 실패: \(error.localizedDescription)")
    }
    
    func sendTokenToServer(token: String) {
        // 여기서 너의 백엔드 API로 토큰 전송
        let url = URL(string: "https://api.yourserver.com/device-token")!
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        
        let body: [String: Any] = [
            "deviceToken": token,
            "platform": "ios",
            "userId": 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"
    }
}

// npm install apn 먼저 설치

const apn = require('apn');

// APNs Provider 설정
const options = {
    token: {
        key: './AuthKey_ABC123DEFG.p8',  // .p8 파일 경로
        keyId: 'ABC123DEFG',              // Key ID
        teamId: 'XYZ987TEAM'              // 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.badge = 1;
    notification.sound = 'default';
    notification.topic = 'com.yourcompany.yourapp';  // Bundle ID
    
    // 커스텀 데이터 추가
    notification.payload = data;
    
    // 만료 시간 설정 (1시간)
    notification.expiry = Math.floor(Date.now() / 1000) + 3600;
    
    // 우선순위 설정 (10: 즉시, 5: 절전 모드 고려)
    notification.priority = 10;
    
    try {
        const result = await apnProvider.send(notification, deviceToken);
        
        if (result.failed.length > 0) {
            console.error('푸시 전송 실패:', result.failed);
            return { success: false, error: result.failed };
        }
        
        console.log('푸시 전송 성공! 🎉');
        return { success: true };
        
    } catch (error) {
        console.error('APNs 에러:', error);
        return { success: false, error: error.message };
    }
}

// 사용 예시
const deviceToken = 'a1b2c3d4e5f6...';  // 앱에서 받은 Device Token

sendPushNotification(
    deviceToken,
    '재능넷 알림',
    '새로운 재능 거래 요청이 도착했습니다!',
    {
        type: 'talent_request',
        talentId: 'talent_12345',
        requesterId: 'user_67890'
    }
);

const jwt = require('jsonwebtoken');
const http2 = require('http2');
const fs = require('fs');

// JWT 토큰 생성
function generateJWT(keyId, teamId, keyPath) {
    const token = jwt.sign(
        {
            iss: teamId,
            iat: Math.floor(Date.now() / 1000)
        },
        fs.readFileSync(keyPath),
        {
            algorithm: 'ES256',
            header: {
                alg: 'ES256',
                kid: keyId
            }
        }
    );
    return token;
}

// APNs에 푸시 전송
function sendPushViaHTTP2(deviceToken, payload, jwtToken, bundleId) {
    
    const host = 'api.sandbox.push.apple.com';  // 개발용
    // const host = 'api.push.apple.com';  // 프로덕션용
    
    const client = http2.connect(`https://${host}`);
    
    const headers = {
        ':method': 'POST',
        ':scheme': 'https',
        ':path': `/3/device/${deviceToken}`,
        'authorization': `bearer ${jwtToken}`,
        'apns-topic': bundleId,
        'apns-push-type': 'alert',
        'apns-priority': '10',
        'apns-expiration': '0'
    };
    
    const request = client.request(headers);
    
    request.on('response', (headers) => {
        const status = headers[':status'];
        
        if (status === 200) {
            console.log('푸시 전송 성공! ✅');
        } else {
            console.error(`푸시 전송 실패: ${status}`);
        }
    });
    
    request.on('data', (chunk) => {
        console.log('응답:', chunk.toString());
    });
    
    request.on('end', () => {
        client.close();
    });
    
    request.write(JSON.stringify(payload));
    request.end();
}

// 사용 예시
const jwtToken = generateJWT(
    'ABC123DEFG',
    'XYZ987TEAM',
    './AuthKey_ABC123DEFG.p8'
);

const payload = {
    aps: {
        alert: {
            title: '재능넷 알림',
            body: '새로운 메시지가 도착했습니다!'
        },
        badge: 1,
        sound: 'default'
    },
    customData: {
        messageId: 'msg_12345'
    }
};

sendPushViaHTTP2(
    'a1b2c3d4e5f6...',
    payload,
    jwtToken,
    'com.yourcompany.yourapp'
);

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 {
            contentHandler(request.content)
            return
        }
        
        // 페이로드에서 이미지 URL 추출
        guard let imageURLString = bestAttemptContent.userInfo["imageUrl"] as? String,
              let imageURL = URL(string: imageURLString) else {
            contentHandler(bestAttemptContent)
            return
        }
        
        // 이미지 다운로드
        downloadImage(from: imageURL) { attachment in
            if let attachment = attachment {
                bestAttemptContent.attachments = [attachment]
            }
            contentHandler(bestAttemptContent)
        }
    }
    
    override func serviceExtensionTimeWillExpire() {
        // 시간 초과 시 (30초 제한)
        if let contentHandler = contentHandler,
           let bestAttemptContent = bestAttemptContent {
            contentHandler(bestAttemptContent)
        }
    }
    
    private func downloadImage(
        from url: URL,
        completion: @escaping (UNNotificationAttachment?) -> Void
    ) {
        let task = URLSession.shared.downloadTask(with: url) { localURL, response, error in
            
            guard let localURL = localURL else {
                completion(nil)
                return
            }
            
            // 임시 디렉토리에 파일 복사
            let tempDirectory = NSTemporaryDirectory()
            let tempFile = "image_\(UUID().uuidString).jpg"
            let tempURL = URL(fileURLWithPath: tempDirectory).appendingPathComponent(tempFile)
            
            do {
                try FileManager.default.moveItem(at: localURL, to: tempURL)
                let attachment = try UNNotificationAttachment(
                    identifier: "image",
                    url: tempURL,
                    options: nil
                )
                completion(attachment)
            } catch {
                print("이미지 첨부 실패: \(error)")
                completion(nil)
            }
        }
        task.resume()
    }
}

const payload = {
    aps: {
        alert: {
            title: '새로운 재능 등록!',
            body: '디자인 재능이 등록되었습니다.'
        },
        'mutable-content': 1,  // 이게 중요! Service Extension 활성화
        sound: 'default'
    },
    imageUrl: 'https://example.com/talent-image.jpg'
};

// 비디오 첨부
let videoAttachment = try UNNotificationAttachment(
    identifier: "video",
    url: videoURL,
    options: [UNNotificationAttachmentOptionsTypeHintKey: kUTTypeMPEG4]
)

// 오디오 첨부
let audioAttachment = try UNNotificationAttachment(
    identifier: "audio",
    url: audioURL,
    options: [UNNotificationAttachmentOptionsTypeHintKey: kUTTypeMPEG4Audio]
)

func setupNotificationActions() {
    // 액션 정의
    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 talentRequestCategory = UNNotificationCategory(
        identifier: "TALENT_REQUEST",
        actions: [acceptAction, declineAction, replyAction],
        intentIdentifiers: [],
        options: []
    )
    
    // 카테고리 등록
    let center = UNUserNotificationCenter.current()
    center.setNotificationCategories([talentRequestCategory])
}

// AppDelegate의 didFinishLaunchingWithOptions에서 호출
func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
) -> Bool {
    setupNotificationActions()
    return true
}

extension AppDelegate: UNUserNotificationCenterDelegate {
    
    func userNotificationCenter(
        _ center: UNUserNotificationCenter,
        didReceive response: UNNotificationResponse,
        withCompletionHandler completionHandler: @escaping () -> Void
    ) {
        let userInfo = response.notification.request.content.userInfo
        
        switch response.actionIdentifier {
            
        case "ACCEPT_ACTION":
            print("재능 요청 수락!")
            if let requestId = userInfo["requestId"] as? String {
                acceptTalentRequest(requestId: requestId)
            }
            
        case "DECLINE_ACTION":
            print("재능 요청 거절")
            if let requestId = userInfo["requestId"] as? String {
                declineTalentRequest(requestId: requestId)
            }
            
        case "REPLY_ACTION":
            if let textResponse = response as? UNTextInputNotificationResponse {
                let replyText = textResponse.userText
                print("답장 내용: \(replyText)")
                sendReply(text: replyText, userInfo: userInfo)
            }
            
        case UNNotificationDefaultActionIdentifier:
            // 알림 자체를 탭한 경우
            print("알림 탭됨")
            navigateToDetail(userInfo: userInfo)
            
        case UNNotificationDismissActionIdentifier:
            // 알림을 스와이프해서 닫은 경우
            print("알림 닫힘")
            
        default:
            break
        }
        
        completionHandler()
    }
    
    func acceptTalentRequest(requestId: String) {
        // API 호출해서 요청 수락 처리
        let url = URL(string: "https://api.yourserver.com/talent-requests/\(requestId)/accept")!
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        
        URLSession.shared.dataTask(with: request) { data, response, error in
            if error == nil {
                print("요청 수락 완료! ✅")
            }
        }.resume()
    }
}

const payload = {
    aps: {
        alert: {
            title: '재능 거래 요청',
            body: '홍길동님이 디자인 재능을 요청했습니다.'
        },
        category: 'TALENT_REQUEST',  // 카테고리 지정
        sound: 'default'
    },
    requestId: 'req_12345',
    requesterId: 'user_67890'
};

curl -v \
  --header "apns-topic: com.yourcompany.yourapp" \
  --header "apns-push-type: alert" \
  --header "authorization: bearer YOUR_JWT_TOKEN" \
  --data '{"aps":{"alert":"Test Push"}}' \
  --http2 \
  https://api.sandbox.push.apple.com/3/device/YOUR_DEVICE_TOKEN

// 서버에서 보내는 페이로드
const silentPayload = {
    aps: {
        'content-available': 1  // 이게 핵심!
        // alert, sound, badge는 포함하지 않음
    },
    updateType: 'newMessages',
    messageCount: 5
};

// AppDelegate에서 처리
func application(
    _ application: UIApplication,
    didReceiveRemoteNotification userInfo: [AnyHashable: Any],
    fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void
) {
    print("Silent push 받음!")
    
    if let updateType = userInfo["updateType"] as? String {
        switch updateType {
        case "newMessages":
            // 메시지 데이터 동기화
            syncMessages { success in
                if success {
                    completionHandler(.newData)
                } else {
                    completionHandler(.failed)
                }
            }
        default:
            completionHandler(.noData)
        }
    }
}

// 서버에서 thread-id 지정
const payload = {
    aps: {
        alert: {
            title: '새 메시지',
            body: '홍길동: 안녕하세요!'
        },
        'thread-id': 'chat-user123',  // 그룹 ID
        sound: 'default'
    }
};

// 같은 thread-id를 가진 알림들이 자동으로 그룹화됨

import UIKit
import UserNotifications
import UserNotificationsUI

class NotificationViewController: UIViewController, UNNotificationContentExtension {
    
    @IBOutlet weak var profileImageView: UIImageView!
    @IBOutlet weak var nameLabel: UILabel!
    @IBOutlet weak var messageLabel: UILabel!
    @IBOutlet weak var timeLabel: UILabel!
    
    func didReceive(_ notification: UNNotification) {
        let content = notification.request.content
        
        // 커스텀 데이터 추출
        if let name = content.userInfo["senderName"] as? String {
            nameLabel.text = name
        }
        
        if let message = content.userInfo["message"] as? String {
            messageLabel.text = message
        }
        
        if let imageUrl = content.userInfo["profileImageUrl"] as? String {
            loadImage(from: imageUrl)
        }
        
        timeLabel.text = formatTime(Date())
    }
    
    func loadImage(from urlString: String) {
        guard let url = URL(string: urlString) else { return }
        
        URLSession.shared.dataTask(with: url) { data, response, error in
            if let data = data, let image = UIImage(data: data) {
                DispatchQueue.main.async {
                    self.profileImageView.image = image
                    self.profileImageView.layer.cornerRadius = self.profileImageView.frame.width / 2
                    self.profileImageView.clipsToBounds = true
                }
            }
        }.resume()
    }
    
    func formatTime(_ date: Date) -> String {
        let formatter = DateFormatter()
        formatter.timeStyle = .short
        return formatter.string(from: date)
    }
}

<key>NSExtension</key>
<dict>
    <key>NSExtensionAttributes</key>
    <dict>
        <key>UNNotificationExtensionCategory</key>
        <string>CUSTOM_MESSAGE</string>
        <key>UNNotificationExtensionInitialContentSizeRatio</key>
        <real>0.5</real>
    </dict>
</dict>

// 서버에서 알림 빈도 제어 로직 예시
class PushNotificationManager {
    
    func shouldSendPush(userId: String, type: String) -> Bool {
        // 최근 24시간 내 발송 횟수 확인
        let recentCount = getRecentPushCount(userId: userId, hours: 24)
        
        // 타입별 최대 허용 횟수
        let maxCount: Int
        switch type {
        case "urgent":
            maxCount = 10  // 긴급 알림은 많이 허용
        case "marketing":
            maxCount = 2   // 마케팅 알림은 제한
        default:
            maxCount = 5
        }
        
        if recentCount >= maxCount {
            print("알림 빈도 제한 초과")
            return false
        }
        
        // 사용자의 방해금지 시간 확인
        if isUserQuietHours(userId: userId) {
            print("사용자 방해금지 시간")
            return false
        }
        
        return true
    }
    
    func getRecentPushCount(userId: String, hours: Int) -> Int {
        // DB에서 최근 발송 기록 조회
        // 실제 구현 필요
        return 0
    }
    
    func isUserQuietHours(userId: String) -> Bool {
        // 사용자가 설정한 방해금지 시간 확인
        // 실제 구현 필요
        return false
    }
}

// 푸시 성과 추적 예시
func trackPushNotification(
    notificationId: String,
    userId: String,
    action: String
) {
    let event = [
        "notification_id": notificationId,
        "user_id": userId,
        "action": action,  // "delivered", "opened", "converted"
        "timestamp": Date().timeIntervalSince1970
    ]
    
    // 분석 서버로 전송
    sendAnalytics(event: event)
}

// AppDelegate에서 호출
func userNotificationCenter(
    _ center: UNUserNotificationCenter,
    didReceive response: UNNotificationResponse,
    withCompletionHandler completionHandler: @escaping () -> Void
) {
    let notificationId = response.notification.request.identifier
    let userId = getCurrentUserId()
    
    // 오픈 이벤트 추적
    trackPushNotification(
        notificationId: notificationId,
        userId: userId,
        action: "opened"
    )
    
    completionHandler()
}

// Device Token 저장 시 암호화 예시 (Node.js)
const crypto = require('crypto');

function encryptDeviceToken(token, secretKey) {
    const cipher = crypto.createCipher('aes-256-cbc', secretKey);
    let encrypted = cipher.update(token, 'utf8', 'hex');
    encrypted += cipher.final('hex');
    return encrypted;
}

function decryptDeviceToken(encryptedToken, secretKey) {
    const decipher = crypto.createDecipher('aes-256-cbc', secretKey);
    let decrypted = decipher.update(encryptedToken, 'hex', 'utf8');
    decrypted += decipher.final('utf8');
    return decrypted;
}

// 사용 예시
const deviceToken = 'a1b2c3d4e5f6...';
const secretKey = process.env.ENCRYPTION_KEY;
const encryptedToken = encryptDeviceToken(deviceToken, secretKey);

// DB에 암호화된 토큰 저장
saveToDatabase(userId, encryptedToken);

// .gitignore에 추가
*.p8
*.p12
*.pem
.env

// 환경 변수로 관리
const apnOptions = {
    token: {
        key: process.env.APN_KEY_PATH,
        keyId: process.env.APN_KEY_ID,
        teamId: process.env.APN_TEAM_ID
    }
};

// 앱 내에서 알림 설정 화면 제공
class NotificationSettingsViewController: UIViewController {
    
    @IBOutlet weak var marketingSwitch: UISwitch!
    @IBOutlet weak var messageSwitch: UISwitch!
    @IBOutlet weak var talentRequestSwitch: UISwitch!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        loadUserPreferences()
    }
    
    @IBAction func settingChanged(_ sender: UISwitch) {
        let preferences = [
            "marketing": marketingSwitch.isOn,
            "message": messageSwitch.isOn,
            "talentRequest": talentRequestSwitch.isOn
        ]
        
        // 서버에 사용자 설정 저장
        savePreferencesToServer(preferences)
    }
    
    func savePreferencesToServer(_ preferences: [String: Bool]) {
        let url = URL(string: "https://api.yourserver.com/notification-preferences")!
        var request = URLRequest(url: url)
        request.httpMethod = "PUT"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        
        let body = try? JSONSerialization.data(withJSONObject: preferences)
        request.httpBody = body
        
        URLSession.shared.dataTask(with: request).resume()
    }
}

// 서버에서 보내는 페이로드
const payload = {
    aps: {
        alert: {
            'title-loc-key': 'NOTIFICATION_TITLE_NEW_MESSAGE',
            'title-loc-args': ['홍길동'],
            'loc-key': 'NOTIFICATION_BODY_NEW_MESSAGE',
            'loc-args': ['안녕하세요!']
        },
        sound: 'default'
    }
};

// Localizable.strings (한국어)
"NOTIFICATION_TITLE_NEW_MESSAGE" = "%@님의 새 메시지";
"NOTIFICATION_BODY_NEW_MESSAGE" = "%@";

// Localizable.strings (영어)
"NOTIFICATION_TITLE_NEW_MESSAGE" = "New message from %@";
"NOTIFICATION_BODY_NEW_MESSAGE" = "%@";

// 서버에서 사용자 언어에 맞게 전송
function getLocalizedMessage(language, key, args) {
    const messages = {
        'ko': {
            'new_message': `${args[0]}님의 새 메시지: ${args[1]}`
        },
        'en': {
            'new_message': `New message from ${args[0]}: ${args[1]}`
        },
        'ja': {
            'new_message': `${args[0]}さんからの新しいメッセージ: ${args[1]}`
        }
    };
    
    return messages[language]?.[key] || messages['en'][key];
}

// 사용 예시
const userLanguage = getUserLanguage(userId);  // DB에서 조회
const message = getLocalizedMessage(
    userLanguage,
    'new_message',
    ['홍길동', '안녕하세요!']
);

const payload = {
    aps: {
        alert: message,
        sound: 'default'
    }
};

// AppDelegate.swift
import UIKit
import UserNotifications

@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    
    func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        
        // 알림 센터 설정
        setupNotifications()
        
        // 앱이 푸시로 실행된 경우 처리
        if let notification = launchOptions?[.remoteNotification] as? [String: AnyObject] {
            handlePushNotification(userInfo: notification)
        }
        
        return true
    }
    
    func setupNotifications() {
        let center = UNUserNotificationCenter.current()
        center.delegate = self
        
        // 알림 액션 설정
        setupNotificationActions()
        
        // 권한 요청
        center.requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
            if granted {
                DispatchQueue.main.async {
                    UIApplication.shared.registerForRemoteNotifications()
                }
            }
        }
    }
    
    func setupNotificationActions() {
        // 재능 요청 액션
        let acceptAction = UNNotificationAction(
            identifier: "ACCEPT_TALENT_REQUEST",
            title: "수락",
            options: [.foreground]
        )
        
        let declineAction = UNNotificationAction(
            identifier: "DECLINE_TALENT_REQUEST",
            title: "거절",
            options: [.destructive]
        )
        
        let talentRequestCategory = UNNotificationCategory(
            identifier: "TALENT_REQUEST",
            actions: [acceptAction, declineAction],
            intentIdentifiers: [],
            options: []
        )
        
        // 메시지 액션
        let replyAction = UNTextInputNotificationAction(
            identifier: "REPLY_MESSAGE",
            title: "답장",
            options: [],
            textInputButtonTitle: "전송",
            textInputPlaceholder: "메시지 입력"
        )
        
        let messageCategory = UNNotificationCategory(
            identifier: "MESSAGE",
            actions: [replyAction],
            intentIdentifiers: [],
            options: []
        )
        
        UNUserNotificationCenter.current().setNotificationCategories([
            talentRequestCategory,
            messageCategory
        ])
    }
    
    func application(
        _ application: UIApplication,
        didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data
    ) {
        let token = deviceToken.map { String(format: "%02.2hhx", $0) }.joined()
        print("📱 Device Token: \(token)")
        
        // 서버로 전송
        PushTokenManager.shared.sendTokenToServer(token: token)
    }
    
    func application(
        _ application: UIApplication,
        didFailToRegisterForRemoteNotificationsWithError error: Error
    ) {
        print("❌ APNs 등록 실패: \(error.localizedDescription)")
    }
    
    func handlePushNotification(userInfo: [AnyHashable: Any]) {
        guard let type = userInfo["type"] as? String else { return }
        
        switch type {
        case "talent_request":
            if let talentId = userInfo["talentId"] as? String {
                navigateToTalentDetail(talentId: talentId)
            }
        case "message":
            if let chatRoomId = userInfo["chatRoomId"] as? String {
                navigateToChatRoom(chatRoomId: chatRoomId)
            }
        case "review":
            navigateToReviewList()
        default:
            break
        }
    }
    
    func navigateToTalentDetail(talentId: String) {
        // 재능 상세 화면으로 이동
        NotificationCenter.default.post(
            name: NSNotification.Name("NavigateToTalentDetail"),
            object: nil,
            userInfo: ["talentId": talentId]
        )
    }
    
    func navigateToChatRoom(chatRoomId: String) {
        // 채팅방으로 이동
        NotificationCenter.default.post(
            name: NSNotification.Name("NavigateToChatRoom"),
            object: nil,
            userInfo: ["chatRoomId": chatRoomId]
        )
    }
    
    func navigateToReviewList() {
        // 리뷰 목록으로 이동
        NotificationCenter.default.post(
            name: NSNotification.Name("NavigateToReviewList"),
            object: nil
        )
    }
}

extension AppDelegate: UNUserNotificationCenterDelegate {
    
    // 포그라운드에서 알림 수신
    func userNotificationCenter(
        _ center: UNUserNotificationCenter,
        willPresent notification: UNNotification,
        withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void
    ) {
        let userInfo = notification.request.content.userInfo
        
        // 현재 화면에 따라 알림 표시 여부 결정
        if isInChatRoom(userInfo: userInfo) {
            // 해당 채팅방에 있으면 알림 표시 안 함
            completionHandler([])
        } else {
            // 알림 표시
            completionHandler([.banner, .sound, .badge])
        }
    }
    
    // 알림 탭 또는 액션 실행
    func userNotificationCenter(
        _ center: UNUserNotificationCenter,
        didReceive response: UNNotificationResponse,
        withCompletionHandler completionHandler: @escaping () -> Void
    ) {
        let userInfo = response.notification.request.content.userInfo
        
        switch response.actionIdentifier {
            
        case "ACCEPT_TALENT_REQUEST":
            if let requestId = userInfo["requestId"] as? String {
                TalentRequestManager.shared.acceptRequest(requestId: requestId)
            }
            
        case "DECLINE_TALENT_REQUEST":
            if let requestId = userInfo["requestId"] as? String {
                TalentRequestManager.shared.declineRequest(requestId: requestId)
            }
            
        case "REPLY_MESSAGE":
            if let textResponse = response as? UNTextInputNotificationResponse,
               let chatRoomId = userInfo["chatRoomId"] as? String {
                MessageManager.shared.sendMessage(
                    chatRoomId: chatRoomId,
                    text: textResponse.userText
                )
            }
            
        case UNNotificationDefaultActionIdentifier:
            // 알림 자체를 탭한 경우
            handlePushNotification(userInfo: userInfo)
            
        default:
            break
        }
        
        completionHandler()
    }
    
    func isInChatRoom(userInfo: [AnyHashable: Any]) -> Bool {
        // 현재 채팅방에 있는지 확인하는 로직
        // 실제 구현 필요
        return false
    }
}

import Foundation

class PushTokenManager {
    static let shared = PushTokenManager()
    
    private let tokenKey = "deviceToken"
    private let baseURL = "https://api.jaenung.net"
    
    func sendTokenToServer(token: String) {
        // 이전 토큰과 같으면 전송하지 않음
        if let savedToken = getSavedToken(), savedToken == token {
            print("토큰이 변경되지 않음")
            return
        }
        
        guard let userId = AuthManager.shared.currentUserId else {
            print("로그인되지 않음")
            return
        }
        
        let url = URL(string: "\(baseURL)/api/push/register")!
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.setValue(AuthManager.shared.accessToken, forHTTPHeaderField: "Authorization")
        
        let body: [String: Any] = [
            "userId": userId,
            "deviceToken": token,
            "platform": "ios",
            "appVersion": Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "",
            "osVersion": UIDevice.current.systemVersion,
            "deviceModel": UIDevice.current.model
        ]
        
        request.httpBody = try? JSONSerialization.data(withJSONObject: body)
        
        URLSession.shared.dataTask(with: request) { data, response, error in
            if let error = error {
                print("❌ 토큰 전송 실패: \(error)")
                return
            }
            
            if let httpResponse = response as? HTTPURLResponse,
               httpResponse.statusCode == 200 {
                print("✅ 토큰 전송 성공")
                self.saveToken(token)
            }
        }.resume()
    }
    
    func deleteTokenFromServer() {
        guard let token = getSavedToken(),
              let userId = AuthManager.shared.currentUserId else {
            return
        }
        
        let url = URL(string: "\(baseURL)/api/push/unregister")!
        var request = URLRequest(url: url)
        request.httpMethod = "DELETE"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.setValue(AuthManager.shared.accessToken, forHTTPHeaderField: "Authorization")
        
        let body: [String: Any] = [
            "userId": userId,
            "deviceToken": token
        ]
        
        request.httpBody = try? JSONSerialization.data(withJSONObject: body)
        
        URLSession.shared.dataTask(with: request) { _, response, _ in
            if let httpResponse = response as? HTTPURLResponse,
               httpResponse.statusCode == 200 {
                print("✅ 토큰 삭제 성공")
                self.clearToken()
            }
        }.resume()
    }
    
    private func saveToken(_ token: String) {
        UserDefaults.standard.set(token, forKey: tokenKey)
    }
    
    private func getSavedToken() -> String? {
        return UserDefaults.standard.string(forKey: tokenKey)
    }
    
    private func clearToken() {
        UserDefaults.standard.removeObject(forKey: tokenKey)
    }
}

// server.js
const express = require('express');
const apn = require('apn');
const mongoose = require('mongoose');

const app = express();
app.use(express.json());

// MongoDB 스키마
const DeviceTokenSchema = new mongoose.Schema({
    userId: { type: String, required: true, index: true },
    deviceToken: { type: String, required: true, unique: true },
    platform: { type: String, required: true },
    appVersion: String,
    osVersion: String,
    deviceModel: String,
    createdAt: { type: Date, default: Date.now },
    updatedAt: { type: Date, default: Date.now }
});

const DeviceToken = mongoose.model('DeviceToken', DeviceTokenSchema);

// APNs Provider 설정
const apnProvider = new apn.Provider({
    token: {
        key: process.env.APN_KEY_PATH,
        keyId: process.env.APN_KEY_ID,
        teamId: process.env.APN_TEAM_ID
    },
    production: process.env.NODE_ENV === 'production'
});

// 토큰 등록 API
app.post('/api/push/register', async (req, res) => {
    try {
        const { userId, deviceToken, platform, appVersion, osVersion, deviceModel } = req.body;
        
        await DeviceToken.findOneAndUpdate(
            { deviceToken },
            {
                userId,
                platform,
                appVersion,
                osVersion,
                deviceModel,
                updatedAt: new Date()
            },
            { upsert: true, new: true }
        );
        
        res.json({ success: true, message: '토큰 등록 완료' });
    } catch (error) {
        console.error('토큰 등록 에러:', error);
        res.status(500).json({ success: false, error: error.message });
    }
});

// 토큰 삭제 API
app.delete('/api/push/unregister', async (req, res) => {
    try {
        const { userId, deviceToken } = req.body;
        
        await DeviceToken.deleteOne({ userId, deviceToken });
        
        res.json({ success: true, message: '토큰 삭제 완료' });
    } catch (error) {
        console.error('토큰 삭제 에러:', error);
        res.status(500).json({ success: false, error: error.message });
    }
});

// 푸시 전송 함수
async function sendPushNotification(userId, notification) {
    try {
        // 사용자의 모든 디바이스 토큰 조회
        const devices = await DeviceToken.find({ userId, platform: 'ios' });
        
        if (devices.length === 0) {
            console.log('등록된 디바이스 없음');
            return { success: false, message: '등록된 디바이스 없음' };
        }
        
        const apnNotification = new apn.Notification();
        apnNotification.alert = {
            title: notification.title,
            body: notification.body
        };
        apnNotification.badge = notification.badge || 1;
        apnNotification.sound = notification.sound || 'default';
        apnNotification.topic = process.env.BUNDLE_ID;
        apnNotification.payload = notification.data || {};
        
        if (notification.category) {
            apnNotification.category = notification.category;
        }
        
        if (notification.mutableContent) {
            apnNotification.mutableContent = 1;
        }
        
        const deviceTokens = devices.map(d => d.deviceToken);
        const result = await apnProvider.send(apnNotification, deviceTokens);
        
        // 실패한 토큰 처리
        if (result.failed.length > 0) {
            for (const failure of result.failed) {
                if (failure.status === '410') {
                    // 토큰이 더 이상 유효하지 않음 - DB에서 삭제
                    await DeviceToken.deleteOne({ deviceToken: failure.device });
                    console.log(`토큰 삭제: ${failure.device}`);
                }
            }
        }
        
        return {
            success: true,
            sent: result.sent.length,
            failed: result.failed.length
        };
        
    } catch (error) {
        console.error('푸시 전송 에러:', error);
        return { success: false, error: error.message };
    }
}

// 재능 요청 알림 API
app.post('/api/push/talent-request', async (req, res) => {
    try {
        const { receiverId, requesterName, talentTitle, requestId } = req.body;
        
        const notification = {
            title: '새로운 재능 요청',
            body: `${requesterName}님이 "${talentTitle}" 재능을 요청했습니다.`,
            category: 'TALENT_REQUEST',
            data: {
                type: 'talent_request',
                requestId: requestId,
                talentTitle: talentTitle
            }
        };
        
        const result = await sendPushNotification(receiverId, notification);
        res.json(result);
        
    } catch (error) {
        res.status(500).json({ success: false, error: error.message });
    }
});

// 메시지 알림 API
app.post('/api/push/message', async (req, res) => {
    try {
        const { receiverId, senderName, message, chatRoomId } = req.body;
        
        const notification = {
            title: senderName,
            body: message,
            category: 'MESSAGE',
            data: {
                type: 'message',
                chatRoomId: chatRoomId,
                senderId: req.body.senderId
            }
        };
        
        const result = await sendPushNotification(receiverId, notification);
        res.json(result);
        
    } catch (error) {
        res.status(500).json({ success: false, error: error.message });
    }
});

// 리뷰 알림 API
app.post('/api/push/review', async (req, res) => {
    try {
        const { receiverId, reviewerName, rating } = req.body;
        
        const stars = '⭐'.repeat(rating);
        
        const notification = {
            title: '새로운 리뷰',
            body: `${reviewerName}님이 ${stars} 리뷰를 남겼습니다.`,
            data: {
                type: 'review'
            }
        };
        
        const result = await sendPushNotification(receiverId, notification);
        res.json(result);
        
    } catch (error) {
        res.status(500).json({ success: false, error: error.message });
    }
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`서버 실행 중: ${PORT}`);
});