import { useState, useEffect, useRef, useMemo } from 'react';
import { useNavigate } from 'react-router-dom';
import { motion, AnimatePresence } from 'framer-motion';
import { Clock, ChevronLeft, ChevronRight, ChevronDown, Tag, Search, ArrowLeft } from 'lucide-react';

function Schedule() {
    const navigate = useNavigate();
    
    // KST 기준 오늘 날짜 (YYYY-MM-DD)
    const getTodayKST = () => {
        const now = new Date();
        const kstOffset = 9 * 60 * 60 * 1000; // 9시간
        const kstDate = new Date(now.getTime() + kstOffset);
        return kstDate.toISOString().split('T')[0];
    };
    
    const [currentDate, setCurrentDate] = useState(new Date());
    const [selectedDate, setSelectedDate] = useState(getTodayKST()); // KST 기준 오늘
    const [showYearMonthPicker, setShowYearMonthPicker] = useState(false);
    const [viewMode, setViewMode] = useState('yearMonth');
    const [slideDirection, setSlideDirection] = useState(0);
    const pickerRef = useRef(null);


    // 데이터 상태
    const [schedules, setSchedules] = useState([]);
    const [categories, setCategories] = useState([]);
    const [selectedCategories, setSelectedCategories] = useState([]);
    const [loading, setLoading] = useState(true);

    // 카테고리 필터 툴팁
    const [showCategoryTooltip, setShowCategoryTooltip] = useState(false);
    const categoryRef = useRef(null);
    
    // 검색 상태
    const [isSearchMode, setIsSearchMode] = useState(false);
    const [searchInput, setSearchInput] = useState('');
    const [searchTerm, setSearchTerm] = useState('');
    const [searchResults, setSearchResults] = useState([]);
    const [searchLoading, setSearchLoading] = useState(false);

    // 데이터 로드
    useEffect(() => {
        fetchSchedules();
        fetchCategories();
    }, []);

    const fetchSchedules = async () => {
        try {
            const response = await fetch('/api/schedules');
            if (response.ok) {
                const data = await response.json();
                setSchedules(data);
            }
        } catch (error) {
            console.error('일정 로드 오류:', error);
        } finally {
            setLoading(false);
        }
    };

    const fetchCategories = async () => {
        try {
            const response = await fetch('/api/schedule-categories');
            if (response.ok) {
                const data = await response.json();
                setCategories(data);
            }
        } catch (error) {
            console.error('카테고리 로드 오류:', error);
        }
    };
    
    // 검색 함수 (Meilisearch API 호출)
    const searchSchedules = async (term) => {
        if (!term.trim()) {
            setSearchResults([]);
            return;
        }
        setSearchLoading(true);
        try {
            const response = await fetch(`/api/schedules?search=${encodeURIComponent(term)}`);
            if (response.ok) {
                const data = await response.json();
                setSearchResults(data);
            }
        } catch (error) {
            console.error('검색 오류:', error);
        } finally {
            setSearchLoading(false);
        }
    };

    // 외부 클릭시 팝업 닫기
    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);
            }
        };

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

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

    const year = currentDate.getFullYear();
    const month = currentDate.getMonth();
    const daysInMonth = getDaysInMonth(year, month);
    const firstDay = getFirstDayOfMonth(year, month);

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

    // 스케줄이 있는 날짜 목록 (ISO 형식에서 YYYY-MM-DD 추출)
    const scheduleDates = schedules.map(s => s.date ? s.date.split('T')[0] : '');

    // 해당 날짜의 첫 번째 일정 카테고리 색상
    const getScheduleColor = (day) => {
        const dateStr = `${year}-${String(month + 1).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
        const schedule = schedules.find(s => (s.date ? s.date.split('T')[0] : '') === dateStr);
        if (!schedule) return null;
        const cat = categories.find(c => c.id === schedule.category_id);
        return cat?.color || '#4A7C59';
    };

    const hasSchedule = (day) => {
        const dateStr = `${year}-${String(month + 1).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
        return scheduleDates.includes(dateStr);
    };

    const prevMonth = () => {
        setSlideDirection(-1);
        setCurrentDate(new Date(year, month - 1, 1));
        setSelectedDate(null); // 월 변경 시 초기화
    };

    const nextMonth = () => {
        setSlideDirection(1);
        setCurrentDate(new Date(year, month + 1, 1));
        setSelectedDate(null); // 월 변경 시 초기화
    };

    const selectDate = (day) => {
        const dateStr = `${year}-${String(month + 1).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
        setSelectedDate(selectedDate === dateStr ? null : dateStr);
    };

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

    const selectMonth = (newMonth) => {
        setCurrentDate(new Date(year, newMonth, 1));
        setShowYearMonthPicker(false);
        setViewMode('yearMonth');
    };

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

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

        
        // 일반 모드: 기존 필터링
        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 formatDate = (dateStr) => {
        const date = new Date(dateStr);
        const dayNames = ['일', '월', '화', '수', '목', '금', '토'];
        return {
            month: date.getMonth() + 1,
            day: date.getDate(),
            weekday: dayNames[date.getDay()],
        };
    };

    // 일정 클릭 핸들러
    const handleScheduleClick = (schedule) => {
        // 설명이 없고 URL만 있으면 바로 링크 열기
        if (!schedule.description && schedule.source_url) {
            window.open(schedule.source_url, '_blank');
        } else {
            // 상세 페이지로 이동 (추후 구현)
            navigate(`/schedule/${schedule.id}`);
        }
    };

    // 년도 범위
    const startYear = Math.floor(year / 10) * 10 - 1;
    const yearRange = Array.from({ length: 12 }, (_, i) => startYear + i);
    
    const isCurrentYear = (y) => new Date().getFullYear() === y;
    const isCurrentMonth = (m) => {
        const today = new Date();
        return today.getFullYear() === year && today.getMonth() === m;
    };
    
    const monthNames = ['1월', '2월', '3월', '4월', '5월', '6월', '7월', '8월', '9월', '10월', '11월', '12월'];
    
    const prevYearRange = () => setCurrentDate(new Date(year - 10, month, 1));
    const nextYearRange = () => setCurrentDate(new Date(year + 10, month, 1));

    // 선택된 카테고리 이름
    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}개`;
    };

    // 카테고리 색상 가져오기
    const getCategoryColor = (categoryId) => {
        const cat = categories.find(c => c.id === categoryId);
        return cat?.color || '#808080';
    };

    const getCategoryName = (categoryId) => {
        const cat = categories.find(c => c.id === categoryId);
        return cat?.name || '';
    };

    // 정렬된 카테고리 목록 (메모이제이션으로 깜빡임 방지)
    const sortedCategories = useMemo(() => {
        return categories
            .map(category => {
                const count = isSearchMode && searchTerm
                    ? searchResults.filter(s => s.category_id === category.id).length
                    : schedules.filter(s => {
                        const scheduleDate = s.date ? s.date.split('T')[0] : '';
                        return scheduleDate.startsWith(currentYearMonth) && s.category_id === category.id;
                    }).length;
                return { ...category, count };
            })
            .filter(category => category.count > 0)
            .sort((a, b) => {
                if (a.name === '기타') return 1;
                if (b.name === '기타') return -1;
                return b.count - a.count;
            });
    }, [categories, schedules, searchResults, isSearchMode, searchTerm, currentYearMonth]);

    return (
        <div className="py-16">
            <div className="max-w-7xl mx-auto px-6">
                {/* 헤더 */}
                <div className="text-center mb-12">
                    <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 gap-8">
                    {/* 왼쪽: 달력 + 카테고리 */}
                    <div className="w-[400px] flex-shrink-0">
                        {/* 달력 */}
                        <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 ? 'border border-primary text-primary 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 ? 'border border-primary text-primary 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 ? 'border border-primary text-primary 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();

                                            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 ? 'bg-primary/10 text-primary font-bold hover:bg-primary/20' : ''}
                                                        ${dayOfWeek === 0 && !isSelected && !isToday ? 'text-red-500' : ''}
                                                        ${dayOfWeek === 6 && !isSelected && !isToday ? 'text-blue-500' : ''}
                                                    `}
                                                >
                                                    <span>{day}</span>
                                                    {/* 점: absolute로 위치 고정하여 글씨 위치에 영향 없음 */}
                                                    <span 
                                                        className={`absolute bottom-1 w-1.5 h-1.5 rounded-full ${hasEvent ? '' : 'opacity-0'}`}
                                                        style={{ backgroundColor: isSelected ? 'white' : (eventColor || 'transparent') }}
                                                    />
                                                </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 justify-between 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>
                                <button
                                    onClick={() => setSelectedDate(null)}
                                    className={`px-4 py-2 rounded-lg transition-colors ${
                                        selectedDate 
                                            ? 'bg-primary text-white hover:bg-primary-dark' 
                                            : 'bg-gray-100 text-gray-400 cursor-default'
                                    }`}
                                    disabled={!selectedDate}
                                >
                                    전체 보기
                                </button>
                            </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">
                                        {isSearchMode && searchTerm 
                                            ? searchResults.length
                                            : schedules.filter(s => {
                                                const scheduleDate = s.date ? s.date.split('T')[0] : '';
                                                return scheduleDate.startsWith(currentYearMonth);
                                            }).length
                                        }
                                    </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="flex-1">
                        {/* 헤더 */}
                        <div className="flex items-center justify-between mb-4">
                            <AnimatePresence mode="wait">
                                {isSearchMode ? (
                                    /* 검색 모드 - 밑줄 스타일 */
                                    <motion.div 
                                        key="search-mode"
                                        initial={{ opacity: 0, x: -10 }}
                                        animate={{ opacity: 1, x: 0 }}
                                        exit={{ opacity: 0, x: -10 }}
                                        transition={{ duration: 0.15 }}
                                        className="flex items-center gap-3 flex-1"
                                    >
                                        <button
                                            onClick={() => {
                                                setIsSearchMode(false);
                                                setSearchInput('');
                                                setSearchTerm('');
                                                setSearchResults([]);
                                            }}
                                            className="p-1.5 hover:bg-gray-100 rounded-lg transition-colors"
                                        >
                                            <ArrowLeft size={20} className="text-gray-500" />
                                        </button>
                                        <div className="flex-1 flex items-center gap-3 border-b border-gray-300 pb-1">
                                            <input
                                                type="text"
                                                placeholder="일정 검색..."
                                                value={searchInput}
                                                autoFocus
                                                onChange={(e) => setSearchInput(e.target.value)}
                                                onKeyDown={(e) => {
                                                    if (e.key === 'Enter') {
                                                        setSearchTerm(searchInput);
                                                        searchSchedules(searchInput);
                                                    } else if (e.key === 'Escape') {
                                                        setIsSearchMode(false);
                                                        setSearchInput('');
                                                        setSearchTerm('');
                                                        setSearchResults([]);
                                                    }
                                                }}
                                                className="flex-1 bg-transparent focus:outline-none text-gray-700 placeholder-gray-400"
                                            />
                                        </div>
                                        <button
                                            onClick={() => {
                                                setSearchTerm(searchInput);
                                                searchSchedules(searchInput);
                                            }}
                                            disabled={searchLoading}
                                            className="px-4 py-1.5 bg-primary text-white text-sm font-medium rounded-lg hover:bg-primary/90 transition-colors disabled:opacity-50"
                                        >
                                            {searchLoading ? '...' : '검색'}
                                        </button>
                                    </motion.div>
                                ) : (
                                    /* 일반 모드 */
                                    <motion.div 
                                        key="normal-mode"
                                        initial={{ opacity: 0, x: 10 }}
                                        animate={{ opacity: 1, x: 0 }}
                                        exit={{ opacity: 0, x: 10 }}
                                        transition={{ duration: 0.15 }}
                                        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>

                        <motion.div 
                            key={isSearchMode ? 'search' : 'normal'}
                            initial={{ opacity: 0 }}
                            animate={{ opacity: 1 }}
                            transition={{ duration: 0.15 }}
                            className="max-h-[calc(100vh-200px)] overflow-y-auto space-y-4 py-2 pr-2"
                        >
                            {loading ? (
                                <div className="text-center py-20 text-gray-500">로딩 중...</div>
                            ) : filteredSchedules.length > 0 ? (

                                filteredSchedules.map((schedule, index) => {
                                    const formatted = formatDate(schedule.date);
                                    const categoryColor = getCategoryColor(schedule.category_id);
                                    const categoryName = getCategoryName(schedule.category_id);
                                    
                                    return (
                                        <motion.div
                                            key={`${schedule.id}-${selectedDate || 'all'}`}
                                            initial={{ opacity: 0 }}
                                            animate={{ opacity: 1 }}
                                            transition={{ delay: Math.min(index, 10) * 0.03 }}

                                            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 }}
                                            >
                                                {/* 검색 모드일 때 년.월 표시, 일반 모드에서는 월 표시 안함 */}
                                                {isSearchMode && searchTerm && (
                                                    <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-6 flex flex-col justify-center">
                                                <h3 className="font-bold text-lg mb-2">{schedule.title}</h3>
                                                
                                                <div className="flex flex-wrap gap-3 text-base text-gray-500">
                                                    {schedule.time && (
                                                        <div className="flex items-center gap-1">
                                                            <Clock size={16} style={{ color: categoryColor }} />
                                                            <span>{schedule.time.slice(0, 5)}</span>
                                                        </div>
                                                    )}
                                                    {categoryName && (
                                                        <div className="flex items-center gap-1">
                                                            <span 
                                                                className="w-2 h-2 rounded-full flex-shrink-0" 
                                                                style={{ backgroundColor: categoryColor }}
                                                            />
                                                            <span>
                                                                {categoryName}
                                                                {schedule.source_name && ` · ${schedule.source_name}`}
                                                            </span>
                                                        </div>
                                                    )}
                                                </div>
                                                {/* 멤버 태그 (별도 줄) */}
                                                {(() => {
                                                    const memberList = schedule.members 
                                                        ? schedule.members.map(m => m.name)
                                                        : (schedule.member_names ? schedule.member_names.split(',') : []);
                                                    if (memberList.length === 0) return null;
                                                    
                                                    // 5명 이상이면 '프로미스나인' 단일 태그
                                                    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>
                                        </motion.div>
                                    );
                                })
                            ) : (
                                <div className="text-center py-20 text-gray-500">
                                    {selectedDate ? '선택한 날짜에 일정이 없습니다.' : '예정된 일정이 없습니다.'}
                                </div>
                            )}
                        </motion.div>
                    </div>

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

export default Schedule;