import { useState, useEffect } from 'react';
import { useLocalStorage } from './use-local-storage';
import { Announcement } from '@/app/types/announcement';

type AnnouncementRead = {
  [id: string]: boolean;
};

export function useUnreadAnnouncements() {
  const [hasUnread, setHasUnread] = useState(false);
  const [announcements, setAnnouncements] = useState<Announcement[]>([]);
  const [readAnnouncements, setReadAnnouncements] = useLocalStorage<AnnouncementRead>('read-announcements', {});
  const [isLoading, setIsLoading] = useState(true);

  // Fetch announcements and check if there are any unread
  const checkForUnreadAnnouncements = async () => {
    try {
      setIsLoading(true);
      const response = await fetch('/api/announcements');
      
      if (!response.ok) {
        throw new Error('Failed to fetch announcements');
      }
      
      const data = await response.json();
      setAnnouncements(data);
      
      // Check if there are any unread announcements
      const hasUnreadAnnouncements = data.some((announcement: Announcement) => {
        return !readAnnouncements[announcement.id];
      });
      
      setHasUnread(hasUnreadAnnouncements);
    } catch (err) {
      console.error('Error checking for unread announcements:', err);
    } finally {
      setIsLoading(false);
    }
  };

  // Mark an announcement as read
  const markAsRead = (announcementId: string) => {
    setReadAnnouncements((prev: AnnouncementRead) => ({
      ...prev,
      [announcementId]: true
    }));
    
    // Check if there are still any unread announcements
    const hasUnreadAnnouncements = announcements.some(announcement => {
      return !readAnnouncements[announcement.id] && announcement.id !== announcementId;
    });
    
    setHasUnread(hasUnreadAnnouncements);
  };

  // Mark all announcements as read
  const markAllAsRead = () => {
    const allRead: AnnouncementRead = {};
    announcements.forEach(announcement => {
      allRead[announcement.id] = true;
    });
    
    setReadAnnouncements(allRead);
    setHasUnread(false);
  };

  // Check for unread announcements on mount
  useEffect(() => {
    checkForUnreadAnnouncements();
  }, []);

  return {
    hasUnread,
    isLoading,
    checkForUnreadAnnouncements,
    markAsRead,
    markAllAsRead
  };
}