import { useState, useEffect, useRef, useMemo, useDeferredValue, memo, useCallback } from 'react';
import { useNavigate } from 'react-router-dom';
import { motion, AnimatePresence } from 'framer-motion';
import { Clock, ChevronLeft, ChevronRight, ChevronDown, Tag, Search, ArrowLeft, Link2, X } from 'lucide-react';
import { useQuery, useInfiniteQuery } from '@tanstack/react-query';
import { useVirtualizer } from '@tanstack/react-virtual';
import { useInView } from 'react-intersection-observer';
import confetti from 'canvas-confetti';
import { getTodayKST } from '../../../utils/date';
import { getSchedules } from '../../../api/public/schedules';
import useScheduleStore from '../../../stores/useScheduleStore';

// HTML 엔티티 디코딩 함수
const decodeHtmlEntities = (text) => {
    if (!text) return '';
    const textarea = document.createElement('textarea');
    textarea.innerHTML = text;
    return textarea.value;
};

// 폭죽 애니메이션 함수
const fireBirthdayConfetti = () => {
    const duration = 3000;
    const animationEnd = Date.now() + duration;
    const colors = ['#ff69b4', '#ff1493', '#da70d6', '#ba55d3', '#9370db', '#8a2be2', '#ffd700', '#ff6347'];

    const randomInRange = (min, max) => Math.random() * (max - min) + min;

    const interval = setInterval(() => {
        const timeLeft = animationEnd - Date.now();

        if (timeLeft <= 0) {
            clearInterval(interval);
            return;
        }

        const particleCount = 50 * (timeLeft / duration);

        // 왼쪽에서 발사
        confetti({
            particleCount: Math.floor(particleCount),
            startVelocity: 30,
            spread: 60,
            origin: { x: randomInRange(0.1, 0.3), y: Math.random() - 0.2 },
            colors: colors,
            shapes: ['circle', 'square'],
            gravity: 1.2,
            scalar: randomInRange(0.8, 1.2),
            drift: randomInRange(-0.5, 0.5),
        });

        // 오른쪽에서 발사
        confetti({
            particleCount: Math.floor(particleCount),
            startVelocity: 30,
            spread: 60,
            origin: { x: randomInRange(0.7, 0.9), y: Math.random() - 0.2 },
            colors: colors,
            shapes: ['circle', 'square'],
            gravity: 1.2,
            scalar: randomInRange(0.8, 1.2),
            drift: randomInRange(-0.5, 0.5),
        });
    }, 250);

    // 초기 대형 폭죽
    confetti({
        particleCount: 100,
        spread: 100,
        origin: { x: 0.5, y: 0.6 },
        colors: colors,
        shapes: ['circle', 'square'],
        startVelocity: 45,
    });
};

// 생일 카드 컴포넌트
function BirthdayCard({ schedule, formatted, showYear = false, onClick }) {
    return (
        <div
            onClick={onClick}
            className="relative overflow-hidden bg-gradient-to-r from-pink-400 via-purple-400 to-indigo-400 rounded-2xl shadow-lg hover:shadow-xl transition-shadow cursor-pointer"
        >
            {/* 배경 장식 */}
            <div className="absolute inset-0 overflow-hidden">
                <div className="absolute -top-4 -right-4 w-24 h-24 bg-white/10 rounded-full" />
                <div className="absolute -bottom-6 -left-6 w-32 h-32 bg-white/10 rounded-full" />
                <div className="absolute top-1/2 right-1/4 w-16 h-16 bg-white/5 rounded-full" />
                <div className="absolute bottom-4 left-12 text-xl animate-pulse">🎉</div>
            </div>

            <div className="relative flex items-center p-4 gap-4">
                {/* 멤버 사진 */}
                {schedule.member_image && (
                    <div className="flex-shrink-0">
                        <div className="w-20 h-20 rounded-full border-4 border-white/50 shadow-lg overflow-hidden bg-white">
                            <img
                                src={schedule.member_image}
                                alt={schedule.member_names}
                                className="w-full h-full object-cover"
                            />
                        </div>
                    </div>
                )}

                {/* 내용 */}
                <div className="flex-1 text-white flex items-center gap-3">
                    <span className="text-4xl">🎂</span>
                    <h3 className="font-bold text-2xl tracking-wide">
                        {schedule.title}
                    </h3>
                </div>

                {/* 날짜 뱃지 */}
                <div className="flex-shrink-0 bg-white/20 backdrop-blur-sm rounded-xl px-4 py-2 text-center">
                    {showYear && (
                        <div className="text-white/70 text-xs font-medium">
                            {new Date(schedule.date).getFullYear()}
                        </div>
                    )}
                    <div className="text-white/70 text-xs font-medium">
                        {new Date(schedule.date).getMonth() + 1}월
                    </div>
                    <div className="text-white text-2xl font-bold">
                        {formatted.day}
                    </div>
                </div>
            </div>
        </div>
    );
}

function Schedule() {
    const navigate = useNavigate();

    // 상태 관리 (zustand store)
    const {
        currentDate,
        setCurrentDate,
        selectedDate: storedSelectedDate,
        setSelectedDate: setStoredSelectedDate,
        selectedCategories,
        setSelectedCategories,
        isSearchMode,
        setIsSearchMode,
        searchInput,
        setSearchInput,
        searchTerm,
        setSearchTerm,
    } = useScheduleStore();

    // 초기값 설정 (store에 값이 없으면 오늘 날짜)
    const selectedDate = storedSelectedDate === undefined ? getTodayKST() : storedSelectedDate;
    const setSelectedDate = setStoredSelectedDate;

    const [showYearMonthPicker, setShowYearMonthPicker] = useState(false);
    const [viewMode, setViewMode] = useState('yearMonth');
    const [slideDirection, setSlideDirection] = useState(0);
    const pickerRef = useRef(null);

    // 월별 일정 데이터 로드 (useQuery)
    const year = currentDate.getFullYear();
    const month = currentDate.getMonth();
    const { data: schedules = [], isLoading: loading } = useQuery({
        queryKey: ['schedules', year, month + 1],
        queryFn: () => getSchedules(year, month + 1),
    });

    // 카테고리는 일정 데이터에서 추출
    const categories = useMemo(() => {
        const categoryMap = new Map();
        schedules.forEach(s => {
            if (s.category_id && !categoryMap.has(s.category_id)) {
                categoryMap.set(s.category_id, {
                    id: s.category_id,
                    name: s.category_name,
                    color: s.category_color,
                });
            }
        });
        return Array.from(categoryMap.values());
    }, [schedules]);

    // 오늘 생일이 있으면 폭죽 발사 (하루에 한 번만)
    useEffect(() => {
        if (loading || schedules.length === 0) return;

        const today = getTodayKST();
        const confettiKey = `birthday-confetti-${today}`;

        // 이미 오늘 폭죽을 봤으면 스킵
        if (localStorage.getItem(confettiKey)) return;

        const hasBirthdayToday = schedules.some(s => {
            if (!s.is_birthday) return false;
            const scheduleDate = s.date ? s.date.split('T')[0] : '';
            return scheduleDate === today;
        });

        if (hasBirthdayToday) {
            // 약간의 딜레이 후 폭죽 발사 (페이지 렌더링 완료 후)
            const timer = setTimeout(() => {
                fireBirthdayConfetti();
                localStorage.setItem(confettiKey, 'true');
            }, 500);
            return () => clearTimeout(timer);
        }
    }, [schedules, loading]);

    // 카테고리 필터 툴팁
    const [showCategoryTooltip, setShowCategoryTooltip] = useState(false);
    const categoryRef = useRef(null);
    const scrollContainerRef = useRef(null); // 일정 목록 스크롤 컨테이너
    const searchContainerRef = useRef(null); // 검색 컨테이너 (외부 클릭 감지용)

    // 검색 관련 로컬 상태 (store에서 관리하지 않는 것들)
    const [originalSearchQuery, setOriginalSearchQuery] = useState(''); // 사용자가 직접 입력한 원본 값 (필터링용)
    const [showSuggestions, setShowSuggestions] = useState(false);
    const [selectedSuggestionIndex, setSelectedSuggestionIndex] = useState(-1);
    const [suggestions, setSuggestions] = useState([]); // 추천 검색어 목록
    const [isLoadingSuggestions, setIsLoadingSuggestions] = useState(false);
    const SEARCH_LIMIT = 20; // 페이지당 20개
    const ESTIMATED_ITEM_HEIGHT = 120; // 아이템 추정 높이 (동적 측정)
    
    // Intersection Observer for infinite scroll
    const { ref: loadMoreRef, inView } = useInView({
        threshold: 0,
        rootMargin: '100px',
    });
    
    // useInfiniteQuery for search
    const {
        data: searchData,
        fetchNextPage,
        hasNextPage,
        isFetchingNextPage,
        isLoading: searchLoading,
        refetch: refetchSearch,
    } = useInfiniteQuery({
        queryKey: ['scheduleSearch', searchTerm],
        queryFn: async ({ pageParam = 0 }) => {
            const response = await fetch(
                `/api/schedules?search=${encodeURIComponent(searchTerm)}&offset=${pageParam}&limit=${SEARCH_LIMIT}`
            );
            if (!response.ok) throw new Error('Search failed');
            return response.json();
        },
        getNextPageParam: (lastPage) => {
            if (lastPage.hasMore) {
                return lastPage.offset + lastPage.schedules.length;
            }
            return undefined;
        },
        enabled: !!searchTerm && isSearchMode,
    });
    
    // Flatten search results and normalize format to match monthly data
    const searchResults = useMemo(() => {
        if (!searchData?.pages) return [];
        return searchData.pages.flatMap(page =>
            page.schedules.map(s => {
                // datetime → date + time 분리
                const dateTime = s.datetime || '';
                const [date, time] = dateTime.includes('T')
                    ? dateTime.split('T')
                    : [dateTime, null];

                return {
                    ...s,
                    date,
                    time,
                    // category 객체 → flat 구조
                    category_id: s.category?.id,
                    category_name: s.category?.name,
                    category_color: s.category?.color,
                    // members 배열 → 쉼표 구분 문자열 (기존 호환)
                    member_names: Array.isArray(s.members) ? s.members.join(',') : s.member_names,
                };
            })
        );
    }, [searchData]);
    
    const searchTotal = searchData?.pages?.[0]?.total || 0;
    

    
    // Auto fetch next page when scrolled to bottom
    // inView가 true로 변경될 때만 fetch (중복 요청 방지)
    const prevInViewRef = useRef(false);
    useEffect(() => {
        // inView가 false→true로 변경될 때만 fetch
        if (inView && !prevInViewRef.current && hasNextPage && !isFetchingNextPage && isSearchMode && searchTerm) {
            fetchNextPage();
        }
        prevInViewRef.current = inView;
    }, [inView, hasNextPage, isFetchingNextPage, fetchNextPage, isSearchMode, searchTerm]);

    // 검색어 자동완성 API 호출 (debounce 적용)
    useEffect(() => {
        // 검색어가 비어있으면 초기화
        if (!originalSearchQuery || originalSearchQuery.trim().length === 0) {
            setSuggestions([]);
            return;
        }

        // debounce: 200ms 후에 API 호출
        const timeoutId = setTimeout(async () => {
            setIsLoadingSuggestions(true);
            try {
                const response = await fetch(`/api/schedules/suggestions?q=${encodeURIComponent(originalSearchQuery)}&limit=10`);
                if (response.ok) {
                    const data = await response.json();
                    setSuggestions(data.suggestions || []);
                }
            } catch (error) {
                console.error('추천 검색어 API 오류:', error);
                setSuggestions([]);
            } finally {
                setIsLoadingSuggestions(false);
            }
        }, 200);

        return () => clearTimeout(timeoutId);
    }, [originalSearchQuery]);

    // 카테고리/일정 데이터는 상단에서 useQuery로 관리됨

    // 외부 클릭시 팝업 닫기
    useEffect(() => {
        const handleClickOutside = (event) => {
            if (pickerRef.current && !pickerRef.current.contains(event.target)) {
                setShowYearMonthPicker(false);
                setViewMode('yearMonth');
            }
            if (categoryRef.current && !categoryRef.current.contains(event.target)) {
                setShowCategoryTooltip(false);
            }
            // 검색 추천 드롭다운 외부 클릭 시 닫기
            if (searchContainerRef.current && !searchContainerRef.current.contains(event.target)) {
                setShowSuggestions(false);
                setSelectedSuggestionIndex(-1);
            }
        };

        document.addEventListener('mousedown', handleClickOutside);
        return () => document.removeEventListener('mousedown', handleClickOutside);
    }, []);

    // 날짜 변경 시 스크롤 맨 위로 초기화
    useEffect(() => {
        if (scrollContainerRef.current) {
            scrollContainerRef.current.scrollTop = 0;
        }
    }, [selectedDate]);

    // 달력 관련 함수
    const getDaysInMonth = (y, m) => new Date(y, m + 1, 0).getDate();
    const getFirstDayOfMonth = (y, m) => new Date(y, m, 1).getDay();

    // year, month는 상단에서 이미 선언됨 (useQuery)
    const daysInMonth = getDaysInMonth(year, month);
    const firstDay = getFirstDayOfMonth(year, month);

    const days = ['일', '월', '화', '수', '목', '금', '토'];

    // 스케줄 데이터를 지연 처리하여 달력 UI 응답성 향상
    const deferredSchedules = useDeferredValue(schedules);

    // 일정 날짜별 맵 (O(1) 조회용) - 지연된 데이터로 점 표시
    const scheduleDateMap = useMemo(() => {
        const map = new Map();
        deferredSchedules.forEach(s => {
            const dateStr = s.date ? s.date.split('T')[0] : '';
            if (!map.has(dateStr)) {
                map.set(dateStr, s);
            }
        });
        return map;
    }, [deferredSchedules]);

    // 해당 날짜의 첫 번째 일정 카테고리 색상 (O(1))
    const getScheduleColor = (day) => {
        const dateStr = `${year}-${String(month + 1).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
        const schedule = scheduleDateMap.get(dateStr);
        if (!schedule) return null;
        // schedule에서 직접 색상 가져오기
        if (schedule.category_color) return schedule.category_color;
        const cat = categories.find(c => c.id === schedule.category_id);
        return cat?.color || '#4A7C59';
    };

    // 해당 날짜에 일정이 있는지 확인 (O(1))
    const hasSchedule = (day) => {
        const dateStr = `${year}-${String(month + 1).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
        return scheduleDateMap.has(dateStr);
    };

    const prevMonth = () => {
        setSlideDirection(-1);
        const newDate = new Date(year, month - 1, 1);
        setCurrentDate(newDate);
        // 이번달이면 오늘, 다른 달이면 1일 선택
        const today = new Date();
        if (newDate.getFullYear() === today.getFullYear() && newDate.getMonth() === today.getMonth()) {
            setSelectedDate(getTodayKST());
        } else {
            const firstDay = `${newDate.getFullYear()}-${String(newDate.getMonth() + 1).padStart(2, '0')}-01`;
            setSelectedDate(firstDay);
        }
    };

    const nextMonth = () => {
        setSlideDirection(1);
        const newDate = new Date(year, month + 1, 1);
        setCurrentDate(newDate);
        // 이번달이면 오늘, 다른 달이면 1일 선택
        const today = new Date();
        if (newDate.getFullYear() === today.getFullYear() && newDate.getMonth() === today.getMonth()) {
            setSelectedDate(getTodayKST());
        } else {
            const firstDay = `${newDate.getFullYear()}-${String(newDate.getMonth() + 1).padStart(2, '0')}-01`;
            setSelectedDate(firstDay);
        }
    };

    // 날짜 선택 (토글 없이 항상 선택)
    const selectDate = (day) => {
        const dateStr = `${year}-${String(month + 1).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
        setSelectedDate(dateStr);
    };

    const selectYear = (newYear) => {
        setCurrentDate(new Date(newYear, month, 1));
        setViewMode('months');
    };

    const selectMonth = (newMonth) => {
        const newDate = new Date(year, newMonth, 1);
        setCurrentDate(newDate);
        // 이번달이면 오늘, 다른 달이면 1일 선택
        const today = new Date();
        if (newDate.getFullYear() === today.getFullYear() && newDate.getMonth() === today.getMonth()) {
            setSelectedDate(getTodayKST());
        } else {
            const firstDay = `${year}-${String(newMonth + 1).padStart(2, '0')}-01`;
            setSelectedDate(firstDay);
        }
        setShowYearMonthPicker(false);
        setViewMode('yearMonth');
    };

    // 카테고리 토글
    const toggleCategory = (categoryId) => {
        if (selectedCategories.includes(categoryId)) {
            setSelectedCategories(selectedCategories.filter(id => id !== categoryId));
        } else {
            setSelectedCategories([...selectedCategories, categoryId]);
        }
    };

    // 필터링된 스케줄 (useMemo로 성능 최적화, 시간순 정렬)
    const currentYearMonth = `${year}-${String(month + 1).padStart(2, '0')}`;
    
    const filteredSchedules = useMemo(() => {
        // 검색 모드일 때
        if (isSearchMode) {
            // 검색 전엔 빈 목록, 검색 후엔 API 결과 (Meilisearch 유사도순 유지)
            if (!searchTerm) return [];
            // 카테고리 필터링 적용
            if (selectedCategories.length === 0) return searchResults;
            return searchResults.filter(s => selectedCategories.includes(s.category_id));
        }

        
        // 일반 모드: 기존 필터링
        return schedules
            .filter(s => {
                const scheduleDate = s.date ? s.date.split('T')[0] : '';
                const matchesDate = selectedDate 
                    ? scheduleDate === selectedDate
                    : scheduleDate.startsWith(currentYearMonth);
                const matchesCategory = selectedCategories.length === 0 || selectedCategories.includes(s.category_id);
                return matchesDate && matchesCategory;
            })
            .sort((a, b) => {
                const dateA = a.date ? a.date.split('T')[0] : '';
                const dateB = b.date ? b.date.split('T')[0] : '';
                if (dateA !== dateB) return dateA.localeCompare(dateB);
                const timeA = a.time || '00:00:00';
                const timeB = b.time || '00:00:00';
                return timeA.localeCompare(timeB);
            });
    }, [schedules, selectedDate, currentYearMonth, selectedCategories, isSearchMode, searchTerm, searchResults]);

    // 가상 스크롤 설정 (검색 모드에서만 활성화, 동적 높이 지원)
    const virtualizer = useVirtualizer({
        count: isSearchMode && searchTerm ? filteredSchedules.length : 0,
        getScrollElement: () => scrollContainerRef.current,
        estimateSize: () => ESTIMATED_ITEM_HEIGHT,
        overscan: 5, // 버퍼 아이템 수
    });

    // 카테고리별 카운트 맵 (useMemo로 미리 계산) - 선택된 날짜 기준
    const categoryCounts = useMemo(() => {
        // 검색어가 있을 때만 검색 결과 사용, 아니면 기존 schedules 사용
        const source = (isSearchMode && searchTerm) ? searchResults : schedules;
        const counts = new Map();
        let total = 0;

        source.forEach(s => {
            const scheduleDate = s.date ? s.date.split('T')[0] : '';
            // 검색 모드에서 검색어가 있을 때는 전체 대상
            // 그 외에는 선택된 날짜 기준으로 필터링
            if (!(isSearchMode && searchTerm) && selectedDate) {
                if (scheduleDate !== selectedDate) return;
            }

            const catId = s.category_id;
            if (catId) {
                counts.set(catId, (counts.get(catId) || 0) + 1);
                total++;
            }
        });

        counts.set('total', total);
        return counts;
    }, [schedules, searchResults, isSearchMode, searchTerm, selectedDate]);

    const formatDate = (dateStr) => {
        const date = new Date(dateStr);
        const dayNames = ['일', '월', '화', '수', '목', '금', '토'];
        return {
            month: date.getMonth() + 1,
            day: date.getDate(),
            weekday: dayNames[date.getDay()],
        };
    };

    // 일정 클릭 핸들러
    const handleScheduleClick = (schedule) => {
        // 생일 일정은 생일 페이지로 이동
        if (schedule.is_birthday || String(schedule.id).startsWith('birthday-')) {
            const scheduleYear = new Date(schedule.date).getFullYear();
            const memberName = schedule.member_names; // 한글 이름
            navigate(`/birthday/${encodeURIComponent(memberName)}/${scheduleYear}`);
            return;
        }

        // 유튜브(id=2), X(id=3), 콘서트(id=6) 카테고리는 상세 페이지로 이동
        if (schedule.category_id === 2 || schedule.category_id === 3 || schedule.category_id === 6) {
            navigate(`/schedule/${schedule.id}`);
            return;
        }

        // 설명이 없고 URL만 있으면 바로 링크 열기
        if (!schedule.description && schedule.source?.url) {
            window.open(schedule.source?.url, '_blank');
        } else {
            // 상세 페이지로 이동
            navigate(`/schedule/${schedule.id}`);
        }
    };

    const currentYear = new Date().getFullYear();
    const isCurrentYear = (y) => y === currentYear;
    const isCurrentMonth = (m) => {
        const now = new Date();
        return year === now.getFullYear() && m === now.getMonth();
    };

    // 연도 선택 범위
    const [yearRangeStart, setYearRangeStart] = useState(currentYear - 1);
    const yearRange = Array.from({ length: 12 }, (_, i) => yearRangeStart + i);
    const monthNames = ['1월', '2월', '3월', '4월', '5월', '6월', '7월', '8월', '9월', '10월', '11월', '12월'];
    const prevYearRange = () => setYearRangeStart(prev => prev - 3);
    const nextYearRange = () => setYearRangeStart(prev => prev + 3);

    // 선택된 카테고리 이름
    const getSelectedCategoryNames = () => {
        if (selectedCategories.length === 0) return '전체';
        const names = selectedCategories.map(id => {
            const cat = categories.find(c => c.id === id);
            return cat?.name || '';
        }).filter(Boolean);
        if (names.length <= 2) return names.join(', ');
        return `${names.slice(0, 2).join(', ')} 외 ${names.length - 2}개`;
    };

    // 카테고리 색상 가져오기 (schedule 객체에서 직접 가져오거나 categories에서 조회)
    const getCategoryColor = useCallback((categoryId, schedule = null) => {
        if (schedule?.category_color) return schedule.category_color;
        const cat = categories.find(c => c.id === categoryId);
        return cat?.color || '#808080';
    }, [categories]);

    const getCategoryName = useCallback((categoryId, schedule = null) => {
        if (schedule?.category_name) return schedule.category_name;
        const cat = categories.find(c => c.id === categoryId);
        return cat?.name || '';
    }, [categories]);

    // 정렬된 카테고리 목록 (메모이제이션으로 깜빡임 방지)
    const sortedCategories = useMemo(() => {
        return categories
            .map(category => ({
                ...category,
                count: categoryCounts.get(category.id) || 0
            }))
            .filter(category => category.count > 0)
            .sort((a, b) => {
                if (a.name === '기타') return 1;
                if (b.name === '기타') return -1;
                return b.count - a.count;
            });
    }, [categories, categoryCounts]);

    return (
        <div className="h-[calc(100vh-64px)] overflow-hidden flex flex-col">
            <div className="flex-1 flex flex-col overflow-hidden max-w-7xl mx-auto px-6 py-8 w-full">
                {/* 헤더 */}
                <div className="flex-shrink-0 text-center mb-8">
                    <motion.h1
                        initial={{ opacity: 0, y: -20 }}
                        animate={{ opacity: 1, y: 0 }}
                        className="text-4xl font-bold mb-4"
                    >
                        일정
                    </motion.h1>
                    <motion.p
                        initial={{ opacity: 0 }}
                        animate={{ opacity: 1 }}
                        transition={{ delay: 0.2 }}
                        className="text-gray-500"
                    >
                        프로미스나인의 다가오는 일정을 확인하세요
                    </motion.p>
                </div>

                <div className="flex-1 min-h-0 grid grid-cols-3 gap-8">
                    {/* 왼쪽: 달력 + 카테고리 */}
                    <div className="space-y-6">
                        {/* 달력 */}
                        <motion.div
                            initial={{ opacity: 0, x: -20 }}
                            animate={{ opacity: isSearchMode ? 0.4 : 1, x: 0 }}
                            transition={{ duration: 0.2 }}
                            className={`${isSearchMode ? 'pointer-events-none' : ''}`}
                        >
                            <div className="bg-white rounded-2xl shadow-sm pt-8 px-8 pb-6 relative transition-all duration-200" ref={pickerRef}>
                            {/* 달력 헤더 */}
                            <div className="flex items-center justify-between mb-8">
                                <button
                                    onClick={prevMonth}
                                    className="p-2 hover:bg-gray-100 rounded-full transition-colors"
                                >
                                    <ChevronLeft size={24} />
                                </button>
                                <button
                                    onClick={() => setShowYearMonthPicker(!showYearMonthPicker)}
                                    className="flex items-center gap-1 text-xl font-bold hover:text-primary transition-colors"
                                >
                                    <span>{year}년 {month + 1}월</span>
                                    <ChevronDown size={20} className={`transition-transform ${showYearMonthPicker ? 'rotate-180' : ''}`} />
                                </button>
                                <button
                                    onClick={nextMonth}
                                    className="p-2 hover:bg-gray-100 rounded-full transition-colors"
                                >
                                    <ChevronRight size={24} />
                                </button>
                            </div>

                            {/* 년/월 선택 팝업 */}
                            <AnimatePresence>
                                {showYearMonthPicker && (
                                    <motion.div
                                        initial={{ opacity: 0, y: -10 }}
                                        animate={{ opacity: 1, y: 0 }}
                                        exit={{ opacity: 0, y: -10 }}
                                        className="absolute top-20 left-8 right-8 mx-auto w-80 bg-white rounded-xl shadow-lg border border-gray-200 p-4 z-10"
                                    >
                                        <div className="flex items-center justify-between mb-4">
                                            <button onClick={prevYearRange} className="p-1.5 hover:bg-gray-100 rounded-lg transition-colors">
                                                <ChevronLeft size={20} className="text-gray-600" />
                                            </button>
                                            <span className="font-medium text-gray-900">
                                                {viewMode === 'yearMonth' ? `${yearRange[0]} - ${yearRange[yearRange.length - 1]}` : `${year}년`}
                                            </span>
                                            <button onClick={nextYearRange} className="p-1.5 hover:bg-gray-100 rounded-lg transition-colors">
                                                <ChevronRight size={20} className="text-gray-600" />
                                            </button>
                                        </div>

                                        <AnimatePresence mode="wait">
                                            {viewMode === 'yearMonth' && (
                                                <motion.div key="yearMonth" initial={{ opacity: 0 }} animate={{ opacity: 1 }} exit={{ opacity: 0 }} transition={{ duration: 0.15 }}>
                                                    <div className="text-center text-sm text-gray-500 mb-3">년도</div>
                                                    <div className="grid grid-cols-4 gap-2 mb-4">
                                                        {yearRange.map((y) => (
                                                            <button
                                                                key={y}
                                                                onClick={() => selectYear(y)}
                                                                className={`py-2 text-sm rounded-lg transition-colors ${
                                                                    year === y ? 'bg-primary text-white' :
                                                                    isCurrentYear(y) && year !== y ? 'text-primary font-medium hover:bg-primary/10' :
                                                                    'hover:bg-gray-100 text-gray-700'
                                                                }`}
                                                            >
                                                                {y}
                                                            </button>
                                                        ))}
                                                    </div>
                                                    <div className="text-center text-sm text-gray-500 mb-3">월</div>
                                                    <div className="grid grid-cols-4 gap-2">
                                                        {monthNames.map((m, i) => (
                                                            <button
                                                                key={m}
                                                                onClick={() => selectMonth(i)}
                                                                className={`py-2 text-sm rounded-lg transition-colors ${
                                                                    month === i ? 'bg-primary text-white' :
                                                                    isCurrentMonth(i) && month !== i ? 'text-primary font-medium hover:bg-primary/10' :
                                                                    'hover:bg-gray-100 text-gray-700'
                                                                }`}
                                                            >
                                                                {m}
                                                            </button>
                                                        ))}
                                                    </div>
                                                </motion.div>
                                            )}
                                            {viewMode === 'months' && (
                                                <motion.div key="months" initial={{ opacity: 0 }} animate={{ opacity: 1 }} exit={{ opacity: 0 }} transition={{ duration: 0.15 }}>
                                                    <div className="text-center text-sm text-gray-500 mb-3">월 선택</div>
                                                    <div className="grid grid-cols-4 gap-2">
                                                        {monthNames.map((m, i) => (
                                                            <button
                                                                key={m}
                                                                onClick={() => selectMonth(i)}
                                                                className={`py-2.5 text-sm rounded-lg transition-colors ${
                                                                    month === i ? 'bg-primary text-white' :
                                                                    isCurrentMonth(i) && month !== i ? 'text-primary font-medium hover:bg-primary/10' :
                                                                    'hover:bg-gray-100 text-gray-700'
                                                                }`}
                                                            >
                                                                {m}
                                                            </button>
                                                        ))}
                                                    </div>
                                                </motion.div>
                                            )}
                                        </AnimatePresence>
                                    </motion.div>
                                )}
                            </AnimatePresence>

                            {/* 요일 헤더 + 날짜 그리드 */}
                            <AnimatePresence mode="wait" initial={false}>
                                <motion.div
                                    key={`${year}-${month}`}
                                    initial={{ opacity: 0, x: slideDirection * 20 }}
                                    animate={{ opacity: 1, x: 0 }}
                                    exit={{ opacity: 0, x: slideDirection * -20 }}
                                    transition={{ duration: 0.08 }}
                                    layout
                                >
                                    <div className="grid grid-cols-7 mb-4">
                                        {days.map((day, i) => (
                                            <div
                                                key={day}
                                                className={`text-center text-sm font-medium py-2 ${
                                                    i === 0 ? 'text-red-500' : i === 6 ? 'text-blue-500' : 'text-gray-500'
                                                }`}
                                            >
                                                {day}
                                            </div>
                                        ))}
                                    </div>

                                    <div className="grid grid-cols-7 gap-1">
                                        {/* 전달 날짜 */}
                                        {Array.from({ length: firstDay }).map((_, i) => {
                                            const prevMonthDays = getDaysInMonth(year, month - 1);
                                            const day = prevMonthDays - firstDay + i + 1;
                                            return (
                                                <div key={`prev-${i}`} className="aspect-square flex items-center justify-center text-gray-300 text-base">
                                                    {day}
                                                </div>
                                            );
                                        })}

                                        {/* 현재 달 날짜 */}
                                        {Array.from({ length: daysInMonth }).map((_, i) => {
                                            const day = i + 1;
                                            const dateStr = `${year}-${String(month + 1).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
                                            const isSelected = selectedDate === dateStr;
                                            const hasEvent = hasSchedule(day);
                                            const eventColor = getScheduleColor(day);
                                            const dayOfWeek = (firstDay + i) % 7;
                                            const isToday = new Date().toDateString() === new Date(year, month, day).toDateString();
                                            
                                            // 해당 날짜의 일정 목록 (점 표시용, 최대 3개)
                                            const daySchedules = schedules.filter(s => {
                                                const scheduleDate = s.date ? s.date.split('T')[0] : '';
                                                const dateStr = `${year}-${String(month + 1).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
                                                return scheduleDate === dateStr;
                                            }).slice(0, 3);

                                            return (
                                                <button
                                                    key={day}
                                                    onClick={() => selectDate(day)}
                                                    className={`aspect-square flex flex-col items-center justify-center rounded-full text-base font-medium transition-all relative hover:bg-gray-100
                                                        ${isSelected ? 'bg-primary text-white shadow-lg hover:bg-primary' : ''}
                                                        ${isToday && !isSelected ? 'text-primary font-bold' : ''}
                                                        ${dayOfWeek === 0 && !isSelected && !isToday ? 'text-red-500' : ''}
                                                        ${dayOfWeek === 6 && !isSelected && !isToday ? 'text-blue-500' : ''}
                                                    `}
                                                >
                                                    <span>{day}</span>
                                                    {/* 점: 선택되지 않은 날짜에만 표시, 최대 3개 */}
                                                    {!isSelected && daySchedules.length > 0 && (
                                                        <span className="absolute bottom-1 flex gap-0.5">
                                                            {daySchedules.map((schedule, idx) => (
                                                                <span
                                                                    key={idx}
                                                                    className="w-1 h-1 rounded-full"
                                                                    style={{ backgroundColor: getCategoryColor(schedule.category_id, schedule) }}
                                                                />
                                                            ))}
                                                        </span>
                                                    )}
                                                </button>
                                            );
                                        })}

                                        {/* 다음달 날짜 */}
                                        {(() => {
                                            const totalCells = firstDay + daysInMonth;
                                            const remainder = totalCells % 7;
                                            const nextDays = remainder === 0 ? 0 : 7 - remainder;
                                            return Array.from({ length: nextDays }).map((_, i) => (
                                                <div key={`next-${i}`} className="aspect-square flex items-center justify-center text-gray-300 text-base">
                                                    {i + 1}
                                                </div>
                                            ));
                                        })()}
                                    </div>
                                </motion.div>
                            </AnimatePresence>

                            {/* 범례 */}
                            <div className="mt-6 pt-4 border-t border-gray-100 flex items-center text-sm">
                                <div className="flex items-center gap-1.5 text-gray-500">
                                    <span className="w-2 h-2 rounded-full bg-primary flex-shrink-0" />
                                    <span className="leading-none">일정 있음</span>
                                </div>
                            </div>
                        </div>
                    </motion.div>

                        {/* 카테고리 필터 */}
                        <motion.div 
                            animate={{ opacity: isSearchMode && searchResults.length === 0 ? 0.4 : 1 }}
                            transition={{ duration: 0.2 }}
                            className={`bg-white rounded-2xl shadow-sm p-6 mt-4 ${isSearchMode && searchResults.length === 0 ? 'pointer-events-none' : ''}`}
                        >
                            <h3 className="font-bold text-gray-900 mb-4">카테고리</h3>
                            <div className="space-y-1">
                                {/* 전체 */}
                                <button
                                    onClick={() => setSelectedCategories([])}
                                    className={`w-full flex items-center justify-between px-3 py-3 rounded-lg transition-colors ${
                                        selectedCategories.length === 0 ? 'bg-primary/10 text-primary' : 'hover:bg-gray-50'
                                    }`}
                                >
                                    <div className="flex items-center gap-2">
                                        <span className="w-3 h-3 rounded-full bg-gray-400" />
                                        <span>전체</span>
                                    </div>
                                    <span className="text-sm text-gray-400">
                                        {categoryCounts.get('total') || 0}
                                    </span>
                                </button>

                                {/* 개별 카테고리 - useMemo로 정렬됨 */}
                                {sortedCategories.map(category => {
                                    const isSelected = selectedCategories.includes(category.id);
                                    return (
                                        <button
                                            key={category.id}
                                            onClick={() => toggleCategory(category.id)}
                                            className={`w-full flex items-center justify-between px-3 py-3 rounded-lg transition-colors ${
                                                isSelected ? 'bg-primary/10 text-primary' : 'hover:bg-gray-50'
                                            }`}
                                        >
                                            <div className="flex items-center gap-2">
                                                <span 
                                                    className="w-3 h-3 rounded-full" 
                                                    style={{ backgroundColor: category.color }}
                                                />
                                                <span>{category.name}</span>
                                            </div>
                                            <span className="text-sm text-gray-400">{category.count}</span>
                                        </button>
                                    );
                                })}
                            </div>
                        </motion.div>
                    </div>

                    {/* 스케줄 리스트 */}
                    <div className="col-span-2 flex flex-col min-h-0">
                        {/* 헤더 */}
                        <div className="flex items-center justify-between h-11 mb-2">
                            <AnimatePresence mode="wait">
                                {isSearchMode ? (
                                    /* 검색 모드 - 밑줄 스타일 */
                                    <motion.div 
                                        key="search-mode"
                                        initial={{ opacity: 0, scale: 0.95 }}
                                        animate={{ opacity: 1, scale: 1 }}
                                        exit={{ opacity: 0, scale: 0.95 }}
                                        transition={{ duration: 0.15, ease: 'easeOut' }}
                                        className="flex items-center flex-1"
                                    >
                                        {/* 검색창 컨테이너 - 화살표와 검색창 일체형 */}
                                        <div className="flex-1 relative" ref={searchContainerRef}>
                                            <div className="flex items-center border border-gray-200 rounded-xl overflow-hidden">
                                                {/* 뒤로가기 영역 */}
                                                <button
                                                    onClick={() => {
                                                        setIsSearchMode(false);
                                                        setSearchInput('');
                                                        setOriginalSearchQuery('');
                                                        setSearchTerm('');
                                                        setShowSuggestions(false);
                                                        setSelectedSuggestionIndex(-1);
                                                        // 스크롤 위치 초기화
                                                        if (scrollContainerRef.current) {
                                                            scrollContainerRef.current.scrollTop = 0;
                                                        }
                                                    }}
                                                    className="flex items-center justify-center px-3 bg-gray-50 border-r border-gray-200 hover:bg-gray-100 transition-colors self-stretch"
                                                >
                                                    <ArrowLeft size={18} className="text-gray-500" />
                                                </button>
                                                
                                                {/* 검색 입력 영역 */}
                                                <div className="flex-1 flex items-center bg-white px-3 py-2.5">
                                                    <input
                                                        type="text"
                                                        placeholder="제목, 멤버, 카테고리로 검색..."
                                                        value={searchInput}
                                                        autoFocus
                                                        onChange={(e) => {
                                                            setSearchInput(e.target.value);
                                                            setOriginalSearchQuery(e.target.value); // 원본 쿼리도 업데이트
                                                            setShowSuggestions(true);
                                                            setSelectedSuggestionIndex(-1);
                                                        }}
                                                        onFocus={() => setShowSuggestions(true)}
                                                        onKeyDown={(e) => {
                                                            if (e.key === 'ArrowDown') {
                                                                e.preventDefault();
                                                                const newIndex = selectedSuggestionIndex < suggestions.length - 1 
                                                                    ? selectedSuggestionIndex + 1 
                                                                    : 0;
                                                                setSelectedSuggestionIndex(newIndex);
                                                                if (suggestions[newIndex]) {
                                                                    setSearchInput(suggestions[newIndex]);
                                                                }
                                                            } else if (e.key === 'ArrowUp') {
                                                                e.preventDefault();
                                                                const newIndex = selectedSuggestionIndex > 0 
                                                                    ? selectedSuggestionIndex - 1 
                                                                    : suggestions.length - 1;
                                                                setSelectedSuggestionIndex(newIndex);
                                                                if (suggestions[newIndex]) {
                                                                    setSearchInput(suggestions[newIndex]);
                                                                }
                                                            } else if (e.key === 'Enter') {
                                                                if (selectedSuggestionIndex >= 0 && suggestions[selectedSuggestionIndex]) {
                                                                    setSearchInput(suggestions[selectedSuggestionIndex]);
                                                                    setSearchTerm(suggestions[selectedSuggestionIndex]);
                                                                } else if (searchInput.trim()) {
                                                                    setSearchTerm(searchInput);
                                                                }
                                                                setShowSuggestions(false);
                                                                setSelectedSuggestionIndex(-1);
                                                            } else if (e.key === 'Escape') {
                                                                setIsSearchMode(false);
                                                                setSearchInput('');
                                                                setOriginalSearchQuery('');
                                                                setSearchTerm('');
                                                                setShowSuggestions(false);
                                                                setSelectedSuggestionIndex(-1);
                                                                // 스크롤 위치 초기화
                                                                if (scrollContainerRef.current) {
                                                                    scrollContainerRef.current.scrollTop = 0;
                                                                }
                                                            }
                                                        }}
                                                        className="flex-1 bg-transparent focus:outline-none text-gray-700 placeholder-gray-400 text-sm"
                                                    />
                                                    {/* 입력 지우기 버튼 - 항상 공간 차지, 입력 있을 때만 보임 */}
                                                    <button
                                                        onClick={() => {
                                                            setSearchInput('');
                                                            setOriginalSearchQuery('');
                                                            setShowSuggestions(false);
                                                            setSelectedSuggestionIndex(-1);
                                                        }}
                                                        className={`p-1 rounded transition-colors ${searchInput ? 'hover:bg-gray-100 opacity-100' : 'opacity-0 pointer-events-none'}`}
                                                    >
                                                        <X size={16} className="text-gray-400" />
                                                    </button>
                                                </div>
                                                
                                                {/* 검색 버튼 영역 */}
                                                <button
                                                    onClick={() => {
                                                        if (searchInput.trim()) {
                                                            setSearchTerm(searchInput);
                                                            setShowSuggestions(false);
                                                            setSelectedSuggestionIndex(-1);
                                                        }
                                                    }}
                                                    className="flex items-center justify-center px-6 bg-primary hover:bg-primary/90 transition-colors self-stretch"
                                                >
                                                    <Search size={18} className="text-white" />
                                                </button>
                                            </div>
                                            
                                            {/* 검색어 추천 드롭다운 */}
                                            {showSuggestions && !isLoadingSuggestions && suggestions.length > 0 && (
                                                <div className="absolute top-full mt-2 bg-white rounded-xl shadow-lg border border-gray-200 py-1 z-50 overflow-hidden" style={{ left: '44px', right: '66px' }}>
                                                    {suggestions.map((suggestion, index) => (
                                                        <button
                                                            key={index}
                                                            onClick={() => {
                                                                setSearchInput(suggestion);
                                                                setSearchTerm(suggestion);
                                                                setShowSuggestions(false);
                                                                setSelectedSuggestionIndex(-1);
                                                            }}
                                                            onMouseEnter={() => setSelectedSuggestionIndex(index)}
                                                            className={`w-full px-4 py-2.5 text-left flex items-center gap-3 transition-colors ${
                                                                selectedSuggestionIndex === index 
                                                                    ? 'bg-primary/10 text-primary' 
                                                                    : 'hover:bg-gray-50 text-gray-700'
                                                            }`}
                                                        >
                                                            <Search size={15} className={selectedSuggestionIndex === index ? 'text-primary' : 'text-gray-400'} />
                                                            <span className="text-sm">{suggestion}</span>
                                                        </button>
                                                    ))}
                                                </div>
                                            )}
                                        </div>
                                    </motion.div>
                                ) : (
                                    /* 일반 모드 */
                                    <motion.div 
                                        key="normal-mode"
                                        initial={{ opacity: 0, scale: 0.95 }}
                                        animate={{ opacity: 1, scale: 1 }}
                                        exit={{ opacity: 0, scale: 0.95 }}
                                        transition={{ duration: 0.15, ease: 'easeOut' }}
                                        className="flex items-center gap-3"
                                    >
                                        <button
                                            onClick={() => setIsSearchMode(true)}
                                            className="p-1.5 hover:bg-gray-100 rounded-lg transition-colors"
                                            title="일정 검색"
                                        >
                                            <Search size={20} className="text-gray-500" />
                                        </button>
                                        <h2 className="text-lg font-bold text-gray-900">
                                            {selectedDate 
                                                ? (() => {
                                                    const d = new Date(selectedDate);
                                                    const dayNames = ['일', '월', '화', '수', '목', '금', '토'];
                                                    return `${d.getMonth() + 1}월 ${d.getDate()}일 ${dayNames[d.getDay()]}요일`;
                                                })()
                                                : `${month + 1}월 전체 일정`
                                            }
                                        </h2>
                                        {selectedCategories.length > 0 && (
                                            <div className="relative" ref={categoryRef}>
                                                <button
                                                    onClick={() => setShowCategoryTooltip(!showCategoryTooltip)}
                                                    className="flex items-center gap-1 px-2 py-1 bg-gray-100 rounded-md text-sm text-gray-600 hover:bg-gray-200 transition-colors"
                                                >
                                                    <Tag size={14} />
                                                    <span>{selectedCategories.length}개 카테고리</span>
                                                </button>
                                                <AnimatePresence>
                                                    {showCategoryTooltip && (
                                                        <motion.div 
                                                            initial={{ opacity: 0, y: -5 }}
                                                            animate={{ opacity: 1, y: 0 }}
                                                            exit={{ opacity: 0, y: -5 }}
                                                            transition={{ duration: 0.15 }}
                                                            className="absolute top-full left-0 mt-1 bg-white rounded-lg shadow-lg border border-gray-200 p-3 z-10 min-w-[150px]"
                                                        >
                                                            {selectedCategories.map(id => {
                                                                const cat = categories.find(c => c.id === id);
                                                                if (!cat) return null;
                                                                return (
                                                                    <div key={id} className="flex items-center gap-2 py-1">
                                                                        <span className="w-2 h-2 rounded-full" style={{ backgroundColor: cat.color }} />
                                                                        <span className="text-sm">{cat.name}</span>
                                                                    </div>
                                                                );
                                                            })}
                                                        </motion.div>
                                                    )}
                                                </AnimatePresence>
                                            </div>
                                        )}
                                    </motion.div>
                                )}
                            </AnimatePresence>
                            <AnimatePresence>
                                {!isSearchMode && (
                                    <motion.span 
                                        key="count"
                                        initial={{ opacity: 0, x: 10 }}
                                        animate={{ opacity: 1, x: 0 }}
                                        exit={{ opacity: 0, x: 10 }}
                                        transition={{ duration: 0.15 }}
                                        className="text-sm text-gray-500"
                                    >
                                        {filteredSchedules.length}개 일정
                                    </motion.span>
                                )}
                            </AnimatePresence>

                        </div>

                        <div 
                            ref={scrollContainerRef}
                            id="scheduleScrollContainer"
                            className="flex-1 min-h-0 overflow-y-auto space-y-4 py-2 pr-2"
                        >
                            {loading ? (
                                <div className="text-center py-20 text-gray-500">로딩 중...</div>
                            ) : filteredSchedules.length > 0 ? (
                                isSearchMode && searchTerm ? (
                                    /* 검색 모드: 가상 스크롤 */
                                    <>
                                        <div
                                            style={{
                                                height: `${virtualizer.getTotalSize()}px`,
                                                width: '100%',
                                                position: 'relative',
                                            }}
                                        >
                                            {virtualizer.getVirtualItems().map((virtualItem) => {
                                                const schedule = filteredSchedules[virtualItem.index];
                                                if (!schedule) return null;

                                                const formatted = formatDate(schedule.date);
                                                const categoryColor = getCategoryColor(schedule.category_id, schedule);
                                                const categoryName = getCategoryName(schedule.category_id, schedule);
                                                
                                                return (
                                                    <div
                                                        key={virtualItem.key}
                                                        ref={virtualizer.measureElement}
                                                        data-index={virtualItem.index}
                                                        style={{
                                                            position: 'absolute',
                                                            top: 0,
                                                            left: 0,
                                                            width: '100%',
                                                            transform: `translateY(${virtualItem.start}px)`,
                                                        }}
                                                    >
                                                        <div className={virtualItem.index < filteredSchedules.length - 1 ? "pb-4" : ""}>
                                                            {schedule.is_birthday ? (
                                                                <BirthdayCard schedule={schedule} formatted={formatted} showYear={true} onClick={() => handleScheduleClick(schedule)} />
                                                            ) : (
                                                            <div
                                                                onClick={() => handleScheduleClick(schedule)}
                                                                className="flex items-stretch bg-white rounded-2xl shadow-sm hover:shadow-md transition-shadow overflow-hidden cursor-pointer min-h-[100px]"
                                                            >
                                                            {/* 날짜 영역 */}
                                                            <div
                                                                className="w-24 flex flex-col items-center justify-center text-white"
                                                                style={{ backgroundColor: categoryColor }}
                                                            >
                                                                <span className="text-xs font-medium opacity-60">
                                                                    {new Date(schedule.date).getFullYear()}.{new Date(schedule.date).getMonth() + 1}
                                                                </span>
                                                                <span className="text-3xl font-bold">{formatted.day}</span>
                                                                <span className="text-sm font-medium opacity-80">{formatted.weekday}</span>
                                                            </div>

                                                            {/* 스케줄 내용 */}
                                                            <div className="flex-1 p-4 flex flex-col justify-center">
                                                                <h3 className="font-bold text-lg mb-1">{decodeHtmlEntities(schedule.title)}</h3>

                                                                <div className="flex flex-wrap gap-3 text-base text-gray-500">
                                                                    {schedule.time && (
                                                                        <span className="flex items-center gap-1">
                                                                            <Clock size={16} className="opacity-60" />
                                                                            {schedule.time.slice(0, 5)}
                                                                        </span>
                                                                    )}
                                                                    <span className="flex items-center gap-1">
                                                                        <Tag size={16} className="opacity-60" />
                                                                        {categoryName}
                                                                    </span>
                                                                    {schedule.source?.name && (
                                                                        <span className="flex items-center gap-1">
                                                                            <Link2 size={16} className="opacity-60" />
                                                                            {schedule.source?.name}
                                                                        </span>
                                                                    )}
                                                                </div>

                                                                {(() => {
                                                                    const memberNames = schedule.member_names || schedule.members?.map(m => m.name).join(',') || '';
                                                                    const memberList = memberNames.split(',').filter(name => name.trim());
                                                                    if (memberList.length === 0) return null;
                                                                    if (memberList.length === 5) {
                                                                        return (
                                                                            <div className="flex flex-wrap gap-1.5 mt-1">
                                                                                <span className="px-2 py-0.5 bg-primary/10 text-primary text-sm font-medium rounded-full">
                                                                                    프로미스나인
                                                                                </span>
                                                                            </div>
                                                                        );
                                                                    }
                                                                    return (
                                                                        <div className="flex flex-wrap gap-1.5 mt-1">
                                                                            {memberList.map((name, i) => (
                                                                                <span key={i} className="px-2 py-0.5 bg-primary/10 text-primary text-sm font-medium rounded-full">
                                                                                    {name}
                                                                                </span>
                                                                            ))}
                                                                        </div>
                                                                    );
                                                                })()}
                                                            </div>
                                                            </div>
                                                            )}
                                                        </div>
                                                    </div>
                                                );
                                            })}
                                        </div>
                                        
                                        {/* 무한 스크롤 트리거 & 로딩 인디케이터 */}
                                        <div ref={loadMoreRef} className="py-4">
                                            {isFetchingNextPage && (
                                                <div className="flex justify-center">
                                                    <div className="w-6 h-6 border-2 border-primary border-t-transparent rounded-full animate-spin" />
                                                </div>
                                            )}
                                            {!hasNextPage && filteredSchedules.length > 0 && (
                                                <div className="text-center text-sm text-gray-400">
                                                    {filteredSchedules.length}개 표시 (모두 로드됨)
                                                </div>
                                            )}
                                        </div>
                                    </>
                                ) : (
                                    /* 일반 모드: 기존 렌더링 */
                                    filteredSchedules.map((schedule, index) => {
                                        const formatted = formatDate(schedule.date);
                                        const categoryColor = getCategoryColor(schedule.category_id, schedule);
                                        const categoryName = getCategoryName(schedule.category_id, schedule);
                                        
                                        return (
                                            <motion.div
                                                key={`${schedule.id}-${selectedDate || 'all'}`}
                                                initial={{ opacity: 0 }}
                                                animate={{ opacity: 1 }}
                                                transition={{ delay: Math.min(index, 10) * 0.03 }}
                                            >
                                                {schedule.is_birthday ? (
                                                    <BirthdayCard schedule={schedule} formatted={formatted} onClick={() => handleScheduleClick(schedule)} />
                                                ) : (
                                                <div
                                                    onClick={() => handleScheduleClick(schedule)}
                                                    className="flex items-stretch bg-white rounded-2xl shadow-sm hover:shadow-md transition-shadow overflow-hidden cursor-pointer"
                                                >
                                                    <div
                                                        className="w-24 flex flex-col items-center justify-center text-white py-6"
                                                        style={{ backgroundColor: categoryColor }}
                                                    >
                                                        <span className="text-3xl font-bold">{formatted.day}</span>
                                                        <span className="text-sm font-medium opacity-80">{formatted.weekday}</span>
                                                    </div>
                                                    <div className="flex-1 p-6 flex flex-col justify-center">
                                                        <h3 className="font-bold text-lg mb-2">{decodeHtmlEntities(schedule.title)}</h3>
                                                        <div className="flex flex-wrap gap-3 text-base text-gray-500">
                                                            {schedule.time && (
                                                                <span className="flex items-center gap-1">
                                                                    <Clock size={16} className="opacity-60" />
                                                                    {schedule.time.slice(0, 5)}
                                                                </span>
                                                            )}
                                                            <span className="flex items-center gap-1">
                                                                <Tag size={16} className="opacity-60" />
                                                                {categoryName}
                                                            </span>
                                                            {schedule.source?.name && (
                                                                <span className="flex items-center gap-1">
                                                                    <Link2 size={16} className="opacity-60" />
                                                                    {schedule.source?.name}
                                                                </span>
                                                            )}
                                                        </div>
                                                        {(() => {
                                                            const memberNames = schedule.member_names || schedule.members?.map(m => m.name).join(',') || '';
                                                            const memberList = memberNames.split(',').filter(name => name.trim());
                                                            if (memberList.length === 0) return null;
                                                            if (memberList.length === 5) {
                                                                return (
                                                                    <div className="flex flex-wrap gap-1.5 mt-2">
                                                                        <span className="px-2 py-0.5 bg-primary/10 text-primary text-sm font-medium rounded-full">
                                                                            프로미스나인
                                                                        </span>
                                                                    </div>
                                                                );
                                                            }
                                                            return (
                                                                <div className="flex flex-wrap gap-1.5 mt-2">
                                                                    {memberList.map((name, i) => (
                                                                        <span key={i} className="px-2 py-0.5 bg-primary/10 text-primary text-sm font-medium rounded-full">
                                                                            {name}
                                                                        </span>
                                                                    ))}
                                                                </div>
                                                            );
                                                        })()}
                                                    </div>
                                                </div>
                                                )}
                                            </motion.div>
                                        );
                                    })
                                )
                            ) : (
                                !isSearchMode && (
                                    <motion.div
                                        initial={{ opacity: 0, y: 10 }}
                                        animate={{ opacity: 1, y: 0 }}
                                        transition={{ duration: 0.2 }}
                                        className="flex flex-col items-center justify-center py-16"
                                    >
                                        <div className="w-24 h-24 bg-gray-100 rounded-full flex items-center justify-center mb-4">
                                            <svg className="w-12 h-12 text-gray-300" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                                                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M8 7V3m8 4V3m-9 8h10M5 21h14a2 2 0 002-2V7a2 2 0 00-2-2H5a2 2 0 00-2 2v12a2 2 0 002 2z" />
                                            </svg>
                                        </div>
                                        <p className="text-gray-400 text-lg font-medium mb-1">
                                            {selectedDate ? '일정이 없습니다' : '예정된 일정이 없습니다'}
                                        </p>
                                        <p className="text-gray-300 text-sm">
                                            {selectedDate ? '다른 날짜를 선택해 보세요' : '다른 달을 확인해 보세요'}
                                        </p>
                                    </motion.div>
                                )
                            )}
                        </div>
                    </div>

                </div>
            </div>
        </div>
    );
}

export default Schedule;
