# Capacitor 푸시 알림 플러그인 설치
npm install @capacitor/push-notifications

# Firebase 관련 패키지 (선택적으로 필요할 수 있어)
npm install @capacitor-firebase/messaging

# 네이티브 프로젝트 동기화
npx cap sync

// android/build.gradle
buildscript {
    dependencies {
        // 이 줄을 추가!
        classpath 'com.google.gms:google-services:4.3.15'
    }
}

// android/app/build.gradle 맨 아래에 추가
apply plugin: 'com.google.gms.google-services'

// ios/App/App/AppDelegate.swift에 추가
import Firebase

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
    func application(_ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: 
        [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        FirebaseApp.configure()  // 이 줄 추가!
        return true
    }
}

// src/app/services/push-notification.service.ts
import { Injectable } from '@angular/core';
import { PushNotifications } from '@capacitor/push-notifications';
import { Router } from '@angular/router';

@Injectable({
  providedIn: 'root'
})
export class PushNotificationService {

  constructor(private router: Router) {}

  // 푸시 알림 초기화 메인 함수
  async initPush() {
    // 플랫폼 확인 (웹에서는 동작 안 함)
    const { Capacitor } = await import('@capacitor/core');
    if (!Capacitor.isNativePlatform()) {
      console.log('웹 환경에서는 푸시 알림을 지원하지 않아요!');
      return;
    }

    await this.registerNotifications();
    this.addListeners();
  }

  // 알림 권한 요청 및 등록
  async registerNotifications() {
    let permStatus = await PushNotifications.checkPermissions();

    if (permStatus.receive === 'prompt') {
      permStatus = await PushNotifications.requestPermissions();
    }

    if (permStatus.receive !== 'granted') {
      console.log('푸시 알림 권한이 거부되었어요!');
      return;
    }

    // FCM에 기기 등록
    await PushNotifications.register();
  }

  // 이벤트 리스너 등록
  addListeners() {
    // 등록 성공 → FCM 토큰 수신
    PushNotifications.addListener('registration', (token) => {
      console.log('FCM 토큰:', token.value);
      // 여기서 토큰을 서버에 저장해야 해!
      this.saveTokenToServer(token.value);
    });

    // 등록 실패
    PushNotifications.addListener('registrationError', (err) => {
      console.error('등록 실패:', err.error);
    });

    // 알림 수신 (앱이 포그라운드일 때)
    PushNotifications.addListener(
      'pushNotificationReceived',
      (notification) => {
        console.log('알림 수신:', notification);
        // 앱 내 알림 UI 표시 로직
        this.showInAppNotification(notification);
      }
    );

    // 알림 탭 (사용자가 알림 클릭)
    PushNotifications.addListener(
      'pushNotificationActionPerformed',
      (notification) => {
        console.log('알림 클릭:', notification);
        // 특정 페이지로 이동
        this.handleNotificationAction(notification);
      }
    );
  }

  // FCM 토큰을 서버에 저장
  private saveTokenToServer(token: string) {
    // HTTP 요청으로 서버에 토큰 전송
    // this.http.post('/api/save-token', { token }).subscribe();
    console.log('서버에 토큰 저장:', token);
  }

  // 앱 내 알림 표시
  private showInAppNotification(notification: any) {
    // Toast나 커스텀 UI로 알림 표시
    console.log('인앱 알림:', notification.title, notification.body);
  }

  // 알림 클릭 처리
  private handleNotificationAction(notification: any) {
    const data = notification.notification.data;
    if (data?.route) {
      this.router.navigate([data.route]);
    }
  }
}

// src/app/app.component.ts
import { Component, OnInit } from '@angular/core';
import { PushNotificationService } from './services/push-notification.service';

@Component({
  selector: 'app-root',
  templateUrl: 'app.component.html',
})
export class AppComponent implements OnInit {

  constructor(
    private pushService: PushNotificationService
  ) {}

  ngOnInit() {
    // 앱 시작 시 푸시 알림 초기화
    this.pushService.initPush();
  }
}

// server.js (Node.js 백엔드)
const admin = require('firebase-admin');

// Firebase Admin 초기화
const serviceAccount = require('./serviceAccountKey.json');
// serviceAccountKey.json은 Firebase 콘솔 → 프로젝트 설정 → 서비스 계정에서 다운로드

admin.initializeApp({
  credential: admin.credential.cert(serviceAccount)
});

// 단일 기기에 알림 보내기
async function sendPushToDevice(fcmToken, title, body, data = {}) {
  const message = {
    notification: {
      title: title,
      body: body,
    },
    data: data,  // 커스텀 데이터 (라우팅 정보 등)
    token: fcmToken,
    android: {
      notification: {
        icon: 'ic_notification',
        color: '#7ab8d4',
        sound: 'default',
        clickAction: 'FLUTTER_NOTIFICATION_CLICK'
      }
    },
    apns: {
      payload: {
        aps: {
          sound: 'default',
          badge: 1
        }
      }
    }
  };

  try {
    const response = await admin.messaging().send(message);
    console.log('알림 전송 성공:', response);
    return response;
  } catch (error) {
    console.error('알림 전송 실패:', error);
    throw error;
  }
}

// 여러 기기에 동시 알림 보내기 (멀티캐스트)
async function sendPushToMultipleDevices(tokens, title, body) {
  const message = {
    notification: { title, body },
    tokens: tokens,  // 토큰 배열 (최대 500개)
  };

  const response = await admin.messaging().sendEachForMulticast(message);
  console.log(`성공: ${response.successCount}, 실패: ${response.failureCount}`);
  return response;
}

// 토픽 구독자 전체에게 알림 보내기
async function sendPushToTopic(topic, title, body) {
  const message = {
    notification: { title, body },
    topic: topic,  // 예: 'news', 'promotions'
  };

  const response = await admin.messaging().send(message);
  console.log('토픽 알림 전송:', response);
  return response;
}

// 사용 예시
sendPushToDevice(
  'FCM_TOKEN_HERE',
  '새 메시지 도착! 📬',
  '재능넷에서 새로운 거래 요청이 왔어요.',
  { route: '/messages', messageId: '123' }
);

// HTTP v1 API 사용 예시 (Python)
import requests
import json

def send_push_notification(access_token, fcm_token, title, body):
    url = "https://fcm.googleapis.com/v1/projects/YOUR_PROJECT_ID/messages:send"
    
    headers = {
        "Authorization": f"Bearer {access_token}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "message": {
            "token": fcm_token,
            "notification": {
                "title": title,
                "body": body
            },
            "data": {
                "route": "/home",
                "type": "general"
            }
        }
    }
    
    response = requests.post(url, headers=headers, 
                            data=json.dumps(payload))
    return response.json()

// 클라이언트에서 토픽 구독
import { PushNotifications } from '@capacitor/push-notifications';

// 방법 1: Firebase JS SDK 사용
import { getMessaging, getToken } from 'firebase/messaging';

// 방법 2: 서버에서 토픽 구독 처리 (권장)
// 클라이언트에서 토큰을 서버로 보내고,
// 서버에서 Admin SDK로 구독 처리

// 서버 코드 (Node.js)
async function subscribeToTopic(tokens, topic) {
  const response = await admin.messaging()
    .subscribeToTopic(tokens, topic);
  console.log('구독 성공:', response.successCount);
}

async function unsubscribeFromTopic(tokens, topic) {
  const response = await admin.messaging()
    .unsubscribeFromTopic(tokens, topic);
  console.log('구독 취소:', response.successCount);
}

// 사용 예시
subscribeToTopic(['TOKEN1', 'TOKEN2'], 'promotions');
subscribeToTopic(['TOKEN1'], 'vip-users');

// 서버에서 리치 알림 보내기 (Node.js)
const richMessage = {
  notification: {
    title: '🎉 특가 상품 알림!',
    body: '오늘만 50% 할인! 지금 바로 확인하세요.',
    imageUrl: 'https://example.com/sale-banner.jpg'  // 이미지 URL
  },
  android: {
    notification: {
      icon: 'ic_sale',
      color: '#7ab8d4',
      sound: 'sale_sound',
      channelId: 'promotions',  // 알림 채널
      // 액션 버튼 추가
      actions: [
        {
          action: 'view',
          title: '지금 보기',
          icon: 'ic_view'
        },
        {
          action: 'dismiss',
          title: '나중에',
          icon: 'ic_dismiss'
        }
      ]
    }
  },
  apns: {
    payload: {
      aps: {
        sound: 'default',
        badge: 1,
        // iOS 인터랙티브 알림
        category: 'SALE_CATEGORY'
      }
    },
    fcmOptions: {
      imageUrl: 'https://example.com/sale-banner.jpg'
    }
  },
  token: fcmToken
};

await admin.messaging().send(richMessage);

// Android 알림 채널 생성 (네이티브 코드)
// android/app/src/main/java/.../MainActivity.java

import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.os.Build;

private void createNotificationChannels() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        NotificationManager manager = 
            getSystemService(NotificationManager.class);

        // 일반 알림 채널
        NotificationChannel generalChannel = new NotificationChannel(
            "general",
            "일반 알림",
            NotificationManager.IMPORTANCE_DEFAULT
        );
        generalChannel.setDescription("일반적인 앱 알림");
        manager.createNotificationChannel(generalChannel);

        // 중요 알림 채널 (높은 우선순위)
        NotificationChannel urgentChannel = new NotificationChannel(
            "urgent",
            "중요 알림",
            NotificationManager.IMPORTANCE_HIGH
        );
        urgentChannel.setDescription("긴급하고 중요한 알림");
        urgentChannel.enableVibration(true);
        manager.createNotificationChannel(urgentChannel);

        // 프로모션 채널 (낮은 우선순위)
        NotificationChannel promoChannel = new NotificationChannel(
            "promotions",
            "프로모션",
            NotificationManager.IMPORTANCE_LOW
        );
        promoChannel.setDescription("할인 및 이벤트 알림");
        manager.createNotificationChannel(promoChannel);
    }
}

// 사일런트 알림 (notification 없이 data만)
const silentMessage = {
  data: {
    type: 'sync',
    action: 'refresh_data',
    timestamp: Date.now().toString()
  },
  // notification 필드 없음!
  android: {
    priority: 'high'  // 백그라운드에서도 수신
  },
  token: fcmToken
};

// 클라이언트에서 처리
PushNotifications.addListener(
  'pushNotificationReceived',
  (notification) => {
    if (notification.data?.type === 'sync') {
      // 데이터 동기화 로직 실행
      this.syncData();
    }
  }
);

# OneSignal Capacitor 플러그인 설치
npm install onesignal-cordova-plugin
npx cap sync

// OneSignal 초기화 (app.component.ts)
import OneSignal from 'onesignal-cordova-plugin';

export class AppComponent implements OnInit {
  ngOnInit() {
    this.initOneSignal();
  }

  initOneSignal() {
    // OneSignal 초기화
    OneSignal.initialize('YOUR_ONESIGNAL_APP_ID');

    // 알림 권한 요청
    OneSignal.Notifications.requestPermission(true).then(
      (accepted) => {
        console.log('알림 권한:', accepted ? '허용' : '거부');
      }
    );

    // 알림 수신 이벤트
    OneSignal.Notifications.addEventListener(
      'foregroundWillDisplay',
      (event) => {
        console.log('알림 수신:', event.notification);
        event.preventDefault();  // 자동 표시 방지
        // 커스텀 처리 후 표시
        event.notification.display();
      }
    );

    // 알림 클릭 이벤트
    OneSignal.Notifications.addEventListener(
      'click',
      (event) => {
        const data = event.notification.additionalData;
        console.log('알림 클릭 데이터:', data);
      }
    );

    // 사용자 ID 가져오기
    OneSignal.User.pushSubscription.getIdAsync().then(
      (id) => {
        console.log('OneSignal Player ID:', id);
        // 서버에 저장
      }
    );
  }
}

// Firebase Analytics로 알림 성과 추적
// 알림 클릭 시 이벤트 로깅
PushNotifications.addListener(
  'pushNotificationActionPerformed',
  async (notification) => {
    // Firebase Analytics 이벤트 기록
    const { FirebaseAnalytics } = await import(
      '@capacitor-firebase/analytics'
    );
    
    await FirebaseAnalytics.logEvent({
      name: 'notification_opened',
      params: {
        notification_id: notification.notification.id,
        notification_type: notification.notification.data?.type,
        campaign: notification.notification.data?.campaign
      }
    });
    
    // 페이지 이동
    const route = notification.notification.data?.route;
    if (route) {
      this.router.navigate([route]);
    }
  }
);