import { useState, useEffect, useRef, useMemo, memo, useDeferredValue } from 'react';
import { useNavigate, Link } from 'react-router-dom';
import { motion, AnimatePresence } from 'framer-motion';
import {
    Home, ChevronRight, Calendar, Plus, Edit2, Trash2,
    ChevronLeft, Search, ChevronDown, Bot, Tag, ArrowLeft, ExternalLink, Clock, Link2, Book
} from 'lucide-react';
import { useQuery, useInfiniteQuery, useQueryClient } from '@tanstack/react-query';
import { useVirtualizer } from '@tanstack/react-virtual';
import { useInView } from 'react-intersection-observer';

import Toast from '../../../components/Toast';
import Tooltip from '../../../components/Tooltip';
import AdminLayout from '../../../components/admin/AdminLayout';
import ConfirmDialog from '../../../components/admin/ConfirmDialog';
import useScheduleStore from '../../../stores/useScheduleStore';
import useAdminAuth from '../../../hooks/useAdminAuth';
import useToast from '../../../hooks/useToast';
import { getTodayKST, formatDate } from '../../../utils/date';
import * as schedulesApi from '../../../api/admin/schedules';

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

// 멤버 리스트 추출 (검색 결과와 일반 데이터 모두 처리)
const getMemberList = (schedule) => {
    // member_names 문자열이 있으면 사용
    if (schedule.member_names) {
        return schedule.member_names.split(',').map(n => n.trim()).filter(Boolean);
    }
    // members 배열이 있으면
    if (Array.isArray(schedule.members) && schedule.members.length > 0) {
        // 문자열 배열인 경우 (검색 결과)
        if (typeof schedule.members[0] === 'string') {
            return schedule.members.filter(Boolean);
        }
        // 객체 배열인 경우 (일반 데이터)
        return schedule.members.map(m => m.name).filter(Boolean);
    }
    return [];
};

// 일정 날짜 추출 (검색 결과와 일반 데이터 모두 처리)
const getScheduleDate = (schedule) => {
    // datetime이 있으면 (검색 결과)
    if (schedule.datetime) {
        return new Date(schedule.datetime);
    }
    // date가 있으면 (일반 데이터)
    if (schedule.date) {
        return new Date(schedule.date);
    }
    return new Date();
};

// 일정 시간 추출 (검색 결과와 일반 데이터 모두 처리)
const getScheduleTime = (schedule) => {
    // time이 있으면 (일반 데이터)
    if (schedule.time) {
        return schedule.time.slice(0, 5);
    }
    // datetime에서 시간 추출 (검색 결과)
    if (schedule.datetime && schedule.datetime.includes('T')) {
        const timePart = schedule.datetime.split('T')[1];
        if (timePart) {
            return timePart.slice(0, 5);
        }
    }
    return null;
};

// 카테고리 ID 추출 (검색 결과와 일반 데이터 모두 처리)
const getCategoryId = (schedule) => {
    // category_id가 있으면 (일반 데이터)
    if (schedule.category_id !== undefined) {
        return schedule.category_id;
    }
    // category.id가 있으면 (검색 결과)
    if (schedule.category?.id !== undefined) {
        return schedule.category.id;
    }
    return null;
};

// 카테고리 정보 추출 (검색 결과와 일반 데이터 모두 처리)
const getCategoryInfo = (schedule, categories) => {
    const catId = getCategoryId(schedule);
    // 검색 결과에 category 객체가 있으면 직접 사용
    if (schedule.category?.name && schedule.category?.color) {
        return {
            id: schedule.category.id,
            name: schedule.category.name,
            color: schedule.category.color
        };
    }
    // categories 배열에서 찾기
    const found = categories.find(c => c.id === catId);
    return found || { id: catId, name: '미분류', color: '#6b7280' };
};

// 카테고리 ID 상수
const CATEGORY_IDS = {
    YOUTUBE: 2,
    X: 3,
};

// 카테고리별 수정 경로 반환
const getEditPath = (scheduleId, categoryId) => {
    switch (categoryId) {
        case CATEGORY_IDS.YOUTUBE:
            return `/admin/schedule/${scheduleId}/edit/youtube`;
        case CATEGORY_IDS.X:
            return `/admin/schedule/${scheduleId}/edit/x`;
        default:
            return `/admin/schedule/${scheduleId}/edit`;
    }
};

// 일정 아이템 컴포넌트 - React.memo로 불필요한 리렌더링 방지
const ScheduleItem = memo(function ScheduleItem({
    schedule,
    index,
    selectedDate,
    categories,
    getColorStyle,
    navigate,
    openDeleteDialog
}) {
    const scheduleDate = getScheduleDate(schedule);
    const isBirthday = schedule.is_birthday || String(schedule.id).startsWith('birthday-');
    const categoryInfo = getCategoryInfo(schedule, categories);
    const categoryColor = getColorStyle(categoryInfo.color)?.style?.backgroundColor || categoryInfo.color || '#6b7280';
    const memberList = getMemberList(schedule);
    const timeStr = getScheduleTime(schedule);
    const catId = getCategoryId(schedule);

    return (
        <motion.div
            key={`${schedule.id}-${selectedDate || 'all'}`}
            initial={{ opacity: 0 }}
            animate={{ opacity: 1 }}
            transition={{ delay: Math.min(index, 10) * 0.03 }}
            className="p-6 hover:bg-gray-50 transition-colors group"
        >
            <div className="flex items-start gap-4">
                <div className="w-20 text-center flex-shrink-0">
                    <div className="text-2xl font-bold text-gray-900">
                        {scheduleDate.getDate()}
                    </div>
                    <div className="text-sm text-gray-500">
                        {['일', '월', '화', '수', '목', '금', '토'][scheduleDate.getDay()]}요일
                    </div>
                </div>

                <div
                    className="w-1.5 rounded-full flex-shrink-0 self-stretch"
                    style={{ backgroundColor: categoryColor }}
                />

                <div className="flex-1 min-w-0">
                    <h3 className="font-semibold text-gray-900">{decodeHtmlEntities(schedule.title)}</h3>
                    <div className="flex items-center gap-3 mt-1 text-sm text-gray-500">
                        {timeStr && (
                            <span className="flex items-center gap-1">
                                <Clock size={14} />
                                {timeStr}
                            </span>
                        )}
                        <span className="flex items-center gap-1">
                            <Tag size={14} />
                            {categoryInfo.name}
                        </span>
                        {schedule.source?.name && (
                            <span className="flex items-center gap-1">
                                <Link2 size={14} />
                                {schedule.source?.name}
                            </span>
                        )}
                    </div>
                    {memberList.length > 0 && (
                        <div className="flex flex-wrap gap-1.5 mt-2">
                            {memberList.length >= 5 ? (
                                <span className="px-2 py-0.5 bg-primary/10 text-primary text-xs font-medium rounded-full">
                                    프로미스나인
                                </span>
                            ) : (
                                memberList.map((name, i) => (
                                    <span key={i} className="px-2 py-0.5 bg-primary/10 text-primary text-xs font-medium rounded-full">
                                        {name.trim()}
                                    </span>
                                ))
                            )}
                        </div>
                    )}
                </div>

                {/* 생일 일정은 수정/삭제 불가 */}
                {!isBirthday && (
                    <div className="flex items-center gap-2 opacity-0 group-hover:opacity-100 transition-opacity">
                        {schedule.source?.url && (
                            <a
                                href={schedule.source?.url}
                                target="_blank"
                                rel="noopener noreferrer"
                                onClick={(e) => e.stopPropagation()}
                                className="p-2 hover:bg-blue-100 rounded-lg transition-colors text-blue-500"
                            >
                                <ExternalLink size={18} />
                            </a>
                        )}
                        <button
                            onClick={() => navigate(getEditPath(schedule.id, schedule.category_id))}
                            className="p-2 hover:bg-gray-200 rounded-lg transition-colors text-gray-500"
                        >
                            <Edit2 size={18} />
                        </button>
                        <button
                            onClick={() => openDeleteDialog(schedule)}
                            className="p-2 hover:bg-red-100 rounded-lg transition-colors text-red-500"
                        >
                            <Trash2 size={18} />
                        </button>
                    </div>
                )}
            </div>
        </motion.div>
    );
});

function AdminSchedule() {
    const navigate = useNavigate();
    const queryClient = useQueryClient();

    // Zustand 스토어에서 상태 가져오기
    const {
        searchInput, setSearchInput,
        searchTerm, setSearchTerm,
        isSearchMode, setIsSearchMode,
        selectedCategories, setSelectedCategories,
        selectedDate, setSelectedDate,
        currentDate, setCurrentDate,
        scrollPosition, setScrollPosition,
    } = useScheduleStore();

    const { user, isAuthenticated } = useAdminAuth();

    // 로컬 상태 (페이지 이동 시 유지할 필요 없는 것들)
    const { toast, setToast } = useToast();
    const scrollContainerRef = useRef(null);
    const searchContainerRef = useRef(null); // 검색 컨테이너 (외부 클릭 감지용)
    
    // 검색 추천 관련 상태
    const [showSuggestions, setShowSuggestions] = useState(false);
    const [selectedSuggestionIndex, setSelectedSuggestionIndex] = useState(-1);
    const [originalSearchQuery, setOriginalSearchQuery] = useState(''); // 필터링용 원본 쿼리
    const [suggestions, setSuggestions] = useState([]); // 추천 검색어 목록
    const [isLoadingSuggestions, setIsLoadingSuggestions] = useState(false);
    
    const SEARCH_LIMIT = 20; // 페이지당 20개
    const ESTIMATED_ITEM_HEIGHT = 100; // 아이템 추정 높이 (동적 측정)
    
    // 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,
    } = useInfiniteQuery({
        queryKey: ['adminScheduleSearch', searchTerm],
        queryFn: async ({ pageParam = 0 }) => {
            return schedulesApi.searchSchedules(searchTerm, { offset: pageParam, limit: SEARCH_LIMIT });
        },
        getNextPageParam: (lastPage) => {
            if (lastPage.hasMore) {
                return lastPage.offset + lastPage.schedules.length;
            }
            return undefined;
        },
        enabled: !!searchTerm && isSearchMode,
    });
    
    // Flatten search results
    const searchResults = useMemo(() => {
        if (!searchData?.pages) return [];
        return searchData.pages.flatMap(page => page.schedules);
    }, [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]);
    
    // selectedDate가 없으면 오늘 날짜로 초기화
    useEffect(() => {
        if (!selectedDate) {
            setSelectedDate(getTodayKST());
        }
    }, []);



    const [slideDirection, setSlideDirection] = useState(0);
    
    // 년월 선택 관련 (Schedule.jsx와 동일한 패턴)
    const [showYearMonthPicker, setShowYearMonthPicker] = useState(false);
    const [showCategoryTooltip, setShowCategoryTooltip] = useState(false);
    const [viewMode, setViewMode] = useState('yearMonth'); // 'yearMonth' | 'months'
    const pickerRef = useRef(null);
    const categoryTooltipRef = useRef(null);

    // 달력 관련
    const year = currentDate.getFullYear();
    const month = currentDate.getMonth();
    const firstDay = new Date(year, month, 1).getDay();
    const daysInMonth = new Date(year, month + 1, 0).getDate();
    const days = ['일', '월', '화', '수', '목', '금', '토'];
    const monthNames = ['1월', '2월', '3월', '4월', '5월', '6월', '7월', '8월', '9월', '10월', '11월', '12월'];
    
    // 년도 범위 (2017년부터 시작, 12년 단위)
    const MIN_YEAR = 2017;
    const startYear = Math.max(MIN_YEAR, Math.floor(year / 12) * 12 - 1);
    const yearRange = Array.from({ length: 12 }, (_, i) => startYear + i);
    const canGoPrevYearRange = startYear > MIN_YEAR;
    
    // 현재 년도/월 확인 함수
    const isCurrentYear = (y) => new Date().getFullYear() === y;
    const isCurrentMonth = (m) => {
        const today = new Date();
        return today.getFullYear() === year && today.getMonth() === m;
    };
    
    const getDaysInMonth = (y, m) => new Date(y, m + 1, 0).getDate();

    // 일정 목록 (React Query로 캐싱)
    const { data: schedules = [], isLoading: loading } = useQuery({
        queryKey: ['adminSchedules', year, month + 1],
        queryFn: () => schedulesApi.getSchedules(year, month + 1),
        enabled: isAuthenticated,
    });

    // 카테고리는 일정 데이터에서 추출
    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 [
            { id: 'all', name: '전체', color: 'gray' },
            ...Array.from(categoryMap.values())
        ];
    }, [schedules]);

    // 카테고리 색상 맵핑
    const colorMap = {
        blue: 'bg-blue-500',
        green: 'bg-green-500',
        purple: 'bg-purple-500',
        red: 'bg-red-500',
        pink: 'bg-pink-500',
        yellow: 'bg-yellow-500',
        orange: 'bg-orange-500',
        gray: 'bg-gray-500',
    };

    // 색상 스타일 (기본 색상 또는 커스텀 HEX)
    const getColorStyle = (color) => {
        if (!color) return { className: 'bg-gray-500' };
        if (color.startsWith('#')) {
            return { style: { backgroundColor: color } };
        }
        return { className: colorMap[color] || 'bg-gray-500' };
    };

    // 카테고리별 색상 (배지용)
    const getCategoryColor = (color) => {
        const colors = {
            blue: 'bg-blue-100 text-blue-700',
            green: 'bg-green-100 text-green-700',
            purple: 'bg-purple-100 text-purple-700',
            red: 'bg-red-100 text-red-700',
            pink: 'bg-pink-100 text-pink-700',
            yellow: 'bg-yellow-100 text-yellow-700',
            orange: 'bg-orange-100 text-orange-700',
            gray: 'bg-gray-100 text-gray-700',
        };
        if (color?.startsWith('#')) {
            return 'bg-gray-100 text-gray-700';
        }
        return colors[color] || 'bg-gray-100 text-gray-700';
    };

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

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

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

    // 해당 날짜의 첫 번째 일정 카테고리 색상 (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;
        const cat = categories.find(c => c.id === schedule.category_id);
        return cat?.color || '#4A7C59';
    };

    useEffect(() => {
        if (!isAuthenticated) return;

        // sessionStorage에서 토스트 메시지 확인 (일정 추가/수정 완료 시)
        const savedToast = sessionStorage.getItem('scheduleToast');
        if (savedToast) {
            setToast(JSON.parse(savedToast));
            sessionStorage.removeItem('scheduleToast');
            // 추가/수정 후 돌아왔을 때 캐시 무효화
            queryClient.invalidateQueries({ queryKey: ['adminSchedules'] });
        }
    }, [isAuthenticated, queryClient]);

    // 스크롤 위치 복원
    useEffect(() => {
        if (scrollContainerRef.current && scrollPosition > 0) {
            scrollContainerRef.current.scrollTop = scrollPosition;
        }
    }, [loading]); // 로딩이 끝나면 스크롤 복원
    
    // 날짜 변경 시 스크롤 맨 위로 초기화
    useEffect(() => {
        if (scrollContainerRef.current) {
            scrollContainerRef.current.scrollTop = 0;
        }
    }, [selectedDate]);
    
    // 스크롤 위치 저장
    const handleScroll = (e) => {
        setScrollPosition(e.target.scrollTop);
    };

    // 외부 클릭 시 피커 닫기
    useEffect(() => {
        const handleClickOutside = (event) => {
            if (pickerRef.current && !pickerRef.current.contains(event.target)) {
                setShowYearMonthPicker(false);
                setViewMode('yearMonth');
            }
            if (categoryTooltipRef.current && !categoryTooltipRef.current.contains(event.target)) {
                setShowCategoryTooltip(false);
            }
            // 검색 추천 드롭다운 외부 클릭 시 닫기
            if (searchContainerRef.current && !searchContainerRef.current.contains(event.target)) {
                setShowSuggestions(false);
                setSelectedSuggestionIndex(-1);
            }
        };
        
        if (showYearMonthPicker || showCategoryTooltip) {
            document.addEventListener('mousedown', handleClickOutside);
        }
        
        return () => document.removeEventListener('mousedown', handleClickOutside);
    }, [showYearMonthPicker, showCategoryTooltip]);

    // 2017년 1월 이전으로 이동 불가
    const canGoPrevMonth = !(year === 2017 && month === 0);

    // 월 이동
    const prevMonth = () => {
        if (!canGoPrevMonth) return;
        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);
        }
    };

    // 년도 범위 이동 (12년 단위, 2017년 이전 불가)
    const prevYearRange = () => canGoPrevYearRange && setCurrentDate(new Date(Math.max(MIN_YEAR, year - 12), month, 1));
    const nextYearRange = () => setCurrentDate(new Date(year + 12, month, 1));

    // 년도 선택
    const selectYear = (newYear) => {
        setCurrentDate(new Date(newYear, month, 1));
    };

    // 월 선택 시 적용 후 닫기
    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 selectDate = (day) => {
        const dateStr = `${year}-${String(month + 1).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
        setSelectedDate(dateStr);
    };

    // 삭제 관련 상태
    const [deleteDialogOpen, setDeleteDialogOpen] = useState(false);
    const [scheduleToDelete, setScheduleToDelete] = useState(null);
    const [deleting, setDeleting] = useState(false);

    // 삭제 확인 다이얼로그 열기
    const openDeleteDialog = (schedule) => {
        setScheduleToDelete(schedule);
        setDeleteDialogOpen(true);
    };

    // 일정 삭제
    const handleDelete = async () => {
        if (!scheduleToDelete) return;

        setDeleting(true);
        try {
            await schedulesApi.deleteSchedule(scheduleToDelete.id);
            setToast({ type: 'success', message: '일정이 삭제되었습니다.' });
            // 캐시 무효화하여 목록 새로고침
            queryClient.invalidateQueries({ queryKey: ['adminSchedules', year, month + 1] });
        } catch (error) {
            console.error('삭제 오류:', error);
            setToast({ type: 'error', message: error.message || '삭제 중 오류가 발생했습니다.' });
        } finally {
            setDeleting(false);
            setDeleteDialogOpen(false);
            setScheduleToDelete(null);
        }
    };

    // 검색어 정규화 (대소문자, 띄어쓰기, 특수문자 무시)
    const normalizeForSearch = (str) => {
        return (str || '').toLowerCase().replace(/[\s\-_.,!?#@]/g, '');
    };
    
    // 일정 목록 (검색 모드일 때 searchResults, 일반 모드일 때 로컬 필터링) - useMemo로 최적화
    const filteredSchedules = useMemo(() => {
        let result;
        if (isSearchMode) {
            if (!searchTerm) return [];
            // 카테고리 필터링 적용
            if (selectedCategories.length === 0) {
                result = [...searchResults];
            } else {
                result = searchResults.filter(s => selectedCategories.includes(getCategoryId(s)));
            }
        } else {
            // 일반 모드: 로컬 필터링
            result = schedules.filter(schedule => {
                const matchesCategory = selectedCategories.length === 0 || selectedCategories.includes(schedule.category_id);
                const scheduleDate = formatDate(schedule.date);
                const matchesDate = !selectedDate || scheduleDate === selectedDate;
                return matchesCategory && matchesDate;
            });
        }
        // 생일 일정을 맨 위로 정렬
        return result.sort((a, b) => {
            const aIsBirthday = a.is_birthday || String(a.id).startsWith('birthday-');
            const bIsBirthday = b.is_birthday || String(b.id).startsWith('birthday-');
            if (aIsBirthday && !bIsBirthday) return -1;
            if (!aIsBirthday && bIsBirthday) return 1;
            return 0;
        });
    }, [isSearchMode, searchTerm, searchResults, schedules, selectedCategories, selectedDate]);

    // 가상 스크롤 설정 (검색 모드에서만 활성화, 동적 높이 지원)
    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 => {
            // 검색 모드에서 검색어가 있을 때는 전체 대상
            // 그 외에는 선택된 날짜 기준으로 필터링
            if (!(isSearchMode && searchTerm) && selectedDate) {
                const sDate = getScheduleDate(s);
                const scheduleDate = formatDate(sDate);
                if (scheduleDate !== selectedDate) return;
            }

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

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

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

    return (
        <AdminLayout user={user}>
            <Toast toast={toast} onClose={() => setToast(null)} />

            {/* 삭제 확인 다이얼로그 */}
            <ConfirmDialog
                isOpen={deleteDialogOpen}
                onClose={() => setDeleteDialogOpen(false)}
                onConfirm={handleDelete}
                title="일정 삭제"
                message={
                    <>
                        <p className="text-gray-600 mb-2">다음 일정을 삭제하시겠습니까?</p>
                        <p className="text-gray-900 font-medium mb-4 p-3 bg-gray-50 rounded-lg">
                            {scheduleToDelete?.title}
                        </p>
                        <p className="text-sm text-red-500">이 작업은 되돌릴 수 없습니다.</p>
                    </>
                }
                loading={deleting}
            />

            {/* 메인 콘텐츠 - 전체 높이 차지 */}
            <div className="h-full flex flex-col overflow-hidden max-w-7xl mx-auto px-6 py-8 w-full">
                {/* 브레드크럼 */}
                <div className="flex-shrink-0 flex items-center gap-2 text-sm text-gray-400 mb-8">
                    <Link to="/admin/dashboard" className="hover:text-primary transition-colors">
                        <Home size={16} />
                    </Link>
                    <ChevronRight size={14} />
                    <span className="text-gray-700">일정 관리</span>
                </div>

                {/* 타이틀 + 추가 버튼 */}
                <div className="flex-shrink-0 flex items-center justify-between mb-8">
                    <div>
                        <h1 className="text-3xl font-bold text-gray-900 mb-2">일정 관리</h1>
                        <p className="text-gray-500">fromis_9의 일정을 관리합니다</p>
                    </div>
                    <div className="flex items-center gap-3">
                        <button
                            onClick={() => navigate('/admin/schedule/dict')}
                            className="flex items-center gap-2 px-5 py-3 bg-gray-100 text-gray-700 rounded-xl hover:bg-gray-200 transition-colors font-medium"
                        >
                            <Book size={20} />
                            사전 관리
                        </button>
                        <button
                            onClick={() => navigate('/admin/schedule/bots')}
                            className="flex items-center gap-2 px-5 py-3 bg-gray-100 text-gray-700 rounded-xl hover:bg-gray-200 transition-colors font-medium"
                        >
                            <Bot size={20} />
                            봇 관리
                        </button>
                        <button
                            onClick={() => navigate('/admin/schedule/new')}
                            className="flex items-center gap-2 px-5 py-3 bg-primary text-white rounded-xl hover:bg-primary-dark transition-colors font-medium shadow-sm"
                        >
                            <Plus size={20} />
                            일정 추가
                        </button>
                    </div>
                </div>

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

                            {/* 년/월 선택 팝업 (Schedule.jsx와 동일한 스타일) */}
                            <AnimatePresence>
                                {showYearMonthPicker && (
                                    <motion.div
                                        initial={{ opacity: 0, y: -10 }}
                                        animate={{ opacity: 1, y: 0 }}
                                        exit={{ opacity: 0, y: -10 }}
                                        className="absolute top-16 left-6 right-6 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}
                                                disabled={!canGoPrevYearRange}
                                                className={`p-1.5 rounded-lg transition-colors ${canGoPrevYearRange ? 'hover:bg-gray-100' : 'opacity-30'}`}
                                            >
                                                <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 }}
                                >
                                    {/* 요일 헤더 */}
                                    <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={() => !isSearchMode && selectDate(day)}
                                                    disabled={isSearchMode}
                                                    className={`aspect-square flex flex-col items-center justify-center rounded-full text-base font-medium transition-all relative 
                                                        ${isSearchMode ? 'cursor-not-allowed opacity-50' : 'hover:bg-gray-100'}
                                                        ${isSelected && !isSearchMode ? '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: getColorStyle(categories.find(c => c.id === schedule.category_id)?.color)?.style?.backgroundColor || '#6b7280' }}
                                                                />
                                                            ))}
                                                        </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>
                        </motion.div>

                        {/* 카테고리 필터 */}
                        <motion.div 
                            animate={{ opacity: isSearchMode && !searchTerm ? 0.4 : 1 }}
                            transition={{ duration: 0.2 }}
                            className={`bg-white rounded-2xl shadow-sm p-6 ${isSearchMode && !searchTerm ? 'pointer-events-none' : ''}`}
                        >
                            <h3 className="font-bold text-gray-900 mb-4">카테고리</h3>
                            <div className="space-y-2">
                                {/* 카테고리 - useMemo로 정렬됨 */}
                                {sortedCategories.map(category => {
                                    const isSelected = category.id === 'all' 
                                        ? selectedCategories.length === 0 
                                        : selectedCategories.includes(category.id);
                                    
                                    const handleClick = () => {
                                        if (category.id === 'all') {
                                            setSelectedCategories([]);
                                        } else {
                                            if (selectedCategories.includes(category.id)) {
                                                setSelectedCategories(selectedCategories.filter(id => id !== category.id));
                                            } else {
                                                setSelectedCategories([...selectedCategories, category.id]);
                                            }
                                        }
                                    };
                                    
                                    return (
                                        <button
                                            key={category.id}
                                            onClick={handleClick}
                                            className={`w-full flex items-center gap-3 px-4 py-3 rounded-xl text-left transition-colors ${
                                                isSelected
                                                    ? 'bg-primary/10 text-primary'
                                                    : 'hover:bg-gray-50 text-gray-700'
                                            }`}
                                        >
                                            <span 
                                                className={`w-3 h-3 rounded-full ${category.id === 'all' ? 'bg-gray-400' : (getColorStyle(category.color).className || '')}`}
                                                style={category.id !== 'all' ? getColorStyle(category.color).style : undefined}
                                            />
                                            <span className="font-medium">{category.name}</span>
                                            <span className="ml-auto 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-1 flex flex-col min-h-0 bg-white rounded-2xl shadow-sm overflow-hidden">
                            <div className="p-5 border-b border-gray-100">
                                <div className="flex items-center gap-3">
                                    <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 gap-3 flex-1"
                                            >
                                                <button
                                                    onClick={() => {
                                                        setIsSearchMode(false);
                                                        setSearchInput('');
                                                        setOriginalSearchQuery('');
                                                        setSearchTerm('');
                                                        setShowSuggestions(false);
                                                        setSelectedSuggestionIndex(-1);
                                                    }}
                                                    className="p-1.5 hover:bg-gray-100 rounded-lg transition-colors"
                                                >
                                                    <ArrowLeft size={20} className="text-gray-500" />
                                                </button>
                                                
                                                {/* 검색 입력 컨테이너 (드롭다운 포함) */}
                                                <div className="flex-1 relative" ref={searchContainerRef}>
                                                    <div className="flex items-center gap-2">
                                                        <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);
                                                                    setSearchResults([]);
                                                                }
                                                            }}
                                                            className="flex-1 bg-transparent focus:outline-none text-gray-700 placeholder-gray-400"
                                                        />
                                                        <button
                                                            onClick={() => {
                                                                if (searchInput.trim()) {
                                                                    setSearchTerm(searchInput);
                                                                    setShowSuggestions(false);
                                                                    setSelectedSuggestionIndex(-1);
                                                                }
                                                            }}
                                                            disabled={searchLoading}
                                                            className="p-1.5 hover:bg-gray-100 rounded-lg transition-colors disabled:opacity-50"
                                                        >
                                                            <Search size={20} className="text-primary" />
                                                        </button>
                                                    </div>
                                                    
                                                    {/* 검색어 추천 드롭다운 */}
                                                    {showSuggestions && !isLoadingSuggestions && suggestions.length > 0 && (
                                                        <div className="absolute top-full left-0 right-8 mt-2 bg-white rounded-xl shadow-lg border border-gray-200 py-1 z-50 overflow-hidden">
                                                            {suggestions.map((suggestion, index) => (
                                                                <button
                                                                    key={suggestion}
                                                                    onClick={() => {
                                                                        setSearchInput(suggestion);
                                                                        setSearchTerm(suggestion);
                                                                        setShowSuggestions(false);
                                                                        setSelectedSuggestionIndex(-1);
                                                                    }}
                                                                    className={`w-full px-4 py-2 text-left text-sm flex items-center gap-3 transition-colors ${
                                                                        index === selectedSuggestionIndex 
                                                                            ? 'bg-primary/10 text-primary' 
                                                                            : 'text-gray-700 hover:bg-gray-50'
                                                                    }`}
                                                                >
                                                                    <Search size={14} className="text-gray-400 shrink-0" />
                                                                    <span>{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 flex-1"
                                            >
                                                <button
                                                    onClick={() => setIsSearchMode(true)}
                                                    className="p-1.5 hover:bg-gray-100 rounded-lg transition-colors"
                                                >
                                                    <Search size={20} className="text-gray-500" />
                                                </button>
                                                <span className="font-medium text-gray-900">
                                                    {selectedDate 
                                                        ? (() => {
                                                            const d = new Date(selectedDate);
                                                            const dayNames = ['일', '월', '화', '수', '목', '금', '토'];
                                                            return `${d.getMonth() + 1}월 ${d.getDate()}일 ${dayNames[d.getDay()]}요일`;
                                                        })()
                                                        : `${month + 1}월 전체 일정`
                                                    }
                                                </span>
                                                <div className="flex-1" />
                                                {/* 카테고리 필터 */}
                                                {selectedCategories.length > 0 && (
                                                    <div className="relative" ref={categoryTooltipRef}>
                                                        <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 right-0 mt-1 bg-white rounded-lg shadow-lg border border-gray-200 p-3 z-10 min-w-[120px]"
                                                                >
                                                                    {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?.startsWith('#') ? cat.color : undefined }}
                                                                                />
                                                                                <span className="text-sm">{cat.name}</span>
                                                                            </div>
                                                                        );
                                                                    })}
                                                                </motion.div>
                                                            )}
                                                        </AnimatePresence>
                                                    </div>
                                                )}
                                                <span className="text-sm text-gray-400">{filteredSchedules.length}개 일정</span>
                                            </motion.div>
                                        )}
                                    </AnimatePresence>
                                </div>
                            </div>

                            {loading ? (
                                <div className="flex justify-center items-center py-20">
                                    <div className="animate-spin rounded-full h-12 w-12 border-4 border-primary border-t-transparent"></div>
                                </div>
                            ) : filteredSchedules.length === 0 ? (
                                // 검색 모드에서는 빈 메시지 표시 안 함
                                !isSearchMode && (
                                    <motion.div 
                                        initial={{ opacity: 0, y: 10 }}
                                        animate={{ opacity: 1, y: 0 }}
                                        transition={{ duration: 0.2 }}
                                        className="text-center py-16 text-gray-500"
                                    >
                                        <Calendar size={48} className="mx-auto mb-4 text-gray-300" />
                                        <p>등록된 일정이 없습니다</p>
                                    </motion.div>
                                )
                            ) : (
                                <div 
                                    ref={scrollContainerRef}
                                    onScroll={handleScroll}
                                    id="adminScheduleScrollContainer"
                                    className="flex-1 overflow-y-auto divide-y divide-gray-100 py-2"
                                >
                                    {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;
                                                    
                                                    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)`,
                                                            }}
                                                        >
                                                            {(() => {
                                                                const scheduleDate = getScheduleDate(schedule);
                                                                const categoryInfo = getCategoryInfo(schedule, categories);
                                                                const categoryColor = getColorStyle(categoryInfo.color)?.style?.backgroundColor || categoryInfo.color || '#6b7280';
                                                                const timeStr = getScheduleTime(schedule);
                                                                const catId = getCategoryId(schedule);
                                                                const memberList = getMemberList(schedule);

                                                                return (
                                                                    <div className="p-5 hover:bg-gray-50 transition-colors group border-b border-gray-100">
                                                                        <div className="flex items-start gap-4">
                                                                            <div className="w-20 text-center flex-shrink-0">
                                                                                <div className="text-xs text-gray-400 mb-0.5">
                                                                                    {scheduleDate.getFullYear()}.{scheduleDate.getMonth() + 1}
                                                                                </div>
                                                                                <div className="text-2xl font-bold text-gray-900">
                                                                                    {scheduleDate.getDate()}
                                                                                </div>
                                                                                <div className="text-sm text-gray-500">
                                                                                    {['일', '월', '화', '수', '목', '금', '토'][scheduleDate.getDay()]}요일
                                                                                </div>
                                                                            </div>

                                                                            <div
                                                                                className="w-1.5 rounded-full flex-shrink-0 self-stretch"
                                                                                style={{ backgroundColor: categoryColor }}
                                                                            />

                                                                            <div className="flex-1 min-w-0">
                                                                                <h3 className="font-semibold text-gray-900">{decodeHtmlEntities(schedule.title)}</h3>
                                                                                <div className="flex items-center gap-3 mt-1 text-sm text-gray-500">
                                                                                    {timeStr && (
                                                                                        <span className="flex items-center gap-1">
                                                                                            <Clock size={14} />
                                                                                            {timeStr}
                                                                                        </span>
                                                                                    )}
                                                                                    <span className="flex items-center gap-1">
                                                                                        <Tag size={14} />
                                                                                        {categoryInfo.name}
                                                                                    </span>
                                                                                    {schedule.source?.name && (
                                                                                    <span className="flex items-center gap-1">
                                                                                        <Link2 size={14} />
                                                                                        {schedule.source?.name}
                                                                                    </span>
                                                                                    )}
                                                                                </div>
                                                                                {memberList.length > 0 && (
                                                                                    <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-xs font-medium rounded-full">
                                                                                                {name}
                                                                                            </span>
                                                                                        ))}
                                                                                    </div>
                                                                                )}
                                                                            </div>

                                                                            <div className="flex items-center gap-2 opacity-0 group-hover:opacity-100 transition-opacity">
                                                                                {schedule.source?.url && (
                                                                                    <a
                                                                                        href={schedule.source?.url}
                                                                                        target="_blank"
                                                                                        rel="noopener noreferrer"
                                                                                        onClick={(e) => e.stopPropagation()}
                                                                                        className="p-2 hover:bg-blue-100 rounded-lg transition-colors text-blue-500"
                                                                                    >
                                                                                        <ExternalLink size={18} />
                                                                                    </a>
                                                                                )}
                                                                                <button
                                                                                    onClick={() => navigate(getEditPath(schedule.id, catId))}
                                                                                    className="p-2 hover:bg-gray-200 rounded-lg transition-colors text-gray-500"
                                                                                >
                                                                                    <Edit2 size={18} />
                                                                                </button>
                                                                                <button
                                                                                    onClick={() => openDeleteDialog(schedule)}
                                                                                    className="p-2 hover:bg-red-100 rounded-lg transition-colors text-red-500"
                                                                                >
                                                                                    <Trash2 size={18} />
                                                                                </button>
                                                                            </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>
                                        </>
                                    ) : (
                                        /* 일반 모드: ScheduleItem 컴포넌트 사용 */
                                        filteredSchedules.map((schedule, index) => (
                                            <ScheduleItem
                                                key={`${schedule.id}-${selectedDate || 'all'}`}
                                                schedule={schedule}
                                                index={index}
                                                selectedDate={selectedDate}
                                                categories={categories}
                                                getColorStyle={getColorStyle}
                                                navigate={navigate}
                                                openDeleteDialog={openDeleteDialog}
                                            />
                                        ))
                                    )}
                                </div>
                            )}
                        </div>
                    </div>
                </div>
            </div>
        </AdminLayout>
    );
}

export default AdminSchedule;
