import React, { createContext, useContext, useState, useEffect, useCallback } from 'react';
import { getUnreadNotifications, markAsRead, markAllAsRead, AlertNotificationDto } from '../services/alertApi';
import { requestNotificationPermission, showNotification } from '../services/notificationService';
import { useNotification } from '../hooks/useNotification';
import { useAuth } from './AuthContext';

interface AlertNotificationContextType {
  notifications: AlertNotificationDto[];
  unreadCount: number;
  latestNotification: AlertNotificationDto | null;
  loadNotifications: () => Promise<void>;
  markNotificationAsRead: (notificationId: number) => Promise<void>;
  /** 알림 팝업 닫기 (읽음 처리 + 목록에서 제거, id 없으면 목록에서만 제거) */
  dismissNotification: (notification: AlertNotificationDto) => Promise<void>;
  /** 현재 떠있는 알림 팝업 전체 닫기 (전체 읽음 처리 + 목록 비우기) */
  dismissAllNotifications: () => Promise<void>;
  requestPermission: () => Promise<boolean>;
}

const AlertNotificationContext = createContext<AlertNotificationContextType | undefined>(undefined);

export const useAlertNotification = () => {
  const context = useContext(AlertNotificationContext);
  if (!context) {
    throw new Error('useAlertNotification must be used within AlertNotificationProvider');
  }
  return context;
};

interface AlertNotificationProviderProps {
  children: React.ReactNode;
}

/**
 * 알림 Context Provider
 */
export const AlertNotificationProvider: React.FC<AlertNotificationProviderProps> = ({ children }) => {
  const { token } = useAuth();
  const [notifications, setNotifications] = useState<AlertNotificationDto[]>([]);
  const [latestNotification, setLatestNotification] = useState<AlertNotificationDto | null>(null);
  const [lastNotificationId, setLastNotificationId] = useState<number | null>(null);
  const [permissionRequested, setPermissionRequested] = useState(false);

  const handleSseNotification = useCallback((payload: { id: number; userId: number | null; symbol: string; message: string; koreanName: string; timestamp?: number }) => {
    const dto: AlertNotificationDto = {
      id: payload.id,
      symbol: payload.symbol,
      koreanName: payload.koreanName,
      message: payload.message,
      isRead: false,
      triggeredAt:
        payload.timestamp != null
          ? new Date(payload.timestamp).toISOString()
          : new Date().toISOString(),
    };
    setNotifications((prev) => [dto, ...prev.filter((n) => n.id !== payload.id)]);
    setLastNotificationId(payload.id);
    setLatestNotification(dto);
    playAlertSound();
    const title = '🎯 골든 애널리시스 - 통합 알림';
    const messageBody = payload.message?.split('\n')[0] || '';
    showNotification(title, {
      body: messageBody,
      icon: '/favicon.ico',
      tag: 'golden-analysis-unified-alert',
      requireInteraction: false,
      silent: true, // 브라우저 기본 알림음 비활성화 → 설정된 알림음만 재생
      data: { page: '#/alerts', notificationId: payload.id },
    });
  }, []);

  useNotification({
    token: token ?? null,
    onNotification: handleSseNotification,
    enabled: true,
    reconnectDelay: 3000,
  });

  const loadNotifications = useCallback(async () => {
    try {
      const data = await getUnreadNotifications();
      setNotifications(data);
      
      // 새로운 알림 감지 및 브라우저 알림 표시
      if (data.length > 0) {
        const newLatestNotification = data[0];
        
        // 이전과 다른 알림이면 브라우저 알림 표시 및 상태 업데이트
        if (newLatestNotification.id && newLatestNotification.id !== lastNotificationId) {
          setLastNotificationId(newLatestNotification.id);
          setLatestNotification(newLatestNotification); // 최신 알림 상태 업데이트
          
          // 알람소리 재생
          playAlertSound();
          
          // 브라우저 알림 표시 (항상 같은 tag 사용하여 이전 알림 자동 교체)
          const title = '🎯 골든 애널리시스 - 통합 알림';
          
          // 통합 알림 첫 줄만 표시
          const messageBody = newLatestNotification.message?.split('\n')[0] || '';
          
          showNotification(title, {
            body: messageBody,
            icon: '/favicon.ico',
            tag: 'golden-analysis-unified-alert', // 항상 같은 tag 사용 - 이전 알림 자동 교체
            requireInteraction: false, // 자동으로 사라지도록
            silent: true, // 브라우저 기본 알림음 비활성화 → 설정된 알림음만 재생
            data: {
              page: '#/alerts',
              notificationId: newLatestNotification.id,
            },
          });
        }
      }
    } catch (error) {
      console.error('알림 로드 실패:', error);
    }
  }, [lastNotificationId]);

  // 알람소리 재생 함수
  const playAlertSound = () => {
    const savedSound = localStorage.getItem('alertSound') || 'bell';
    
    // 무음 선택 시 소리 재생 안 함
    if (savedSound === 'silent') {
      console.log('🔇 알림소리: 무음 모드');
      return;
    }
    
    const soundUrl = getAlertSoundUrl(savedSound);
    const audio = new Audio(soundUrl);
    audio.play().catch(err => console.error('알림 소리 재생 실패:', err));
  };

  // 알람소리 URL 가져오기
  const getAlertSoundUrl = (soundType: string): string => {
    switch (soundType) {
      case 'silent':
        return ''; // 무음
      case 'bell':
        return 'https://assets.mixkit.co/active_storage/sfx/2869/2869-preview.mp3';
      case 'chime':
        return 'https://assets.mixkit.co/active_storage/sfx/2870/2870-preview.mp3';
      case 'alert':
        return 'https://assets.mixkit.co/active_storage/sfx/2868/2868-preview.mp3';
      case 'success':
        return 'https://assets.mixkit.co/active_storage/sfx/2018/2018-preview.mp3';
      case 'ding':
        return 'https://assets.mixkit.co/active_storage/sfx/2354/2354-preview.mp3';
      case 'message':
        return 'https://assets.mixkit.co/active_storage/sfx/2357/2357-preview.mp3';
      case 'notification':
        return 'https://assets.mixkit.co/active_storage/sfx/2359/2359-preview.mp3';
      case 'ring':
        return 'https://assets.mixkit.co/active_storage/sfx/2356/2356-preview.mp3';
      case 'alert2':
        return 'https://assets.mixkit.co/active_storage/sfx/2358/2358-preview.mp3';
      case 'positive':
        return 'https://assets.mixkit.co/active_storage/sfx/2000/2000-preview.mp3';
      case 'beep':
        return 'https://assets.mixkit.co/active_storage/sfx/2869/2869-preview.mp3';
      case 'coin':
        return 'https://assets.mixkit.co/active_storage/sfx/1998/1998-preview.mp3';
      case 'pop':
        return 'https://assets.mixkit.co/active_storage/sfx/2355/2355-preview.mp3';
      case 'tone':
        return 'https://assets.mixkit.co/active_storage/sfx/2867/2867-preview.mp3';
      case 'complete':
        return 'https://assets.mixkit.co/active_storage/sfx/2001/2001-preview.mp3';
      default:
        return 'https://assets.mixkit.co/active_storage/sfx/2869/2869-preview.mp3';
    }
  };

  const markNotificationAsRead = useCallback(async (notificationId: number) => {
    try {
      await markAsRead(notificationId);
      setNotifications(prev => prev.filter(n => n.id !== notificationId));
    } catch (error) {
      console.error('알림 읽음 처리 실패:', error);
    }
  }, []);

  const dismissNotification = useCallback(async (notification: AlertNotificationDto) => {
    if (notification.id != null) {
      try {
        await markAsRead(notification.id);
      } catch (error) {
        console.error('알림 읽음 처리 실패:', error);
      }
    }
    setNotifications(prev => prev.filter(n => n !== notification && (notification.id == null || n.id !== notification.id)));
  }, []);

  const dismissAllNotifications = useCallback(async () => {
    try {
      await markAllAsRead();
    } catch (error) {
      console.error('알림 전체 읽음 처리 실패:', error);
    }
    setNotifications([]);
  }, []);

  const requestPermission = useCallback(async () => {
    const granted = await requestNotificationPermission();
    setPermissionRequested(true);
    return granted;
  }, []);

  // 초기화: 기존 개별 알림 모두 정리 (한 번만 실행)
  useEffect(() => {
    const hasCleanedOldAlerts = localStorage.getItem('hasCleanedOldAlerts_v2');
    if (!hasCleanedOldAlerts) {
      markAllAsRead().then(() => {
        localStorage.setItem('hasCleanedOldAlerts_v2', 'true');
        console.log('✅ 기존 개별 알림 정리 완료 - 이제 통합 알림만 표시됩니다.');
      }).catch(err => {
        console.error('기존 알림 정리 실패:', err);
      });
    }
  }, []);

  // 초기 권한 요청
  useEffect(() => {
    if (!permissionRequested) {
      requestPermission();
    }
  }, [permissionRequested, requestPermission]);

  // 초기 로드
  useEffect(() => {
    loadNotifications();
  }, [loadNotifications]);

  // 폴백 폴링: SSE 미수신 시에도 알림 수신 (5초 간격 — 전략 평가 주기와 맞춤)
  useEffect(() => {
    const interval = setInterval(loadNotifications, 5000);
    return () => clearInterval(interval);
  }, [loadNotifications]);

  const value: AlertNotificationContextType = {
    notifications,
    unreadCount: notifications.length,
    latestNotification,
    loadNotifications,
    markNotificationAsRead,
    dismissNotification,
    dismissAllNotifications,
    requestPermission,
  };

  return (
    <AlertNotificationContext.Provider value={value}>
      {children}
    </AlertNotificationContext.Provider>
  );
};

export default AlertNotificationContext;

