app.py

import gradio as gr
import pandas as pd
import os
import time
import threading
import tempfile
import logging
import random
import uuid
import shutil
import glob
from datetime import datetime
from gradio_client import Client
from dotenv import load_dotenv

# 환경변수 로드
load_dotenv()

# 로깅 설정 (API 엔드포인트 정보는 제외)
class SecureFilter(logging.Filter):
    """API 엔드포인트 정보를 로그에서 제거하는 필터"""
    def filter(self, record):
        # API 엔드포인트 관련 로그 필터링
        message = record.getMessage()
        if any(keyword in message.lower() for keyword in ['hf.space', 'happydoggg', 'gradio_api', 'http request']):
            return False
        return True

# 보안 필터 적용
secure_filter = SecureFilter()

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.StreamHandler(),
        logging.FileHandler('control_tower_app.log', mode='a')
    ]
)

logger = logging.getLogger(__name__)
logger.addFilter(secure_filter)

# HTTP 요청 로그도 숨김
logging.getLogger("httpx").setLevel(logging.WARNING)
logging.getLogger("gradio_client").setLevel(logging.WARNING)

# API 클라이언트 초기화
def get_api_client():
    """환경변수에서 API 엔드포인트를 가져와 클라이언트 생성"""
    endpoint = os.getenv('API_ENDPOINT')
    if not endpoint:
        logger.error("API_ENDPOINT 환경변수가 설정되지 않았습니다.")
        raise ValueError("API_ENDPOINT 환경변수가 필요합니다.")
    return Client(endpoint)

# 세션별 임시 파일 관리를 위한 딕셔너리
session_temp_files = {}
session_data = {}

def cleanup_huggingface_temp_folders():
    """허깅페이스 임시 폴더 초기 정리"""
    try:
        # 일반적인 임시 디렉토리들
        temp_dirs = [
            tempfile.gettempdir(),
            "/tmp",
            "/var/tmp",
            os.path.join(os.getcwd(), "temp"),
            os.path.join(os.getcwd(), "tmp"),
            "/gradio_cached_examples",
            "/flagged"
        ]
        
        cleanup_count = 0
        
        for temp_dir in temp_dirs:
            if os.path.exists(temp_dir):
                try:
                    # 기존 세션 파일들 정리
                    session_files = glob.glob(os.path.join(temp_dir, "session_*.xlsx"))
                    session_files.extend(glob.glob(os.path.join(temp_dir, "session_*.csv")))
                    session_files.extend(glob.glob(os.path.join(temp_dir, "*keyword*.xlsx")))
                    session_files.extend(glob.glob(os.path.join(temp_dir, "*keyword*.csv")))
                    session_files.extend(glob.glob(os.path.join(temp_dir, "tmp*.xlsx")))
                    session_files.extend(glob.glob(os.path.join(temp_dir, "tmp*.csv")))
                    
                    for file_path in session_files:
                        try:
                            # 파일이 1시간 이상 오래된 경우만 삭제
                            if os.path.getmtime(file_path) < time.time() - 3600:
                                os.remove(file_path)
                                cleanup_count += 1
                                logger.info(f"초기 정리: 오래된 임시 파일 삭제 - {file_path}")
                        except Exception as e:
                            logger.warning(f"파일 삭제 실패 (무시됨): {file_path} - {e}")
                            
                except Exception as e:
                    logger.warning(f"임시 디렉토리 정리 실패 (무시됨): {temp_dir} - {e}")
        
        logger.info(f"✅ 허깅페이스 임시 폴더 초기 정리 완료 - {cleanup_count}개 파일 삭제")
        
        # Gradio 캐시 폴더도 정리
        try:
            gradio_temp_dir = os.path.join(os.getcwd(), "gradio_cached_examples")
            if os.path.exists(gradio_temp_dir):
                shutil.rmtree(gradio_temp_dir, ignore_errors=True)
                logger.info("Gradio 캐시 폴더 정리 완료")
        except Exception as e:
            logger.warning(f"Gradio 캐시 폴더 정리 실패 (무시됨): {e}")
            
    except Exception as e:
        logger.error(f"초기 임시 폴더 정리 중 오류 (계속 진행): {e}")

def setup_clean_temp_environment():
    """깨끗한 임시 환경 설정"""
    try:
        # 1. 기존 임시 파일들 정리
        cleanup_huggingface_temp_folders()
        
        # 2. 애플리케이션 전용 임시 디렉토리 생성
        app_temp_dir = os.path.join(tempfile.gettempdir(), "control_tower_app")
        if os.path.exists(app_temp_dir):
            shutil.rmtree(app_temp_dir, ignore_errors=True)
        os.makedirs(app_temp_dir, exist_ok=True)
        
        # 3. 환경 변수 설정 (임시 디렉토리 지정)
        os.environ['CONTROL_TOWER_TEMP'] = app_temp_dir
        
        logger.info(f"✅ 애플리케이션 전용 임시 디렉토리 설정: {app_temp_dir}")
        
        return app_temp_dir
        
    except Exception as e:
        logger.error(f"임시 환경 설정 실패: {e}")
        return tempfile.gettempdir()

def get_app_temp_dir():
    """애플리케이션 전용 임시 디렉토리 반환"""
    return os.environ.get('CONTROL_TOWER_TEMP', tempfile.gettempdir())

def get_session_id():
    """세션 ID 생성 - 원본 API와 동일"""
    try:
        client = get_api_client()
        result = client.predict(api_name="/get_session_id")
        return result
    except Exception as e:
        logger.error(f"세션 ID 생성 API 호출 오류: {e}")
        return str(uuid.uuid4())

def cleanup_session_files(session_id, delay=300):
    """세션별 임시 파일 정리 함수"""
    def cleanup():
        time.sleep(delay)
        if session_id in session_temp_files:
            files_to_remove = session_temp_files[session_id].copy()
            del session_temp_files[session_id]
            
            for file_path in files_to_remove:
                try:
                    if os.path.exists(file_path):
                        os.remove(file_path)
                        logger.info(f"세션 {session_id[:8]}... 임시 파일 삭제: {file_path}")
                except Exception as e:
                    logger.error(f"세션 {session_id[:8]}... 파일 삭제 오류: {e}")
    
    threading.Thread(target=cleanup, daemon=True).start()

def register_session_file(session_id, file_path):
    """세션별 파일 등록"""
    if session_id not in session_temp_files:
        session_temp_files[session_id] = []
    session_temp_files[session_id].append(file_path)

def cleanup_old_sessions():
    """오래된 세션 데이터 정리"""
    current_time = time.time()
    sessions_to_remove = []
    
    for session_id, data in session_data.items():
        if current_time - data.get('last_activity', 0) > 3600:  # 1시간 초과
            sessions_to_remove.append(session_id)
    
    for session_id in sessions_to_remove:
        # 파일 정리
        if session_id in session_temp_files:
            for file_path in session_temp_files[session_id]:
                try:
                    if os.path.exists(file_path):
                        os.remove(file_path)
                        logger.info(f"오래된 세션 {session_id[:8]}... 파일 삭제: {file_path}")
                except Exception as e:
                    logger.error(f"오래된 세션 파일 삭제 오류: {e}")
            del session_temp_files[session_id]
        
        # 세션 데이터 정리
        if session_id in session_data:
            del session_data[session_id]
            logger.info(f"오래된 세션 데이터 삭제: {session_id[:8]}...")

def update_session_activity(session_id):
    """세션 활동 시간 업데이트"""
    if session_id not in session_data:
        session_data[session_id] = {}
    session_data[session_id]['last_activity'] = time.time()

def create_session_temp_file(session_id, suffix='.xlsx'):
    """세션별 임시 파일 생성 (전용 디렉토리 사용)"""
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    random_suffix = str(random.randint(1000, 9999))
    
    # 애플리케이션 전용 임시 디렉토리 사용
    temp_dir = get_app_temp_dir()
    filename = f"session_{session_id[:8]}_{timestamp}_{random_suffix}{suffix}"
    temp_file_path = os.path.join(temp_dir, filename)
    
    # 빈 파일 생성
    with open(temp_file_path, 'w') as f:
        pass
    
    register_session_file(session_id, temp_file_path)
    return temp_file_path

# ========== 원본 API와 정확히 동일한 함수들 ==========

def search_with_loading(keyword, korean_only, apply_main_keyword, exclude_zero_volume):
    """원본 API: /search_with_loading (4개 매개변수, 1개 반환값)"""
    try:
        client = get_api_client()
        result = client.predict(
            keyword=keyword,
            korean_only=korean_only,
            apply_main_keyword=apply_main_keyword,
            exclude_zero_volume=exclude_zero_volume,
            api_name="/search_with_loading"
        )
        return result
    except Exception as e:
        logger.error(f"search_with_loading API 호출 오류: {e}")
        return gr.update(visible=True)

def process_search_results(keyword, korean_only, apply_main_keyword, exclude_zero_volume):
    """원본 API: /process_search_results (4개 매개변수, 6개 반환값)"""
    try:
        client = get_api_client()
        result = client.predict(
            keyword=keyword,
            korean_only=korean_only,
            apply_main_keyword=apply_main_keyword,
            exclude_zero_volume=exclude_zero_volume,
            api_name="/process_search_results"
        )
        
        # 원본 API 문서에 따르면 6개 반환값이지만 실제로는 5개일 수 있음
        # 안전하게 처리
        if len(result) == 6:
            table_html, cat_choices, vol_choices, selected_cat, download_file, progress_html = result
        elif len(result) == 5:
            table_html, cat_choices, vol_choices, selected_cat, download_file = result
            progress_html = ""
        else:
            logger.error(f"예상과 다른 반환값 개수: {len(result)}")
            return (
                "<p>서비스 응답 형식에 문제가 발생했습니다.</p>",
                ["전체 보기"], ["전체"], "전체 보기", None, ""
            )
        
        # 다운로드 파일이 있는 경우 로컬로 복사
        local_download_file = None
        if download_file:
            session_id = get_session_id()
            local_download_file = create_session_temp_file(session_id, '.xlsx')
            try:
                shutil.copy2(download_file, local_download_file)
            except Exception as e:
                logger.error(f"파일 복사 오류: {e}")
                local_download_file = None
        
        return table_html, cat_choices, vol_choices, selected_cat, local_download_file, progress_html
        
    except Exception as e:
        logger.error(f"API 호출 오류: {e}")
        return (
            "<p>서비스 연결에 문제가 발생했습니다. 잠시 후 다시 시도해주세요.</p>",
            ["전체 보기"], ["전체"], "전체 보기", None, ""
        )

def filter_and_sort_table(selected_cat, keyword_sort, total_volume_sort, usage_count_sort, selected_volume_range, exclude_zero_volume):
    """원본 API: /filter_and_sort_table (6개 매개변수, 1개 반환값)"""
    try:
        client = get_api_client()
        result = client.predict(
            selected_cat=selected_cat,
            keyword_sort=keyword_sort,
            total_volume_sort=total_volume_sort,
            usage_count_sort=usage_count_sort,
            selected_volume_range=selected_volume_range,
            exclude_zero_volume=exclude_zero_volume,
            api_name="/filter_and_sort_table"
        )
        return result
    except Exception as e:
        logger.error(f"filter_and_sort_table API 호출 오류: {e}")
        return "<p>필터링 서비스 연결에 문제가 발생했습니다.</p>"

def filter_and_sort_table_1(selected_cat, keyword_sort, total_volume_sort, usage_count_sort, selected_volume_range, exclude_zero_volume):
    """원본 API: /filter_and_sort_table_1"""
    try:
        client = get_api_client()
        result = client.predict(
            selected_cat=selected_cat,
            keyword_sort=keyword_sort,
            total_volume_sort=total_volume_sort,
            usage_count_sort=usage_count_sort,
            selected_volume_range=selected_volume_range,
            exclude_zero_volume=exclude_zero_volume,
            api_name="/filter_and_sort_table_1"
        )
        return result
    except Exception as e:
        logger.error(f"filter_and_sort_table_1 API 호출 오류: {e}")
        return "<p>필터링 서비스 연결에 문제가 발생했습니다.</p>"

def filter_and_sort_table_2(selected_cat, keyword_sort, total_volume_sort, usage_count_sort, selected_volume_range, exclude_zero_volume):
    """원본 API: /filter_and_sort_table_2"""
    try:
        client = get_api_client()
        result = client.predict(
            selected_cat=selected_cat,
            keyword_sort=keyword_sort,
            total_volume_sort=total_volume_sort,
            usage_count_sort=usage_count_sort,
            selected_volume_range=selected_volume_range,
            exclude_zero_volume=exclude_zero_volume,
            api_name="/filter_and_sort_table_2"
        )
        return result
    except Exception as e:
        logger.error(f"filter_and_sort_table_2 API 호출 오류: {e}")
        return "<p>필터링 서비스 연결에 문제가 발생했습니다.</p>"

def filter_and_sort_table_3(selected_cat, keyword_sort, total_volume_sort, usage_count_sort, selected_volume_range, exclude_zero_volume):
    """원본 API: /filter_and_sort_table_3"""
    try:
        client = get_api_client()
        result = client.predict(
            selected_cat=selected_cat,
            keyword_sort=keyword_sort,
            total_volume_sort=total_volume_sort,
            usage_count_sort=usage_count_sort,
            selected_volume_range=selected_volume_range,
            exclude_zero_volume=exclude_zero_volume,
            api_name="/filter_and_sort_table_3"
        )
        return result
    except Exception as e:
        logger.error(f"filter_and_sort_table_3 API 호출 오류: {e}")
        return "<p>필터링 서비스 연결에 문제가 발생했습니다.</p>"

def filter_and_sort_table_4(selected_cat, keyword_sort, total_volume_sort, usage_count_sort, selected_volume_range, exclude_zero_volume):
    """원본 API: /filter_and_sort_table_4"""
    try:
        client = get_api_client()
        result = client.predict(
            selected_cat=selected_cat,
            keyword_sort=keyword_sort,
            total_volume_sort=total_volume_sort,
            usage_count_sort=usage_count_sort,
            selected_volume_range=selected_volume_range,
            exclude_zero_volume=exclude_zero_volume,
            api_name="/filter_and_sort_table_4"
        )
        return result
    except Exception as e:
        logger.error(f"filter_and_sort_table_4 API 호출 오류: {e}")
        return "<p>필터링 서비스 연결에 문제가 발생했습니다.</p>"

def update_category_selection(selected_cat):
    """원본 API: /update_category_selection (1개 매개변수, 1개 반환값)"""
    try:
        client = get_api_client()
        result = client.predict(
            selected_cat=selected_cat,
            api_name="/update_category_selection"
        )
        return gr.update(value=result)
    except Exception as e:
        logger.error(f"update_category_selection API 호출 오류: {e}")
        return gr.update(value=selected_cat)

def analyze_with_loading(analysis_keywords, selected_category):
    """원본 API: /analyze_with_loading (2개 매개변수, 1개 반환값)"""
    try:
        client = get_api_client()
        result = client.predict(
            analysis_keywords=analysis_keywords,
            selected_category=selected_category,
            api_name="/analyze_with_loading"
        )
        return result
    except Exception as e:
        logger.error(f"analyze_with_loading API 호출 오류: {e}")
        return gr.update(visible=True)

def process_analyze_results(analysis_keywords, selected_category):
    """원본 API: /process_analyze_results (2개 매개변수, 2개 반환값)"""
    try:
        client = get_api_client()
        result = client.predict(
            analysis_keywords=analysis_keywords,
            selected_category=selected_category,
            api_name="/process_analyze_results"
        )
        
        analysis_result, download_file = result
        
        # 다운로드 파일이 있는 경우 로컬로 복사
        local_download_file = None
        if download_file:
            session_id = get_session_id()
            local_download_file = create_session_temp_file(session_id, '.xlsx')
            try:
                shutil.copy2(download_file, local_download_file)
            except Exception as e:
                logger.error(f"분석 결과 파일 복사 오류: {e}")
                local_download_file = None
        
        return analysis_result, local_download_file
        
    except Exception as e:
        logger.error(f"process_analyze_results API 호출 오류: {e}")
        return "분석 서비스 연결에 문제가 발생했습니다. 잠시 후 다시 시도해주세요.", None

def reset_interface():
    """원본 API: /reset_interface (0개 매개변수, 16개 반환값)"""
    try:
        client = get_api_client()
        result = client.predict(api_name="/reset_interface")
        return result
    except Exception as e:
        logger.error(f"reset_interface API 호출 오류: {e}")
        # 기본 리셋 값 반환 (16개)
        return (
            "", # 검색 키워드
            True, # 한글만 추출
            False, # 검색량 0 키워드 제외
            "메인키워드 적용", # 조합 방식
            "", # HTML 테이블
            ["전체 보기"], # 카테고리 필터 choices
            "전체 보기", # 카테고리 필터 value
            ["전체"], # 검색량 구간 필터 choices
            "전체", # 검색량 구간 필터 value
            "정렬 없음", # 총검색량 정렬
            "정렬 없음", # 키워드 사용횟수 정렬
            ["전체 보기"], # 분석할 카테고리 choices
            "전체 보기", # 분석할 카테고리 value
            "", # 키워드 입력
            "", # 분석 결과
            None # 다운로드 파일
        )

# ========== UI 처리 래퍼 함수들 ==========

def wrapper_search_with_loading(keyword, korean_only, apply_main_keyword, exclude_zero_volume):
    """검색 로딩 UI 처리"""
    result = search_with_loading(keyword, korean_only, apply_main_keyword, exclude_zero_volume)
    return (
        gr.update(visible=True),  # progress_section
        gr.update(visible=False)  # empty_table_html
    )

def wrapper_process_search_results(keyword, korean_only, apply_main_keyword, exclude_zero_volume):
    """검색 결과 처리 UI"""
    result = process_search_results(keyword, korean_only, apply_main_keyword, exclude_zero_volume)
    
    # 안전하게 결과 처리
    if len(result) >= 5:
        table_html, cat_choices, vol_choices, selected_cat, download_file = result[:5]
        progress_html = result[5] if len(result) > 5 else ""
    else:
        logger.error(f"검색 결과 처리 오류: 예상보다 적은 반환값 {len(result)}")
        table_html = "<p>검색 결과 처리에 문제가 발생했습니다.</p>"
        cat_choices = ["전체 보기"]
        vol_choices = ["전체"]
        selected_cat = "전체 보기"
        download_file = None
        progress_html = ""
    
    # UI 표시 여부 결정
    if table_html and "검색 결과가 없습니다" not in table_html and "문제가 발생했습니다" not in table_html:
        keyword_section_visibility = True
        category_section_visibility = True
        empty_placeholder_vis = False
        execution_section_visibility = True
    else:
        keyword_section_visibility = False
        category_section_visibility = False
        empty_placeholder_vis = True
        execution_section_visibility = False
    
    # 가상의 state_df (원본과 호환성을 위해)
    state_df = pd.DataFrame()
    
    return (
        table_html,  # table_output
        cat_choices,  # category_filter choices
        vol_choices,  # search_volume_filter choices
        state_df,  # state_df
        selected_cat,  # selected_category value
        download_file,  # download_output
        gr.update(visible=keyword_section_visibility),  # keyword_analysis_section
        gr.update(visible=category_section_visibility),  # category_analysis_section
        gr.update(visible=False),  # progress_section
        gr.update(visible=empty_placeholder_vis),  # empty_table_html
        gr.update(visible=execution_section_visibility),  # execution_section
        keyword  # keyword_state
    )

def wrapper_analyze_with_loading(analysis_keywords, selected_category, state_df):
    """분석 로딩 UI 처리"""
    result = analyze_with_loading(analysis_keywords, selected_category)
    return gr.update(visible=True)  # progress_section

def wrapper_process_analyze_results(analysis_keywords, selected_category, state_df):
    """분석 결과 처리 UI"""
    analysis_result, download_file = process_analyze_results(analysis_keywords, selected_category)
    return (
        analysis_result,  # analysis_result
        download_file,  # download_output
        gr.update(visible=True),  # analysis_output_section
        gr.update(visible=False)  # progress_section
    )

# 세션 정리 스케줄러
def start_session_cleanup_scheduler():
    """세션 정리 스케줄러 시작"""
    def cleanup_scheduler():
        while True:
            time.sleep(600)  # 10분마다 실행
            cleanup_old_sessions()
            cleanup_huggingface_temp_folders()
    
    threading.Thread(target=cleanup_scheduler, daemon=True).start()

def cleanup_on_startup():
    """애플리케이션 시작 시 전체 정리"""
    logger.info("🧹 컨트롤 타워 애플리케이션 시작 - 초기 정리 작업 시작...")
    
    # 1. 허깅페이스 임시 폴더 정리
    cleanup_huggingface_temp_folders()
    
    # 2. 깨끗한 임시 환경 설정
    app_temp_dir = setup_clean_temp_environment()
    
    # 3. 전역 변수 초기화
    global session_temp_files, session_data
    session_temp_files.clear()
    session_data.clear()
    
    logger.info(f"✅ 초기 정리 작업 완료 - 앱 전용 디렉토리: {app_temp_dir}")
    
    return app_temp_dir

# Gradio 인터페이스 생성
def create_app():
    fontawesome_html = """
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css">
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/orioncactus/pretendard/dist/web/static/pretendard.css">
    <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Noto+Sans+KR:wght@300;400;500;700&display=swap">
    """
    
    # CSS 파일 로드
    try:
        with open('style.css', 'r', encoding='utf-8') as f:
            custom_css = f.read()
    except:
        custom_css = """
        :root {
            --primary-color: #FB7F0D;
            --secondary-color: #ff9a8b;
        }
        .custom-button {
            background: linear-gradient(135deg, var(--primary-color), var(--secondary-color)) !important;
            color: white !important;
            border-radius: 30px !important;
            height: 45px !important;
            font-size: 16px !important;
            font-weight: bold !important;
            width: 100% !important;
            text-align: center !important;
            display: flex !important;
            align-items: center !important;
            justify-content: center !important;
        }
        """
    
    with gr.Blocks(css=custom_css, theme=gr.themes.Default(
        primary_hue="orange",
        secondary_hue="orange",
        font=[gr.themes.GoogleFont("Noto Sans KR"), "ui-sans-serif", "system-ui"]
    )) as demo:
        gr.HTML(fontawesome_html)
        
        # 키워드 상태 관리
        keyword_state = gr.State("")
        
        # 입력 섹션
        with gr.Column(elem_classes="custom-frame fade-in"):
            gr.HTML('<div class="section-title"><i class="fas fa-search"></i> 검색 입력</div>')
            
            with gr.Row():
                with gr.Column(scale=1):
                    keyword = gr.Textbox(
                        label="메인 키워드", 
                        placeholder="예: 오징어"
                    )
                with gr.Column(scale=1):
                    search_btn = gr.Button(
                        "메인키워드 분석", 
                        elem_classes="custom-button"
                    )
            
            with gr.Accordion("옵션 설정", open=False):
                with gr.Row():
                    with gr.Column(scale=1):
                        korean_only = gr.Checkbox(
                            label="한글만 추출", 
                            value=True
                        )
                    with gr.Column(scale=1):
                        exclude_zero_volume = gr.Checkbox(
                            label="검색량 0 키워드 제외", 
                            value=False
                        )
                
                with gr.Row():
                    with gr.Column(scale=1):
                        apply_main_keyword = gr.Radio(
                            ["메인키워드 적용", "메인키워드 미적용"], 
                            label="조합 방식", 
                            value="메인키워드 적용"
                        )
                    with gr.Column(scale=1):
                        gr.HTML("")
        
        # 진행 상태 표시 섹션
        with gr.Column(elem_classes="custom-frame fade-in", visible=False) as progress_section:
            gr.HTML('<div class="section-title"><i class="fas fa-spinner"></i> 분석 진행 상태</div>')
            progress_html = gr.HTML("""
            <div style="padding: 15px; background-color: #f9f9f9; border-radius: 5px; margin: 10px 0; border: 1px solid #ddd;">
                <div style="margin-bottom: 10px; display: flex; align-items: center;">
                    <i class="fas fa-spinner fa-spin" style="color: #FB7F0D; margin-right: 10px;"></i>
                    <span>키워드 데이터를 분석중입니다. 잠시만 기다려주세요...</span>
                </div>
                <div style="background-color: #e9ecef; height: 10px; border-radius: 5px; overflow: hidden;">
                    <div class="progress-bar"></div>
                </div>
            </div>
            """)
        
        # 메인키워드 분석 결과 섹션
        with gr.Column(elem_classes="custom-frame fade-in") as main_keyword_section:
            gr.HTML('<div class="section-title"><i class="fas fa-table"></i> 메인키워드 분석 결과</div>')
            
            empty_table_html = gr.HTML("""
            <table class="empty-table">
                <thead>
                    <tr>
                        <th>순번</th>
                        <th>조합 키워드</th>
                        <th>PC검색량</th>
                        <th>모바일검색량</th>
                        <th>총검색량</th>
                        <th>검색량구간</th>
                        <th>키워드 사용자순위</th>
                        <th>키워드 사용횟수</th>
                        <th>상품 등록 카테고리</th>
                    </tr>
                </thead>
                <tbody>
                    <tr>
                        <td colspan="9" style="padding: 30px; text-align: center;">
                            검색을 실행하면 여기에 결과가 표시됩니다
                        </td>
                    </tr>
                </tbody>
            </table>
            """)
            
            with gr.Column(visible=False) as keyword_analysis_section:
                with gr.Row():
                    with gr.Column(scale=1):
                        category_filter = gr.Dropdown(
                            choices=["전체 보기"], 
                            label="카테고리 필터", 
                            value="전체 보기", 
                            interactive=True
                        )
                    with gr.Column(scale=1):
                        total_volume_sort = gr.Dropdown(
                            choices=["정렬 없음", "오름차순", "내림차순"],
                            label="총검색량 정렬",
                            value="정렬 없음",
                            interactive=True
                        )
                
                with gr.Row():
                    with gr.Column(scale=1):
                        search_volume_filter = gr.Dropdown(
                            choices=["전체"], 
                            label="검색량 구간 필터", 
                            value="전체",
                            interactive=True
                        )
                    with gr.Column(scale=1):
                        usage_count_sort = gr.Dropdown(
                            choices=["정렬 없음", "오름차순", "내림차순"],
                            label="키워드 사용횟수 정렬",
                            value="정렬 없음",
                            interactive=True
                        )
                
                gr.HTML("<div class='data-container' id='table_container'></div>")
                table_output = gr.HTML(elem_classes="fade-in")
        
        # 카테고리 분석 섹션
        with gr.Column(elem_classes="custom-frame fade-in", visible=False) as category_analysis_section:
            gr.HTML('<div class="section-title"><i class="fas fa-chart-bar"></i> 키워드 분석</div>')
            
            with gr.Row():
                with gr.Column(scale=1):
                    analysis_keywords = gr.Textbox(
                        label="키워드 입력 (최대 20개, 쉼표 또는 엔터로 구분)", 
                        placeholder="예: 오징어볶음, 오징어 손질, 오징어 요리...",
                        lines=5
                    )
                    
                with gr.Column(scale=1):
                    selected_category = gr.Dropdown(
                        label="분석할 카테고리(분석 전 반드시 선택해주세요)", 
                        choices=["전체 보기"],
                        value="전체 보기",
                        interactive=True
                    )
        
        # 실행 섹션
        with gr.Column(elem_classes="execution-section", visible=False) as execution_section:
            gr.HTML('<div class="section-title"><i class="fas fa-play-circle"></i> 실행</div>')
            with gr.Row():
                with gr.Column(scale=1):
                    analyze_btn = gr.Button(
                        "카테고리 일치 분석", 
                        elem_classes=["execution-button", "primary-button"]
                    )
                with gr.Column(scale=1):
                    reset_btn = gr.Button(
                        "모든 입력 초기화", 
                        elem_classes=["execution-button", "secondary-button"]
                    )
        
        # 분석 결과 출력 섹션
        with gr.Column(elem_classes="custom-frame fade-in", visible=False) as analysis_output_section:
            gr.HTML('<div class="section-title"><i class="fas fa-list-ul"></i> 분석 결과 요약</div>')
            
            analysis_result = gr.HTML(elem_classes="fade-in")
            
            with gr.Row():
                download_output = gr.File(
                    label="키워드 목록 다운로드", 
                    visible=True
                )
        
        # 상태 저장용 변수
        state_df = gr.State()
        
        # 이벤트 연결
        search_btn.click(
            fn=wrapper_search_with_loading,
            inputs=[keyword, korean_only, apply_main_keyword, exclude_zero_volume],
            outputs=[progress_section, empty_table_html]
        ).then(
            fn=wrapper_process_search_results,
            inputs=[keyword, korean_only, apply_main_keyword, exclude_zero_volume],
            outputs=[
                table_output, category_filter, search_volume_filter, 
                state_df, selected_category, download_output,
                keyword_analysis_section, category_analysis_section,
                progress_section, empty_table_html, execution_section,
                keyword_state
            ]
        )
        
        # 필터 및 정렬 변경 이벤트 연결
        category_filter.change(
            fn=filter_and_sort_table, 
            inputs=[
                category_filter, gr.Textbox(value="정렬 없음", visible=False), 
                total_volume_sort, usage_count_sort, 
                search_volume_filter, exclude_zero_volume
            ], 
            outputs=[table_output]
        )
        
        category_filter.change(
            fn=update_category_selection,
            inputs=[category_filter],
            outputs=[selected_category]
        )
        
        total_volume_sort.change(
            fn=filter_and_sort_table, 
            inputs=[
                category_filter, gr.Textbox(value="정렬 없음", visible=False), 
                total_volume_sort, usage_count_sort, 
                search_volume_filter, exclude_zero_volume
            ], 
            outputs=[table_output]
        )
        
        usage_count_sort.change(
            fn=filter_and_sort_table, 
            inputs=[
                category_filter, gr.Textbox(value="정렬 없음", visible=False), 
                total_volume_sort, usage_count_sort, 
                search_volume_filter, exclude_zero_volume
            ], 
            outputs=[table_output]
        )
        
        search_volume_filter.change(
            fn=filter_and_sort_table, 
            inputs=[
                category_filter, gr.Textbox(value="정렬 없음", visible=False), 
                total_volume_sort, usage_count_sort, 
                search_volume_filter, exclude_zero_volume
            ], 
            outputs=[table_output]
        )
        
        exclude_zero_volume.change(
            fn=filter_and_sort_table, 
            inputs=[
                category_filter, gr.Textbox(value="정렬 없음", visible=False), 
                total_volume_sort, usage_count_sort, 
                search_volume_filter, exclude_zero_volume
            ], 
            outputs=[table_output]
        )
        
        # 카테고리 분석 버튼 이벤트
        analyze_btn.click(
            fn=wrapper_analyze_with_loading,
            inputs=[analysis_keywords, selected_category, state_df],
            outputs=[progress_section]
        ).then(
            fn=wrapper_process_analyze_results,
            inputs=[analysis_keywords, selected_category, state_df],
            outputs=[analysis_result, download_output, analysis_output_section, progress_section]
        )
        
        # 리셋 버튼 이벤트 연결
        reset_btn.click(
            fn=reset_interface,
            inputs=[],
            outputs=[
                keyword, korean_only, exclude_zero_volume, apply_main_keyword, 
                table_output, category_filter, category_filter, 
                search_volume_filter, search_volume_filter, 
                total_volume_sort, usage_count_sort, 
                selected_category, selected_category, 
                analysis_keywords, analysis_result, download_output
            ]
        )
                
    return demo