app.py

 -*- coding: utf-8 -*-
"""
AI 상품 소싱 분석 시스템 v3.2 - 컨트롤 타워 (더미 데이터 제거 버전)
- 허깅페이스 그라디오 엔드포인트 활용
- 분석 결과 HTML 기반 완전한 파일 생성 시스템
- 데이터 흐름 개선 및 fallback 로직 강화
- 한국시간 처리 및 파일명 생성 로직 포함
- 더미 데이터 생성 로직 완전 제거
"""

import gradio as gr
import pandas as pd
import os
import logging
from datetime import datetime
import pytz
import time
import tempfile
import zipfile
import re
import json

# 로깅 설정
logging.basicConfig(level=logging.WARNING, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

# 외부 라이브러리 로그 비활성화
logging.getLogger('gradio').setLevel(logging.WARNING)
logging.getLogger('gradio_client').setLevel(logging.WARNING)
logging.getLogger('httpx').setLevel(logging.WARNING)
logging.getLogger('urllib3').setLevel(logging.WARNING)

# ===== API 클라이언트 설정 =====
def get_api_client():
    """환경변수에서 API 엔드포인트를 가져와 클라이언트 생성"""
    try:
        from gradio_client import Client
        
        # 환경변수에서 API 엔드포인트 가져오기
        api_endpoint = os.getenv('API_ENDPOINT')
        
        if not api_endpoint:
            logger.error("API_ENDPOINT 환경변수가 설정되지 않았습니다.")
            raise ValueError("API_ENDPOINT 환경변수가 설정되지 않았습니다.")
        
        client = Client(api_endpoint)
        logger.info("원격 API 클라이언트 초기화 성공")
        return client
        
    except Exception as e:
        logger.error(f"API 클라이언트 초기화 실패: {e}")
        return None

# ===== 한국시간 관련 함수 =====
def get_korean_time():
    """한국시간 반환"""
    korea_tz = pytz.timezone('Asia/Seoul')
    return datetime.now(korea_tz)

def format_korean_datetime(dt=None, format_type="filename"):
    """한국시간 포맷팅"""
    if dt is None:
        dt = get_korean_time()
    
    if format_type == "filename":
        return dt.strftime("%y%m%d_%H%M")
    elif format_type == "display":
        return dt.strftime('%Y년 %m월 %d일 %H시 %M분')
    elif format_type == "full":
        return dt.strftime('%Y-%m-%d %H:%M:%S')
    else:
        return dt.strftime("%y%m%d_%H%M")

# ===== 데이터 처리 및 검증 함수들 =====
def create_export_data_from_html(analysis_keyword, main_keyword, analysis_html, step1_data=None):
    """분석 HTML과 1단계 데이터를 기반으로 export용 데이터 구조 생성 (더미 데이터 제거)"""
    logger.info("=== 📊 Export 데이터 구조 생성 시작 (더미 데이터 제거 버전) ===")
    
    # 기본 export 데이터 구조
    export_data = {
        "main_keyword": main_keyword or analysis_keyword,
        "analysis_keyword": analysis_keyword,
        "analysis_html": analysis_html,
        "main_keywords_df": None,
        "related_keywords_df": None,
        "analysis_completed": True,
        "created_at": get_korean_time().isoformat()
    }
    
    # 1단계 데이터에서 main_keywords_df 추출 (실제 데이터만)
    if step1_data and isinstance(step1_data, dict):
        if "keywords_df" in step1_data:
            keywords_df = step1_data["keywords_df"]
            if isinstance(keywords_df, dict):
                try:
                    export_data["main_keywords_df"] = pd.DataFrame(keywords_df)
                    logger.info(f"✅ 1단계 키워드 데이터를 DataFrame으로 변환: {export_data['main_keywords_df'].shape}")
                except Exception as e:
                    logger.warning(f"⚠️ 1단계 데이터 변환 실패: {e}")
                    export_data["main_keywords_df"] = None
            elif hasattr(keywords_df, 'shape'):
                export_data["main_keywords_df"] = keywords_df
                logger.info(f"✅ 1단계 키워드 DataFrame 사용: {keywords_df.shape}")
            else:
                logger.info("📋 1단계 키워드 데이터가 유효하지 않음 - None으로 유지")
                export_data["main_keywords_df"] = None
    
    # 분석 HTML에서 연관검색어 정보 추출 시도 (실제 데이터만)
    if analysis_html and "연관검색어 분석" in analysis_html:
        logger.info("🔍 분석 HTML에서 연관검색어 정보 발견 - 실제 파싱 필요")
        # 실제 HTML 파싱 로직이 필요한 부분
        # 현재는 더미 데이터 대신 None으로 유지
        export_data["related_keywords_df"] = None
        logger.info("💡 실제 HTML 파싱 로직 구현 필요 - 연관검색어 데이터는 None으로 유지")
    
    logger.info(f"📊 Export 데이터 구조 생성 완료 (더미 데이터 없음):")
    logger.info(f"   - analysis_keyword: {export_data['analysis_keyword']}")
    logger.info(f"   - main_keywords_df: {export_data['main_keywords_df'].shape if export_data['main_keywords_df'] is not None else 'None'}")
    logger.info(f"   - related_keywords_df: {export_data['related_keywords_df'].shape if export_data['related_keywords_df'] is not None else 'None'}")
    logger.info(f"   - analysis_html: {len(str(export_data['analysis_html']))} 문자")
    
    return export_data

def validate_and_repair_export_data(export_data):
    """Export 데이터 유효성 검사 및 복구 (더미 데이터 제거)"""
    logger.info("🔧 Export 데이터 유효성 검사 및 복구 시작 (더미 데이터 제거 버전)")
    
    if not export_data or not isinstance(export_data, dict):
        logger.warning("⚠️ Export 데이터가 없거나 딕셔너리가 아님 - 기본 구조 생성")
        return {
            "main_keyword": "기본키워드",
            "analysis_keyword": "기본분석키워드",
            "analysis_html": "<div>기본 분석 결과</div>",
            "main_keywords_df": None,  # 더미 데이터 대신 None
            "related_keywords_df": None,  # 더미 데이터 대신 None
            "analysis_completed": True
        }
    
    # 필수 키들 확인 및 복구
    required_keys = {
        "analysis_keyword": "분석키워드",
        "main_keyword": "메인키워드", 
        "analysis_html": "<div>분석 완료</div>",
        "analysis_completed": True
    }
    
    for key, default_value in required_keys.items():
        if key not in export_data or not export_data[key]:
            export_data[key] = default_value
            logger.info(f"🔧 {key} 키 복구: {default_value}")
    
    # DataFrame 데이터 검증 및 변환 (더미 데이터 생성 안함)
    for df_key in ["main_keywords_df", "related_keywords_df"]:
        if df_key in export_data and export_data[df_key] is not None:
            df_data = export_data[df_key]
            
            # 딕셔너리를 DataFrame으로 변환
            if isinstance(df_data, dict):
                try:
                    # 빈 딕셔너리는 None으로 처리
                    if not df_data:
                        export_data[df_key] = None
                        logger.info(f"📋 {df_key} 빈 딕셔너리 - None으로 설정")
                    else:
                        export_data[df_key] = pd.DataFrame(df_data)
                        logger.info(f"✅ {df_key} 딕셔너리를 DataFrame으로 변환 성공")
                except Exception as e:
                    logger.warning(f"⚠️ {df_key} 변환 실패: {e}")
                    export_data[df_key] = None
            elif not hasattr(df_data, 'shape'):
                logger.warning(f"⚠️ {df_key}가 DataFrame이 아님 - None으로 설정")
                export_data[df_key] = None
    
    logger.info("✅ Export 데이터 유효성 검사 및 복구 완료 (더미 데이터 없음)")
    return export_data

# ===== 파일 출력 함수들 =====
def create_timestamp_filename(analysis_keyword):
    """타임스탬프가 포함된 파일명 생성 - 한국시간 적용"""
    timestamp = format_korean_datetime(format_type="filename")
    safe_keyword = re.sub(r'[^\w\s-]', '', analysis_keyword).strip()
    safe_keyword = re.sub(r'[-\s]+', '_', safe_keyword)
    return f"{safe_keyword}_{timestamp}_분석결과"

def export_to_excel(main_keyword, main_keywords_df, analysis_keyword, related_keywords_df, filename_base):
    """엑셀 파일로 출력 (실제 데이터만)"""
    try:
        # 실제 데이터가 있는지 확인
        has_main_data = main_keywords_df is not None and not main_keywords_df.empty
        has_related_data = related_keywords_df is not None and not related_keywords_df.empty
        
        if not has_main_data and not has_related_data:
            logger.info("📋 생성할 데이터가 없어 엑셀 파일 생성 건너뜀")
            return None
        
        excel_filename = f"{filename_base}.xlsx"
        excel_path = os.path.join(tempfile.gettempdir(), excel_filename)
        
        with pd.ExcelWriter(excel_path, engine='xlsxwriter') as writer:
            # 워크북과 워크시트 스타일 설정
            workbook = writer.book
            
            # 헤더 스타일
            header_format = workbook.add_format({
                'bold': True,
                'text_wrap': True,
                'valign': 'top',
                'fg_color': '#D7E4BC',
                'border': 1
            })
            
            # 데이터 스타일
            data_format = workbook.add_format({
                'text_wrap': True,
                'valign': 'top',
                'border': 1
            })
            
            # 숫자 포맷
            number_format = workbook.add_format({
                'num_format': '#,##0',
                'text_wrap': True,
                'valign': 'top',
                'border': 1
            })
            
            # 첫 번째 시트: 메인키워드 조합키워드 (실제 데이터만)
            if has_main_data:
                main_keywords_df.to_excel(writer, sheet_name=f'{main_keyword}_조합키워드', index=False)
                worksheet1 = writer.sheets[f'{main_keyword}_조합키워드']
                
                # 헤더 스타일 적용
                for col_num, value in enumerate(main_keywords_df.columns.values):
                    worksheet1.write(0, col_num, value, header_format)
                
                # 데이터 스타일 적용
                for row_num in range(1, len(main_keywords_df) + 1):
                    for col_num, value in enumerate(main_keywords_df.iloc[row_num-1]):
                        if isinstance(value, (int, float)) and col_num in [1, 2, 3]:  # 검색량 컬럼
                            worksheet1.write(row_num, col_num, value, number_format)
                        else:
                            worksheet1.write(row_num, col_num, value, data_format)
                
                # 열 너비 자동 조정
                for i, col in enumerate(main_keywords_df.columns):
                    max_len = max(
                        main_keywords_df[col].astype(str).map(len).max(),
                        len(str(col))
                    )
                    worksheet1.set_column(i, i, min(max_len + 2, 50))
                
                logger.info(f"✅ 메인키워드 시트 생성: {main_keywords_df.shape}")
            
            # 두 번째 시트: 분석키워드 연관검색어 (실제 데이터만)
            if has_related_data:
                related_keywords_df.to_excel(writer, sheet_name=f'{analysis_keyword}_연관검색어', index=False)
                worksheet2 = writer.sheets[f'{analysis_keyword}_연관검색어']
                
                # 헤더 스타일 적용
                for col_num, value in enumerate(related_keywords_df.columns.values):
                    worksheet2.write(0, col_num, value, header_format)
                
                # 데이터 스타일 적용
                for row_num in range(1, len(related_keywords_df) + 1):
                    for col_num, value in enumerate(related_keywords_df.iloc[row_num-1]):
                        if isinstance(value, (int, float)) and col_num in [1, 2, 3]:  # 검색량 컬럼
                            worksheet2.write(row_num, col_num, value, number_format)
                        else:
                            worksheet2.write(row_num, col_num, value, data_format)
                
                # 열 너비 자동 조정
                for i, col in enumerate(related_keywords_df.columns):
                    max_len = max(
                        related_keywords_df[col].astype(str).map(len).max(),
                        len(str(col))
                    )
                    worksheet2.set_column(i, i, min(max_len + 2, 50))
                
                logger.info(f"✅ 연관검색어 시트 생성: {related_keywords_df.shape}")
        
        logger.info(f"엑셀 파일 생성 완료: {excel_path}")
        return excel_path
        
    except Exception as e:
        logger.error(f"엑셀 파일 생성 오류: {e}")
        return None

def export_to_html(analysis_html, filename_base):
    """HTML 파일로 출력 - 한국시간 적용"""
    try:
        html_filename = f"{filename_base}.html"
        html_path = os.path.join(tempfile.gettempdir(), html_filename)
        
        # 한국시간으로 생성 시간 표시
        korean_time = format_korean_datetime(format_type="display")
        
        # 완전한 HTML 문서 생성
        full_html = f"""
<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>키워드 심충분석 결과</title>
    <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">
    <style>
        body {{
            font-family: 'Pretendard', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
            margin: 0;
            padding: 20px;
            background-color: #f5f5f5;
            line-height: 1.6;
        }}
        .container {{
            max-width: 1200px;
            margin: 0 auto;
            background: white;
            border-radius: 12px;
            box-shadow: 0 4px 12px rgba(0,0,0,0.1);
            overflow: hidden;
        }}
        .header {{
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            color: white;
            padding: 30px;
            text-align: center;
        }}
        .header h1 {{
            margin: 0;
            font-size: 28px;
            font-weight: 700;
        }}
        .header p {{
            margin: 10px 0 0 0;
            font-size: 16px;
            opacity: 0.9;
        }}
        .content {{
            padding: 30px;
        }}
        .timestamp {{
            text-align: center;
            padding: 20px;
            background: #f8f9fa;
            color: #6c757d;
            font-size: 14px;
            border-top: 1px solid #dee2e6;
        }}
        
        /* 차트 스타일 개선 */
        .chart-container {{
            margin: 20px 0;
            padding: 20px;
            background: white;
            border-radius: 8px;
            box-shadow: 0 2px 8px rgba(0,0,0,0.1);
        }}
        
        /* 반응형 스타일 */
        @media (max-width: 768px) {{
            .container {{
                margin: 10px;
                border-radius: 8px;
            }}
            .header {{
                padding: 20px;
            }}
            .header h1 {{
                font-size: 24px;
            }}
            .content {{
                padding: 20px;
            }}
        }}
        
        /* 애니메이션 */
        @keyframes spin {{
            0% {{ transform: rotate(0deg); }}
            100% {{ transform: rotate(360deg); }}
        }}
        
        @keyframes progress {{
            0% {{ transform: translateX(-100%); }}
            100% {{ transform: translateX(100%); }}
        }}
        
        /* 프린트 스타일 */
        @media print {{
            body {{
                background: white;
                padding: 0;
            }}
            .container {{
                box-shadow: none;
                border-radius: 0;
            }}
            .header {{
                background: #667eea !important;
                -webkit-print-color-adjust: exact;
            }}
        }}
    </style>
</head>
<body>
    <div class="container">
        <div class="header">
            <h1><i class="fas fa-chart-line"></i> 키워드 심충분석 결과</h1>
            <p>AI 상품 소싱 분석 시스템 v3.2 (더미 데이터 제거 버전)</p>
        </div>
        <div class="content">
            {analysis_html}
        </div>
        <div class="timestamp">
            <i class="fas fa-clock"></i> 생성 시간: {korean_time} (한국시간)
        </div>
    </div>
</body>
</html>
        """
        
        with open(html_path, 'w', encoding='utf-8') as f:
            f.write(full_html)
        
        logger.info(f"HTML 파일 생성 완료: {html_path}")
        return html_path
        
    except Exception as e:
        logger.error(f"HTML 파일 생성 오류: {e}")
        return None

def create_zip_file(excel_path, html_path, filename_base):
    """압축 파일 생성"""
    try:
        zip_filename = f"{filename_base}.zip"
        zip_path = os.path.join(tempfile.gettempdir(), zip_filename)
        
        files_added = 0
        with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
            if excel_path and os.path.exists(excel_path):
                zipf.write(excel_path, f"{filename_base}.xlsx")
                logger.info(f"엑셀 파일 압축 추가: {filename_base}.xlsx")
                files_added += 1
            
            if html_path and os.path.exists(html_path):
                zipf.write(html_path, f"{filename_base}.html")
                logger.info(f"HTML 파일 압축 추가: {filename_base}.html")
                files_added += 1
        
        if files_added == 0:
            logger.warning("압축할 파일이 없음")
            return None
        
        logger.info(f"압축 파일 생성 완료: {zip_path} ({files_added}개 파일)")
        return zip_path
        
    except Exception as e:
        logger.error(f"압축 파일 생성 오류: {e}")
        return None

def export_analysis_results_enhanced(export_data):
    """강화된 분석 결과 출력 메인 함수 (더미 데이터 제거)"""
    try:
        logger.info("=== 📊 강화된 출력 함수 시작 (더미 데이터 제거 버전) ===")
        
        # 데이터 유효성 검사 및 복구
        export_data = validate_and_repair_export_data(export_data)
        
        analysis_keyword = export_data.get("analysis_keyword", "기본키워드")
        analysis_html = export_data.get("analysis_html", "<div>분석 완료</div>")
        main_keyword = export_data.get("main_keyword", analysis_keyword)
        main_keywords_df = export_data.get("main_keywords_df")
        related_keywords_df = export_data.get("related_keywords_df")
        
        logger.info(f"🔍 처리할 데이터:")
        logger.info(f"   - analysis_keyword: '{analysis_keyword}'")
        logger.info(f"   - main_keyword: '{main_keyword}'")
        logger.info(f"   - analysis_html: {len(str(analysis_html))} 문자")
        logger.info(f"   - main_keywords_df: {main_keywords_df.shape if main_keywords_df is not None else 'None'}")
        logger.info(f"   - related_keywords_df: {related_keywords_df.shape if related_keywords_df is not None else 'None'}")
        
        # 파일명 생성 (한국시간 적용)
        filename_base = create_timestamp_filename(analysis_keyword)
        logger.info(f"📁 출력 파일명: {filename_base}")
        
        # HTML 파일은 분석 결과가 있으면 생성
        html_path = None
        if analysis_html and len(str(analysis_html).strip()) > 20:  # 의미있는 HTML인지 확인
            logger.info("🌐 HTML 파일 생성 시작...")
            html_path = export_to_html(analysis_html, filename_base)
            if html_path:
                logger.info(f"✅ HTML 파일 생성 성공: {html_path}")
            else:
                logger.error("❌ HTML 파일 생성 실패")
        else:
            logger.info("📄 분석 HTML이 없어 HTML 파일 생성 건너뜀")
        
        # 엑셀 파일 생성 (실제 DataFrame이 있는 경우만)
        excel_path = None
        if (main_keywords_df is not None and not main_keywords_df.empty) or \
           (related_keywords_df is not None and not related_keywords_df.empty):
            logger.info("📊 엑셀 파일 생성 시작...")
            excel_path = export_to_excel(
                main_keyword,
                main_keywords_df,
                analysis_keyword,
                related_keywords_df,
                filename_base
            )
            if excel_path:
                logger.info(f"✅ 엑셀 파일 생성 성공: {excel_path}")
            else:
                logger.warning("⚠️ 엑셀 파일 생성 실패")
        else:
            logger.info("📊 실제 DataFrame 데이터가 없어 엑셀 파일 생성 생략")
        
        # 생성된 파일이 있는지 확인
        if not html_path and not excel_path:
            logger.warning("⚠️ 생성된 파일이 없음")
            return None, "⚠️ 생성할 수 있는 데이터가 없습니다. 분석을 먼저 완료해주세요."
        
        # 압축 파일 생성
        logger.info("📦 압축 파일 생성 시작...")
        zip_path = create_zip_file(excel_path, html_path, filename_base)
        if zip_path:
            file_types = []
            if html_path:
                file_types.append("HTML")
            if excel_path:
                file_types.append("엑셀")
            
            file_list = " + ".join(file_types)
            logger.info(f"✅ 압축 파일 생성 성공: {zip_path} ({file_list})")
            return zip_path, f"✅ 분석 결과가 성공적으로 출력되었습니다!\n파일명: {filename_base}.zip\n포함 파일: {file_list}\n\n💡 더미 데이터 제거 버전 - 실제 분석 데이터만 포함됩니다."
        else:
            logger.error("❌ 압축 파일 생성 실패")
            return None, "압축 파일 생성에 실패했습니다."
    
    except Exception as e:
        logger.error(f"❌ 강화된 출력 함수 전체 오류: {e}")
        import traceback
        logger.error(f"스택 트레이스:\n{traceback.format_exc()}")
        return None, f"출력 중 오류가 발생했습니다: {str(e)}"

# ===== 로딩 애니메이션 =====
def create_loading_animation():
    """로딩 애니메이션 HTML"""
    return """
    <div style="display: flex; flex-direction: column; align-items: center; padding: 40px; background: white; border-radius: 12px; box-shadow: 0 4px 12px rgba(0,0,0,0.1);">
        <div style="width: 60px; height: 60px; border: 4px solid #f3f3f3; border-top: 4px solid #FB7F0D; border-radius: 50%; animation: spin 1s linear infinite; margin-bottom: 20px;"></div>
        <h3 style="color: #FB7F0D; margin: 10px 0; font-size: 18px;">분석 중입니다...</h3>
        <p style="color: #666; margin: 5px 0; text-align: center;">원격 서버에서 데이터를 수집하고 AI가 분석하고 있습니다.<br>잠시만 기다려주세요.</p>
        <div style="width: 200px; height: 4px; background: #f0f0f0; border-radius: 2px; margin-top: 15px; overflow: hidden;">
            <div style="width: 100%; height: 100%; background: linear-gradient(90deg, #FB7F0D, #ff9a8b); border-radius: 2px; animation: progress 2s ease-in-out infinite;"></div>
        </div>
    </div>
    
    <style>
    @keyframes spin {
        0% { transform: rotate(0deg); }
        100% { transform: rotate(360deg); }
    }
    
    @keyframes progress {
        0% { transform: translateX(-100%); }
        100% { transform: translateX(100%); }
    }
    </style>
    """

# ===== 에러 처리 함수 =====
def generate_error_response(error_message):
    """에러 응답 생성"""
    return f'''
    <div style="color: red; padding: 30px; text-align: center; width: 100%; 
                background-color: #f8d7da; border-radius: 12px; border: 1px solid #f5c6cb;">
        <h3 style="margin-bottom: 15px;">❌ 연결 오류</h3>
        <p style="margin-bottom: 20px;">{error_message}</p>
        <div style="background: white; padding: 15px; border-radius: 8px; color: #333;">
            <h4>해결 방법:</h4>
            <ul style="text-align: left; padding-left: 20px;">
                <li>네트워크 연결을 확인해주세요</li>
                <li>원격 서버 상태를 확인해주세요</li>
                <li>잠시 후 다시 시도해주세요</li>
                <li>문제가 지속되면 관리자에게 문의하세요</li>
            </ul>
        </div>
    </div>
    '''

# ===== 원격 API 호출 함수들 =====
def call_collect_data_api(keyword):
    """1단계: 상품 데이터 수집 API 호출"""
    try:
        client = get_api_client()
        if not client:
            return generate_error_response("API 클라이언트를 초기화할 수 없습니다."), {}
        
        logger.info("원격 API 호출: 상품 데이터 수집")
        result = client.predict(
            keyword=keyword,
            api_name="/on_collect_data"
        )
        
        logger.info(f"데이터 수집 API 결과 타입: {type(result)}")
        
        # 결과가 튜플인 경우 첫 번째 요소는 HTML, 두 번째는 세션 데이터
        if isinstance(result, tuple) and len(result) == 2:
            html_result, session_data = result
            
            # 세션 데이터가 제대로 있는지 확인
            if isinstance(session_data, dict):
                logger.info(f"데이터 수집 세션 데이터 수신: {list(session_data.keys()) if session_data else '빈 딕셔너리'}")
                return html_result, session_data
            else:
                logger.warning("세션 데이터가 딕셔너리가 아닙니다.")
                return html_result, {}
        else:
            logger.warning("예상과 다른 데이터 수집 결과 형태")
            return str(result), {"keywords_collected": True}
            
    except Exception as e:
        logger.error(f"상품 데이터 수집 API 호출 오류: {e}")
        return generate_error_response(f"원격 서버 연결 실패: {str(e)}"), {}

def call_analyze_keyword_api_enhanced(analysis_keyword, base_keyword, keywords_data):
    """3단계: 강화된 키워드 심충분석 API 호출 (더미 데이터 제거)"""
    try:
        client = get_api_client()
        if not client:
            return generate_error_response("API 클라이언트를 초기화할 수 없습니다."), {}
        
        logger.info("=== 🚀 강화된 키워드 심충분석 API 호출 (더미 데이터 제거) ===")
        logger.info(f"파라미터 - analysis_keyword: '{analysis_keyword}'")
        logger.info(f"파라미터 - base_keyword: '{base_keyword}'")
        logger.info(f"파라미터 - keywords_data 타입: {type(keywords_data)}")
        
        # 원격 API 호출
        result = client.predict(
            analysis_keyword,
            base_keyword, 
            keywords_data,
            api_name="/on_analyze_keyword"
        )
        
        logger.info(f"📡 원격 API 응답 수신:")
        logger.info(f"   - 응답 타입: {type(result)}")
        logger.info(f"   - 응답 길이: {len(result) if hasattr(result, '__len__') else 'N/A'}")
        
        # 응답 처리 및 Export 데이터 구조 생성
        if isinstance(result, tuple) and len(result) == 2:
            html_result, remote_export_data = result
            
            logger.info(f"📊 원격 export 데이터:")
            logger.info(f"   - 타입: {type(remote_export_data)}")
            logger.info(f"   - 키들: {list(remote_export_data.keys()) if isinstance(remote_export_data, dict) else 'None'}")
            
            # HTML 결과가 있으면 Export 데이터 구조 생성 (더미 데이터 없이)
            if html_result:
                logger.info("🔧 Export 데이터 구조 생성 시작 (더미 데이터 제거)")
                enhanced_export_data = create_export_data_from_html(
                    analysis_keyword=analysis_keyword,
                    main_keyword=base_keyword,
                    analysis_html=html_result,
                    step1_data=keywords_data
                )
                
                # 원격에서 온 실제 데이터가 있으면 병합
                if isinstance(remote_export_data, dict) and remote_export_data:
                    logger.info("🔗 원격 실제 데이터와 로컬 데이터 병합")
                    for key, value in remote_export_data.items():
                        if value is not None and key in ["main_keywords_df", "related_keywords_df"]:
                            # DataFrame 데이터만 검증하여 병합
                            if isinstance(value, dict) and value:  # 빈 딕셔너리가 아닌 경우만
                                enhanced_export_data[key] = value
                                logger.info(f"   - {key} 원격 실제 데이터로 업데이트")
                            elif hasattr(value, 'shape') and not value.empty:  # DataFrame이고 비어있지 않은 경우
                                enhanced_export_data[key] = value
                                logger.info(f"   - {key} 원격 DataFrame 데이터로 업데이트")
                        elif value is not None and key not in ["main_keywords_df", "related_keywords_df"]:
                            enhanced_export_data[key] = value
                            logger.info(f"   - {key} 원격 데이터로 업데이트")
                
                logger.info(f"✅ 최종 Export 데이터 구조 (더미 데이터 없음):")
                logger.info(f"   - 키 개수: {len(enhanced_export_data)}")
                logger.info(f"   - 키 목록: {list(enhanced_export_data.keys())}")
                
                return html_result, enhanced_export_data
            else:
                logger.warning("⚠️ HTML 결과가 비어있음")
                return str(result), {}
        else:
            logger.warning("⚠️ 예상과 다른 API 응답 형태")
            # HTML만 반환된 경우도 처리
            if isinstance(result, str) and len(result) > 100:  # HTML일 가능성이 높음
                logger.info("📄 HTML 문자열로 추정되는 응답 - Export 데이터 생성 (더미 데이터 없이)")
                enhanced_export_data = create_export_data_from_html(
                    analysis_keyword=analysis_keyword,
                    main_keyword=base_keyword,
                    analysis_html=result,
                    step1_data=keywords_data
                )
                return result, enhanced_export_data
            else:
                return str(result), {}
            
    except Exception as e:
        logger.error(f"❌ 키워드 심충분석 API 호출 오류: {e}")
        import traceback
        logger.error(f"스택 트레이스:\n{traceback.format_exc()}")
        return generate_error_response(f"원격 서버 연결 실패: {str(e)}"), {}

# ===== 그라디오 인터페이스 =====
def create_interface():
    # CSS 스타일링 (기존과 동일)
    custom_css = """
    /* 기존 다크모드 자동 변경 AI 상품 소싱 분석 시스템 CSS */
    :root {
        --primary-color: #FB7F0D;
        --secondary-color: #ff9a8b;
        --accent-color: #FF6B6B;
        --background-color: #FFFFFF;
        --card-bg: #ffffff;
        --input-bg: #ffffff;
        --text-color: #334155;
        --text-secondary: #64748b;
        --border-color: #dddddd;
        --border-light: #e5e5e5;
        --table-even-bg: #f3f3f3;
        --table-hover-bg: #f0f0f0;
        --shadow: 0 8px 30px rgba(251, 127, 13, 0.08);
        --shadow-light: 0 2px 4px rgba(0, 0, 0, 0.1);
        --border-radius: 18px;
    }
    @media (prefers-color-scheme: dark) {
        :root {
            --background-color: #1a1a1a;
            --card-bg: #2d2d2d;
            --input-bg: #2d2d2d;
            --text-color: #e5e5e5;
            --text-secondary: #a1a1aa;
            --border-color: #404040;
            --border-light: #525252;
            --table-even-bg: #333333;
            --table-hover-bg: #404040;
            --shadow: 0 8px 30px rgba(0, 0, 0, 0.3);
            --shadow-light: 0 2px 4px rgba(0, 0, 0, 0.2);
        }
    }
    body {
        font-family: 'Pretendard', 'Noto Sans KR', -apple-system, BlinkMacSystemFont, sans-serif;
        background-color: var(--background-color) !important;
        color: var(--text-color) !important;
        line-height: 1.6;
        margin: 0;
        padding: 0;
        transition: background-color 0.3s ease, color 0.3s ease;
    }
    .gradio-container {
        width: 100%;
        margin: 0 auto;
        padding: 20px;
        background-color: var(--background-color) !important;
    }
    .custom-frame {
        background-color: var(--card-bg) !important;
        border: 1px solid var(--border-light) !important;
        border-radius: var(--border-radius);
        padding: 20px;
        margin: 10px 0;
        box-shadow: var(--shadow) !important;
        color: var(--text-color) !important;
    }
    .custom-button {
        border-radius: 30px !important;
        background: var(--primary-color) !important;
        color: white !important;
        font-size: 18px !important;
        padding: 10px 20px !important;
        border: none;
        box-shadow: 0 4px 8px rgba(251, 127, 13, 0.25);
        transition: transform 0.3s ease;
        height: 45px !important;
        width: 100% !important;
    }
    .custom-button:hover {
        transform: translateY(-2px);
        box-shadow: 0 6px 12px rgba(251, 127, 13, 0.3);
    }
    .export-button {
        background: linear-gradient(135deg, #28a745, #20c997) !important;
        color: white !important; 
        border-radius: 25px !important; 
        height: 50px !important;
        font-size: 17px !important; 
        font-weight: bold !important; 
        width: 100% !important;
        margin-top: 20px !important;
    }
    .section-title {
        display: flex;
        align-items: center;
        font-size: 20px;
        font-weight: 700;
        color: var(--text-color) !important;
        margin-bottom: 10px;
        padding-bottom: 5px;
        border-bottom: 2px solid var(--primary-color);
        font-family: 'Pretendard', 'Noto Sans KR', -apple-system, BlinkMacSystemFont, sans-serif;
    }
    .section-title img, .section-title i {
        margin-right: 10px;
        font-size: 20px;
        color: var(--primary-color);
    }
    .gr-input, .gr-text-input, .gr-sample-inputs,
    input[type="text"], input[type="number"], textarea, select {
        border-radius: var(--border-radius) !important;
        border: 1px solid var(--border-color) !important;
        padding: 12px !important;
        box-shadow: inset 0 1px 3px rgba(0, 0, 0, 0.05) !important;
        transition: all 0.3s ease !important;
        background-color: var(--input-bg) !important;
        color: var(--text-color) !important;
    }
    .gr-input:focus, .gr-text-input:focus,
    input[type="text"]:focus, textarea:focus, select:focus {
        border-color: var(--primary-color) !important;
        outline: none !important;
        box-shadow: 0 0 0 2px rgba(251, 127, 13, 0.2) !important;
    }
    .fade-in {
        animation: fadeIn 0.5s ease-out;
    }
    @keyframes fadeIn {
        from { opacity: 0; transform: translateY(10px); }
        to { opacity: 1; transform: translateY(0); }
    }
    """
    
    with gr.Blocks(
        css=custom_css, 
        title="🛒 AI 상품 소싱 분석기 v3.2 (더미 데이터 제거)",
        theme=gr.themes.Default(primary_hue="orange", secondary_hue="orange")
    ) as interface:
        
        # 폰트 및 아이콘 로드
        gr.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">
        """)
        
        # 세션별 상태 변수
        keywords_data_state = gr.State()
        export_data_state = gr.State({})
        
        # === UI 컴포넌트들 ===
        with gr.Column(elem_classes="custom-frame fade-in"):
            gr.HTML('<div class="section-title"><i class="fas fa-search"></i> 1단계: 메인 키워드 입력</div>')
            
            keyword_input = gr.Textbox(
                label="상품 메인키워드", 
                placeholder="예: 슬리퍼, 무선이어폰, 핸드크림",
                value="",
                elem_id="keyword_input"
            )
            
            collect_data_btn = gr.Button("1단계: 상품 데이터 수집하기", elem_classes="custom-button", size="lg")
        
        with gr.Column(elem_classes="custom-frame fade-in"):
            gr.HTML('<div class="section-title"><i class="fas fa-database"></i> 2단계: 수집된 키워드 목록</div>')
            keywords_result = gr.HTML()
        
        with gr.Column(elem_classes="custom-frame fade-in"):
            gr.HTML('<div class="section-title"><i class="fas fa-bullseye"></i> 3단계: 분석할 키워드 선택</div>')
            
            analysis_keyword_input = gr.Textbox(
                label="분석할 키워드", 
                placeholder="위 목록에서 원하는 키워드를 입력하세요 (예: 통굽 슬리퍼)",
                value="",
                elem_id="analysis_keyword_input"
            )
            
            analyze_keyword_btn = gr.Button("키워드 심충분석 하기", elem_classes="custom-button", size="lg")
        
        with gr.Column(elem_classes="custom-frame fade-in"):
            gr.HTML('<div class="section-title"><i class="fas fa-chart-line"></i> 키워드 심충분석</div>')
            analysis_result = gr.HTML(label="키워드 심충분석")
        
        with gr.Column(elem_classes="custom-frame fade-in"):
            gr.HTML('<div class="section-title"><i class="fas fa-download"></i> 분석 결과 출력</div>')
            
            gr.HTML("""
            <div style="background: #e3f2fd; border-left: 4px solid #2196f3; padding: 15px; margin: 10px 0; border-radius: 5px;">
                <h4 style="margin: 0 0 10px 0; color: #1976d2;"><i class="fas fa-info-circle"></i> 실제 데이터 출력 버전</h4>
                <p style="margin: 0; color: #1976d2; font-size: 14px;">
                    • 분석된 데이터를 파일로 출력됩니다<br>
                </p>
            </div>
            """)
        
            export_btn = gr.Button("📊 분석결과 출력하기", elem_classes="export-button", size="lg")
            export_result = gr.HTML()
            download_file = gr.File(label="다운로드", visible=False)
        
        # ===== 이벤트 핸들러 =====
        def on_collect_data(keyword):
            if not keyword.strip():
                return ("<div style='color: red; padding: 20px; text-align: center; width: 100%;'>키워드를 입력해주세요.</div>", None)
            
            # 로딩 상태 표시
            yield (create_loading_animation(), None)
            
            # 원격 API 호출
            result_html, result_data = call_collect_data_api(keyword)
            
            yield (result_html, result_data)
        
        def on_analyze_keyword(analysis_keyword, base_keyword, keywords_data):
            if not analysis_keyword.strip():
                return "<div style='color: red; padding: 20px; text-align: center; width: 100%;'>분석할 키워드를 입력해주세요.</div>", {}
            
            # 로딩 상태 표시
            yield create_loading_animation(), {}
            
            # 강화된 API 호출 (더미 데이터 제거)
            html_result, enhanced_export_data = call_analyze_keyword_api_enhanced(
                analysis_keyword, base_keyword, keywords_data
            )
            
            yield html_result, enhanced_export_data
                
        def on_export_results(export_data):
            """강화된 분석 결과 출력 핸들러 (더미 데이터 제거)"""
            try:
                logger.info(f"📊 입력 export_data: {type(export_data)}")
                if isinstance(export_data, dict):
                    logger.info(f"📋 export_data 키들: {list(export_data.keys())}")
                
                # 강화된 출력 함수 호출 (더미 데이터 제거)
                zip_path, message = export_analysis_results_enhanced(export_data)
                
                if zip_path:
                    success_html = f"""
                    <div style="background: #d4edda; border: 1px solid #c3e6cb; padding: 20px; border-radius: 8px; margin: 10px 0;">
                        <h4 style="color: #155724; margin: 0 0 15px 0;"><i class="fas fa-check-circle"></i> 출력 완료!</h4>
                        <p style="color: #155724; margin: 0; line-height: 1.6;">
                            {message}<br>
                            <strong>데이터출력:</strong><br>
                            <br>
                            <i class="fas fa-download"></i> 아래 다운로드 버튼을 클릭하여 파일을 저장하세요.<br>
                            <small style="color: #666;">⏰ 한국시간 기준으로 파일명이 생성됩니다.</small>
                        </p>
                    </div>
                    """
                    return success_html, gr.update(value=zip_path, visible=True)
                else:
                    error_html = f"""
                    <div style="background: #f8d7da; border: 1px solid #f5c6cb; padding: 20px; border-radius: 8px; margin: 10px 0;">
                        <h4 style="color: #721c24; margin: 0 0 10px 0;"><i class="fas fa-exclamation-triangle"></i> 출력 실패</h4>
                        <p style="color: #721c24; margin: 0;">{message}</p>
                        <div style="margin-top: 15px; padding: 15px; background: white; border-radius: 5px;">
                            <h5 style="color: #721c24; margin: 0 0 10px 0;">🔍 디버깅 정보:</h5>
                            <ul style="color: #721c24; margin: 0; padding-left: 20px;">
                                <li>Export 데이터 타입: {type(export_data)}</li>
                                <li>Export 데이터 유효성: {'유효' if export_data else '무효'}</li>
                                <li>키워드 심충분석 상태: {'완료' if export_data.get('analysis_completed') else '미완료'}</li>
                            </ul>
                        </div>
                    </div>
                    """
                    logger.error("❌ 강화된 출력 실패")
                    return error_html, gr.update(visible=False)
                    
            except Exception as e:
                logger.error(f"❌ 강화된 출력 핸들러 오류: {e}")
                import traceback
                logger.error(f"스택 트레이스:\n{traceback.format_exc()}")
                
                error_html = f"""
                <div style="background: #f8d7da; border: 1px solid #f5c6cb; padding: 20px; border-radius: 8px; margin: 10px 0;">
                    <h4 style="color: #721c24; margin: 0 0 10px 0;"><i class="fas fa-exclamation-triangle"></i> 시스템 오류</h4>
                    <p style="color: #721c24; margin: 0;">강화된 출력 중 시스템 오류가 발생했습니다:</p>
                    <code style="display: block; margin: 10px 0; padding: 10px; background: #f8f9fa; border-radius: 3px; color: #721c24;">
                        {type(e).__name__}: {str(e)}
                    </code>
                    <div style="margin-top: 15px; padding: 10px; background: #fff3cd; border-radius: 5px;">
                        <p style="margin: 0; color: #856404; font-size: 14px;">
                            💡 실제 분석 결과가 있어야만 파일이 생성됩니다.
                        </p>
                    </div>
                </div>
                """
                return error_html, gr.update(visible=False)
        
        # ===== 이벤트 연결 =====
        collect_data_btn.click(
            fn=on_collect_data,
            inputs=[keyword_input],
            outputs=[keywords_result, keywords_data_state],
            api_name="on_collect_data"
        )
        
        analyze_keyword_btn.click(
            fn=on_analyze_keyword,
            inputs=[analysis_keyword_input, keyword_input, keywords_data_state],  
            outputs=[analysis_result, export_data_state],
            api_name="on_analyze_keyword"
        )
        
        export_btn.click(
            fn=on_export_results,
            inputs=[export_data_state],
            outputs=[export_result, download_file],
            api_name="on_export_results"
        )
    
    return interface

# ===== 메인 실행 =====
if __name__ == "__main__":
    # pytz 모듈 설치 확인
    try:
        import pytz
        logger.info("✅ pytz 모듈 로드 성공 - 한국시간 지원")
    except ImportError:
        logger.info("시스템 시간을 사용합니다.")
    
    # 앱 실행
    app = create_interface()
    app.launch(server_name="0.0.0.0", server_port=7860, share=True)