app.py

import os, json, re, logging, requests, markdown, time, io
from datetime import datetime
import random
import base64
from io import BytesIO
from PIL import Image

import streamlit as st
from openai import OpenAI

from gradio_client import Client
import pandas as pd
import PyPDF2  # For handling PDF files
import kagglehub

# ──────────────────────────────── Environment Variables / Constants ─────────────────────────
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")  
BRAVE_KEY      = os.getenv("SERPHOUSE_API_KEY", "")  # Keep this name
BRAVE_ENDPOINT = "https://api.search.brave.com/res/v1/web/search"
BRAVE_VIDEO_ENDPOINT = "https://api.search.brave.com/res/v1/videos/search"
BRAVE_NEWS_ENDPOINT  = "https://api.search.brave.com/res/v1/news/search"
IMAGE_API_URL  = "http://211.233.58.201:7896"
MAX_TOKENS     = 7999
KAGGLE_API_KEY = os.getenv("KDATA_API", "")

# Set Kaggle API key
os.environ["KAGGLE_KEY"] = KAGGLE_API_KEY

# Analysis modes and style definitions
ANALYSIS_MODES = {
    "price_forecast": "농산물 가격 예측과 시장 분석",
    "market_trend": "시장 동향 및 수요 패턴 분석",
    "production_analysis": "생산량 분석 및 식량 안보 전망",
    "agricultural_policy": "농업 정책 및 규제 영향 분석",
    "climate_impact": "기후 변화가 농업에 미치는 영향 분석"
}

RESPONSE_STYLES = {
    "professional": "전문적이고 학술적인 분석",
    "simple": "쉽게 이해할 수 있는 간결한 설명",
    "detailed": "상세한 통계 기반 깊이 있는 분석",
    "action_oriented": "실행 가능한 조언과 추천 중심"
}

# Example search queries
EXAMPLE_QUERIES = {
    "example1": "쌀 가격 추세 및 향후 6개월 전망을 분석해주세요",
    "example2": "기후 변화는 한국 채소 생산에 어떤 영향을 미치나요?",
    "example3": "세계 곡물 시장 동향과 국내 식량 안보에 미치는 영향은?"
}

# ──────────────────────────────── Logging ────────────────────────────────
logging.basicConfig(level=logging.INFO,
                    format="%(asctime)s - %(levelname)s - %(message)s")

# ──────────────────────────────── OpenAI Client ──────────────────────────

@st.cache_resource
def get_openai_client():
    """Create an OpenAI client with timeout and retry settings."""
    if not OPENAI_API_KEY:
        raise RuntimeError("⚠️ OPENAI_API_KEY 환경 변수가 설정되지 않았습니다.")
    return OpenAI(
        api_key=OPENAI_API_KEY,
        timeout=60.0,
        max_retries=3
    )

# ────────────────────────────── Kaggle Dataset Access ──────────────────────
@st.cache_resource
def load_agriculture_dataset():
    """Download and load the UN agriculture dataset from Kaggle"""
    try:
        path = kagglehub.dataset_download("unitednations/global-food-agriculture-statistics")
        logging.info(f"Kaggle dataset downloaded to: {path}")
        
        # Load metadata about available files
        available_files = []
        for root, dirs, files in os.walk(path):
            for file in files:
                if file.endswith('.csv'):
                    file_path = os.path.join(root, file)
                    file_size = os.path.getsize(file_path) / (1024 * 1024)  # Size in MB
                    available_files.append({
                        'name': file,
                        'path': file_path,
                        'size_mb': round(file_size, 2)
                    })
        
        return {
            'base_path': path,
            'files': available_files
        }
    except Exception as e:
        logging.error(f"Error loading Kaggle dataset: {e}")
        return None

def get_dataset_summary():
    """Generate a summary of the available agriculture datasets"""
    dataset_info = load_agriculture_dataset()
    if not dataset_info:
        return "Failed to load the UN global food and agriculture statistics dataset."
    
    summary = "# UN 글로벌 식량 및 농업 통계 데이터셋\n\n"
    summary += f"총 {len(dataset_info['files'])}개의 CSV 파일이 포함되어 있습니다.\n\n"
    
    # List files with sizes
    summary += "## 사용 가능한 데이터 파일:\n\n"
    for i, file_info in enumerate(dataset_info['files'][:10], 1):  # Limit to first 10 files
        summary += f"{i}. **{file_info['name']}** ({file_info['size_mb']} MB)\n"
    
    if len(dataset_info['files']) > 10:
        summary += f"\n...외 {len(dataset_info['files']) - 10}개 파일\n"
    
    # Add example of data structure
    try:
        if dataset_info['files']:
            sample_file = dataset_info['files'][0]['path']
            df = pd.read_csv(sample_file, nrows=5)
            summary += "\n## 데이터 샘플 구조:\n\n"
            summary += df.head(5).to_markdown() + "\n\n"
            
            summary += "## 데이터셋 변수 설명:\n\n"
            for col in df.columns:
                summary += f"- **{col}**: [변수 설명 필요]\n"
    except Exception as e:
        logging.error(f"Error generating dataset sample: {e}")
        summary += "\n데이터 샘플을 생성하는 중 오류가 발생했습니다.\n"
    
    return summary

def analyze_dataset_for_query(query):
    """Find and analyze relevant data from the dataset based on the query"""
    dataset_info = load_agriculture_dataset()
    if not dataset_info:
        return "데이터셋을 불러올 수 없습니다. Kaggle API 연결을 확인해주세요."
    
    # Extract key terms from the query
    query_lower = query.lower()
    
    # Define keywords to look for in the dataset files
    keywords = {
        "쌀": ["rice", "grain"],
        "밀": ["wheat", "grain"],
        "옥수수": ["corn", "maize", "grain"],
        "채소": ["vegetable", "produce"],
        "과일": ["fruit", "produce"],
        "가격": ["price", "cost", "value"],
        "생산": ["production", "yield", "harvest"],
        "수출": ["export", "trade"],
        "수입": ["import", "trade"],
        "소비": ["consumption", "demand"]
    }
    
    # Find relevant files based on the query
    relevant_files = []
    
    # First check for Korean keywords in the query
    found_keywords = []
    for k_term, e_terms in keywords.items():
        if k_term in query_lower:
            found_keywords.extend([k_term] + e_terms)
    
    # If no Korean keywords found, check for English terms in the filenames
    if not found_keywords:
        # Generic search through all files
        relevant_files = dataset_info['files'][:5]  # Take first 5 files as default
    else:
        # Search for files related to the found keywords
        for file_info in dataset_info['files']:
            file_name_lower = file_info['name'].lower()
            for keyword in found_keywords:
                if keyword.lower() in file_name_lower:
                    relevant_files.append(file_info)
                    break
        
        # If still no relevant files, take the first 5 files
        if not relevant_files:
            relevant_files = dataset_info['files'][:5]
    
    # Read and analyze the relevant files
    analysis_result = "# 농업 데이터 분석 결과\n\n"
    analysis_result += f"쿼리: '{query}'에 대한 분석을 수행했습니다.\n\n"
    
    if found_keywords:
        analysis_result += f"## 분석 키워드: {', '.join(set(found_keywords))}\n\n"
    
    # Process each relevant file
    for file_info in relevant_files[:3]:  # Limit to 3 files for performance
        try:
            analysis_result += f"## 파일: {file_info['name']}\n\n"
            
            # Read the CSV file
            df = pd.read_csv(file_info['path'])
            
            # Basic file stats
            analysis_result += f"- 행 수: {len(df)}\n"
            analysis_result += f"- 열 수: {len(df.columns)}\n"
            analysis_result += f"- 열 목록: {', '.join(df.columns.tolist())}\n\n"
            
            # Sample data
            analysis_result += "### 데이터 샘플:\n\n"
            analysis_result += df.head(5).to_markdown() + "\n\n"
            
            # Statistical summary of numeric columns
            numeric_cols = df.select_dtypes(include=['number']).columns
            if len(numeric_cols) > 0:
                analysis_result += "### 기본 통계:\n\n"
                stats_df = df[numeric_cols].describe()
                analysis_result += stats_df.to_markdown() + "\n\n"
            
            # Time series analysis if possible
            time_cols = [col for col in df.columns if 'year' in col.lower() or 'date' in col.lower()]
            if time_cols:
                analysis_result += "### 시계열 패턴:\n\n"
                analysis_result += "데이터셋에 시간 관련 열이 있어 시계열 분석이 가능합니다.\n\n"
            
        except Exception as e:
            logging.error(f"Error analyzing file {file_info['name']}: {e}")
            analysis_result += f"이 파일 분석 중 오류가 발생했습니다: {str(e)}\n\n"
    
    analysis_result += "## 농산물 가격 예측 및 수요 분석에 대한 인사이트\n\n"
    analysis_result += "데이터셋에서 추출한 정보를 바탕으로 다음 인사이트를 제공합니다:\n\n"
    analysis_result += "1. 데이터 기반 분석 (기본적인 요약)\n"
    analysis_result += "2. 주요 가격 및 수요 동향\n"
    analysis_result += "3. 생산량 및 무역 패턴\n\n"
    
    analysis_result += "이 분석은 UN 글로벌 식량 및 농업 통계 데이터셋을 기반으로 합니다.\n\n"
    
    return analysis_result
    
# ──────────────────────────────── System Prompt ─────────────────────────
def get_system_prompt(mode="price_forecast", style="professional", include_search_results=True, include_uploaded_files=False) -> str:
    """
    Generate a system prompt for the 'Agricultural Price & Demand Forecast AI Assistant' interface based on:
    - The selected analysis mode and style
    - Guidelines for using agricultural datasets, web search results and uploaded files
    """
    base_prompt = """
당신은 농업 데이터 전문가로서 농산물 가격 예측과 수요 분석을 수행하는 AI 어시스턴트입니다.

주요 임무:
1. UN 글로벌 식량 및 농업 통계 데이터셋을 기반으로 농산물 시장 분석
2. 농산물 가격 추세 예측 및 수요 패턴 분석
3. 데이터를 바탕으로 명확하고 근거 있는 분석 제공
4. 관련 정보와 인사이트를 체계적으로 구성하여 제시
5. 시각적 이해를 돕기 위해 차트, 그래프 등을 적절히 활용

중요 가이드라인:
- 데이터에 기반한 객관적 분석을 제공하세요
- 분석 과정과 방법론을 명확히 설명하세요
- 통계적 신뢰성과 한계점을 투명하게 제시하세요
- 이해하기 쉬운 시각적 요소로 분석 결과를 보완하세요
- 마크다운을 활용해 응답을 체계적으로 구성하세요
"""

    mode_prompts = {
        "price_forecast": """
농산물 가격 예측 및 시장 분석에 집중합니다:
- 과거 가격 데이터 패턴에 기반한 예측 제공
- 가격 변동성 요인 분석(계절성, 날씨, 정책 등)
- 단기 및 중장기 가격 전망 제시
- 가격에 영향을 미치는 국내외 요인 식별
- 시장 불확실성과 리스크 요소 강조
""",
        "market_trend": """
시장 동향 및 수요 패턴 분석에 집중합니다:
- 주요 농산물 수요 변화 패턴 식별
- 소비자 선호도 및 구매 행동 분석
- 시장 세그먼트 및 틈새시장 기회 탐색
- 시장 확대/축소 트렌드 평가
- 수요 탄력성 및 가격 민감도 분석
""",
        "production_analysis": """
생산량 분석 및 식량 안보 전망에 집중합니다:
- 작물 생산량 추세 및 변동 요인 분석
- 식량 생산과 인구 성장 간의 관계 평가
- 국가/지역별 생산 역량 비교
- 식량 안보 위협 요소 및 취약점 식별
- 생산성 향상 전략 및 기회 제안
""",
        "agricultural_policy": """
농업 정책 및 규제 영향 분석에 집중합니다:
- 정부 정책과, 보조금, 규제의 시장 영향 분석
- 국제 무역 정책과 관세의 농산물 가격 영향 평가
- 농업 지원 프로그램의 효과성 검토
- 규제 환경 변화에 따른 시장 조정 예측
- 정책적 개입의 의도된/의도치 않은 결과 분석
""",
        "climate_impact": """
기후 변화가 농업에 미치는 영향 분석에 집중합니다:
- 기후 변화와 농산물 생산량/품질 간의 상관관계 분석
- 기상 이변이 가격 변동성에 미치는 영향 평가
- 장기적 기후 추세에 따른 농업 패턴 변화 예측
- 기후 회복력 있는 농업 시스템 전략 제안
- 지역별 기후 위험 노출도 및 취약성 매핑
"""
    }

    style_guides = {
        "professional": "전문적이고 학술적인 어조를 사용하세요. 기술적 용어를 적절히 사용하고 체계적인 데이터 분석을 제공하세요.",
        "simple": "쉽고 간결한 언어로 설명하세요. 전문 용어는 최소화하고 핵심 개념을 일상적인 표현으로 전달하세요.",
        "detailed": "상세하고 포괄적인 분석을 제공하세요. 다양한 데이터 포인트, 통계적 뉘앙스, 그리고 여러 시나리오를 고려한 심층 분석을 제시하세요.",
        "action_oriented": "실행 가능한 인사이트와 구체적인 권장사항에 초점을 맞추세요. '다음 단계' 및 '실질적 조언' 섹션을 포함하세요."
    }

    dataset_guide = """
UN 글로벌 식량 및 농업 통계 데이터셋 활용 지침:
- 제공된 데이터셋 분석 결과를 응답의 주요 근거로 사용하세요
- 데이터의 출처와 연도를 명확히 인용하세요
- 데이터셋 내 주요 변수 간의 관계를 분석하여 인사이트를 도출하세요
- 데이터의 한계와 불확실성을 투명하게 언급하세요
- 필요시 데이터 격차를 식별하고 추가 연구가 필요한 영역을 제안하세요
"""

    search_guide = """
웹 검색 결과 활용 지침:
- 데이터셋 분석을 보완하는 최신 시장 정보로 검색 결과를 활용하세요
- 각 정보의 출처를 마크다운 링크로 포함하세요: [출처명](URL)
- 주요 주장이나 데이터 포인트마다 출처를 표시하세요
- 출처가 상충할 경우, 다양한 관점과 신뢰도를 설명하세요
- 관련 동영상 링크는 [비디오: 제목](video_url) 형식으로 포함하세요
- 검색 정보를 일관되고 체계적인 응답으로 통합하세요
- 모든 주요 출처를 나열한 "참고 자료" 섹션을 마지막에 포함하세요
"""

    upload_guide = """
업로드된 파일 활용 지침:
- 업로드된 파일을 응답의 주요 정보원으로 활용하세요
- 쿼리와 직접 관련된 파일 정보를 추출하고 강조하세요
- 관련 구절을 인용하고 특정 파일을 출처로 인용하세요
- CSV 파일의 수치 데이터는 요약 문장으로 변환하세요
- PDF 콘텐츠는 특정 섹션이나 페이지를 참조하세요
- 파일 정보를 웹 검색 결과와 원활하게 통합하세요
- 정보가 상충할 경우, 일반적인 웹 결과보다 파일 콘텐츠를 우선시하세요
"""

    # Base prompt
    final_prompt = base_prompt

    # Add mode-specific guidance
    if mode in mode_prompts:
        final_prompt += "\n" + mode_prompts[mode]

    # Style
    if style in style_guides:
        final_prompt += f"\n\n분석 스타일: {style_guides[style]}"

    # Always include dataset guide
    final_prompt += f"\n\n{dataset_guide}"

    if include_search_results:
        final_prompt += f"\n\n{search_guide}"

    if include_uploaded_files:
        final_prompt += f"\n\n{upload_guide}"

    final_prompt += """
\n\n응답 형식 요구사항:
- 마크다운 제목(## 및 ###)을 사용하여 응답을 체계적으로 구성하세요
- 중요한 점은 굵은 텍스트(**텍스트**)로 강조하세요
- 3-5개의 후속 질문을 포함한 "관련 질문" 섹션을 마지막에 추가하세요
- 적절한 간격과 단락 구분으로 응답을 서식화하세요
- 모든 링크는 마크다운 형식으로 클릭 가능하게 만드세요: [텍스트](url)
- 가능한 경우 데이터를 시각적으로 표현(표, 그래프 등의 설명)하세요
"""
    return final_prompt

# ──────────────────────────────── Brave Search API ────────────────────────
@st.cache_data(ttl=3600)
def brave_search(query: str, count: int = 10):
    if not BRAVE_KEY:
        raise RuntimeError("⚠️ SERPHOUSE_API_KEY (Brave API Key) environment variable is empty.")

    headers = {"Accept": "application/json", "Accept-Encoding": "gzip", "X-Subscription-Token": BRAVE_KEY}
    params = {"q": query + " 농산물 가격 동향 농업 데이터", "count": str(count)}

    for attempt in range(3):
        try:
            r = requests.get(BRAVE_ENDPOINT, headers=headers, params=params, timeout=15)
            r.raise_for_status()
            data = r.json()

            logging.info(f"Brave search result data structure: {list(data.keys())}")

            raw = data.get("web", {}).get("results") or data.get("results", [])
            if not raw:
                logging.warning(f"No Brave search results found. Response: {data}")
                raise ValueError("No search results found.")
            
            arts = []
            for i, res in enumerate(raw[:count], 1):
                url = res.get("url", res.get("link", ""))
                host = re.sub(r"https?://(www\.)?", "", url).split("/")[0]
                arts.append({
                    "index": i,
                    "title": res.get("title", "No title"),
                    "link": url,
                    "snippet": res.get("description", res.get("text", "No snippet")),
                    "displayed_link": host
                })

            logging.info(f"Brave search success: {len(arts)} results")
            return arts

        except Exception as e:
            logging.error(f"Brave search failure (attempt {attempt+1}/3): {e}")
            if attempt < 2:
                time.sleep(5)

    return []

@st.cache_data(ttl=3600)
def brave_video_search(query: str, count: int = 3):
    if not BRAVE_KEY:
        raise RuntimeError("⚠️ SERPHOUSE_API_KEY (Brave API Key) environment variable is empty.")

    headers = {"Accept": "application/json","Accept-Encoding": "gzip","X-Subscription-Token": BRAVE_KEY}
    params = {"q": query + " 농산물 가격 농업 시장", "count": str(count)}

    for attempt in range(3):
        try:
            r = requests.get(BRAVE_VIDEO_ENDPOINT, headers=headers, params=params, timeout=15)
            r.raise_for_status()
            data = r.json()

            results = []
            for i, vid in enumerate(data.get("results", [])[:count], 1):
                results.append({
                    "index": i,
                    "title": vid.get("title", "Video"),
                    "video_url": vid.get("url", ""),
                    "thumbnail_url": vid.get("thumbnail", {}).get("src", ""),
                    "source": vid.get("provider", {}).get("name", "Unknown source")
                })

            logging.info(f"Brave video search success: {len(results)} results")
            return results

        except Exception as e:
            logging.error(f"Brave video search failure (attempt {attempt+1}/3): {e}")
            if attempt < 2:
                time.sleep(5)

    return []

@st.cache_data(ttl=3600)
def brave_news_search(query: str, count: int = 3):
    if not BRAVE_KEY:
        raise RuntimeError("⚠️ SERPHOUSE_API_KEY (Brave API Key) environment variable is empty.")

    headers = {"Accept": "application/json","Accept-Encoding": "gzip","X-Subscription-Token": BRAVE_KEY}
    params = {"q": query + " 농산물 가격 동향 농업", "count": str(count)}

    for attempt in range(3):
        try:
            r = requests.get(BRAVE_NEWS_ENDPOINT, headers=headers, params=params, timeout=15)
            r.raise_for_status()
            data = r.json()

            results = []
            for i, news in enumerate(data.get("results", [])[:count], 1):
                results.append({
                    "index": i,
                    "title": news.get("title", "News article"),
                    "url": news.get("url", ""),
                    "description": news.get("description", ""),
                    "source": news.get("source", "Unknown source"),
                    "date": news.get("age", "Unknown date")
                })

            logging.info(f"Brave news search success: {len(results)} results")
            return results

        except Exception as e:
            logging.error(f"Brave news search failure (attempt {attempt+1}/3): {e}")
            if attempt < 2:
                time.sleep(5)

    return []

def mock_results(query: str) -> str:
    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    return (f"# 대체 검색 콘텐츠 (생성 시간: {ts})\n\n"
            f"'{query}'에 대한 검색 API 요청이 실패했거나 결과가 없습니다. "
            f"기존 지식을 기반으로 응답을 생성해주세요.\n\n"
            f"다음 사항을 고려하세요:\n\n"
            f"- {query}에 관한 기본 개념과 중요성\n"
            f"- 일반적으로 알려진 관련 통계나 추세\n"
            f"- 이 주제에 대한 전문가 의견\n"
            f"- 독자가 가질 수 있는 질문\n\n"
            f"참고: 이는 실시간 데이터가 아닌 대체 지침입니다.\n\n")

def do_web_search(query: str) -> str:
    try:
        arts = brave_search(query, 10)
        if not arts:
            logging.warning("No search results, using fallback content")
            return mock_results(query)

        videos = brave_video_search(query, 2)
        news   = brave_news_search(query, 3)
        
        result = "# 웹 검색 결과\n다음 결과를 활용하여 데이터셋 분석을 보완하는 포괄적인 답변을 제공하세요.\n\n"
        
        result += "## 웹 결과\n\n"
        for a in arts[:5]:
            result += f"### 결과 {a['index']}: {a['title']}\n\n{a['snippet']}\n\n"
            result += f"**출처**: [{a['displayed_link']}]({a['link']})\n\n---\n"
        
        if news:
            result += "## 뉴스 결과\n\n"
            for n in news:
                result += f"### {n['title']}\n\n{n['description']}\n\n"
                result += f"**출처**: [{n['source']}]({n['url']}) - {n['date']}\n\n---\n"
                
        if videos:
            result += "## 비디오 결과\n\n"
            for vid in videos:
                result += f"### {vid['title']}\n\n"
                if vid.get('thumbnail_url'):
                    result += f"![썸네일]({vid['thumbnail_url']})\n\n"
                result += f"**시청**: [{vid['source']}]({vid['video_url']})\n\n"
        
        return result
        
    except Exception as e:
        logging.error(f"Web search process failed: {str(e)}")
        return mock_results(query)

# ──────────────────────────────── File Upload Handling ─────────────────────
def process_text_file(file):
    try:
        content = file.read()
        file.seek(0)

        text = content.decode('utf-8', errors='ignore')
        if len(text) > 10000:
            text = text[:9700] + "...(truncated)..."

        result = f"## 텍스트 파일: {file.name}\n\n" + text
        return result
    except Exception as e:
        logging.error(f"Error processing text file: {str(e)}")
        return f"텍스트 파일 처리 오류: {str(e)}"

def process_csv_file(file):
    try:
        content = file.read()
        file.seek(0)

        df = pd.read_csv(io.BytesIO(content))
        result = f"## CSV 파일: {file.name}\n\n"
        result += f"- 행: {len(df)}\n"
        result += f"- 열: {len(df.columns)}\n"
        result += f"- 열 이름: {', '.join(df.columns.tolist())}\n\n"

        result += "### 데이터 미리보기\n\n"
        preview_df = df.head(10)
        try:
            markdown_table = preview_df.to_markdown(index=False)
            if markdown_table:
                result += markdown_table + "\n\n"
            else:
                result += "CSV 데이터를 표시할 수 없습니다.\n\n"
        except Exception as e:
            logging.error(f"Markdown table conversion error: {e}")
            result += "텍스트로 데이터 표시:\n\n" + str(preview_df) + "\n\n"

        num_cols = df.select_dtypes(include=['number']).columns
        if len(num_cols) > 0:
            result += "### 기본 통계 정보\n\n"
            try:
                stats_df = df[num_cols].describe().round(2)
                stats_markdown = stats_df.to_markdown()
                if stats_markdown:
                    result += stats_markdown + "\n\n"
                else:
                    result += "통계 정보를 표시할 수 없습니다.\n\n"
            except Exception as e:
                logging.error(f"Statistical info conversion error: {e}")
                result += "통계 정보를 생성할 수 없습니다.\n\n"

        return result
    except Exception as e:
        logging.error(f"CSV file processing error: {str(e)}")
        return f"CSV 파일 처리 오류: {str(e)}"

def process_pdf_file(file):
    try:
        file_bytes = file.read()
        file.seek(0)

        pdf_file = io.BytesIO(file_bytes)
        reader = PyPDF2.PdfReader(pdf_file, strict=False)

        result = f"## PDF 파일: {file.name}\n\n- 총 페이지: {len(reader.pages)}\n\n"

        max_pages = min(5, len(reader.pages))
        all_text = ""

        for i in range(max_pages):
            try:
                page = reader.pages[i]
                page_text = page.extract_text()
                current_page_text = f"### 페이지 {i+1}\n\n"
                if page_text and len(page_text.strip()) > 0:
                    if len(page_text) > 1500:
                        current_page_text += page_text[:1500] + "...(축약됨)...\n\n"
                    else:
                        current_page_text += page_text + "\n\n"
                else:
                    current_page_text += "(텍스트를 추출할 수 없음)\n\n"

                all_text += current_page_text

                if len(all_text) > 8000:
                    all_text += "...(나머지 페이지 축약됨)...\n\n"
                    break

            except Exception as page_err:
                logging.error(f"Error processing PDF page {i+1}: {str(page_err)}")
                all_text += f"### 페이지 {i+1}\n\n(내용 추출 오류: {str(page_err)})\n\n"

        if len(reader.pages) > max_pages:
            all_text += f"\n참고: 처음 {max_pages} 페이지만 표시됩니다.\n\n"

        result += "### PDF 내용\n\n" + all_text
        return result

    except Exception as e:
        logging.error(f"PDF file processing error: {str(e)}")
        return f"## PDF 파일: {file.name}\n\n오류: {str(e)}\n\n처리할 수 없습니다."

def process_uploaded_files(files):
    if not files:
        return None

    result = "# 업로드된 파일 내용\n\n사용자가 제공한 파일의 내용입니다.\n\n"
    for file in files:
        try:
            ext = file.name.split('.')[-1].lower()
            if ext == 'txt':
                result += process_text_file(file) + "\n\n---\n\n"
            elif ext == 'csv':
                result += process_csv_file(file) + "\n\n---\n\n"
            elif ext == 'pdf':
                result += process_pdf_file(file) + "\n\n---\n\n"
            else:
                result += f"### 지원되지 않는 파일: {file.name}\n\n---\n\n"
        except Exception as e:
            logging.error(f"File processing error {file.name}: {e}")
            result += f"### 파일 처리 오류: {file.name}\n\n오류: {e}\n\n---\n\n"

    return result

# ──────────────────────────────── Image & Utility ─────────────────────────

def generate_image(prompt, w=768, h=768, g=3.5, steps=30, seed=3):
    if not prompt:
        return None, "Insufficient prompt"
    try:
        res = Client(IMAGE_API_URL).predict(
            prompt=prompt, width=w, height=h, guidance=g,
            inference_steps=steps, seed=seed,
            do_img2img=False, init_image=None,
            image2image_strength=0.8, resize_img=True,
            api_name="/generate_image"
        )
        return res[0], f"Seed: {res[1]}"
    except Exception as e:
        logging.error(e)
        return None, str(e)

def extract_image_prompt(response_text: str, topic: str):
    client = get_openai_client()
    try:
        response = client.chat.completions.create(
            model="gpt-4.1-mini",
            messages=[
                {"role": "system", "content": "농업 및 농산물에 관한 이미지 프롬프트를 생성합니다. 한 줄의 영어로 된 프롬프트만 반환하세요, 다른 텍스트는 포함하지 마세요."},
                {"role": "user", "content": f"주제: {topic}\n\n---\n{response_text}\n\n---"}
            ],
            temperature=1,
            max_tokens=80,
            top_p=1
        )
        return response.choices[0].message.content.strip()
    except Exception as e:
        logging.error(f"OpenAI image prompt generation error: {e}")
        return f"A professional photograph of agricultural produce and farm fields, data visualization of crop prices and trends, high quality"

def md_to_html(md: str, title="농산물 수요 예측 분석 결과"):
    return f"<!DOCTYPE html><html><head><title>{title}</title><meta charset='utf-8'></head><body>{markdown.markdown(md)}</body></html>"

def keywords(text: str, top=5):
    cleaned = re.sub(r"[^가-힣a-zA-Z0-9\s]", "", text)
    return " ".join(cleaned.split()[:top])

# ──────────────────────────────── Streamlit UI ────────────────────────────
def agricultural_price_forecast_app():
    st.title("농산물 수요 및 가격 예측 AI 어시스턴트")
    st.markdown("UN 글로벌 식량 및 농업 통계 데이터셋 분석 기반의 농산물 시장 예측")

    if "ai_model" not in st.session_state:
        st.session_state.ai_model = "gpt-4.1-mini"
    if "messages" not in st.session_state:
        st.session_state.messages = []
    if "auto_save" not in st.session_state:
        st.session_state.auto_save = True
    if "generate_image" not in st.session_state:
        st.session_state.generate_image = False
    if "web_search_enabled" not in st.session_state:
        st.session_state.web_search_enabled = True
    if "analysis_mode" not in st.session_state:
        st.session_state.analysis_mode = "price_forecast"
    if "response_style" not in st.session_state:
        st.session_state.response_style = "professional"

    sb = st.sidebar
    sb.title("분석 설정")
    
    # Kaggle dataset info display
    if sb.checkbox("데이터셋 정보 표시", value=False):
        st.info("UN 글로벌 식량 및 농업 통계 데이터셋을 불러오는 중...")
        dataset_info = load_agriculture_dataset()
        if dataset_info:
            st.success(f"데이터셋 로드 완료: {len(dataset_info['files'])}개 파일")
            
            with st.expander("데이터셋 미리보기", expanded=False):
                for file_info in dataset_info['files'][:5]:
                    st.write(f"**{file_info['name']}** ({file_info['size_mb']} MB)")
        else:
            st.error("데이터셋을 불러오는데 실패했습니다. Kaggle API 설정을 확인하세요.")
    
    sb.subheader("분석 구성")
    sb.selectbox(
        "분석 모드", 
        options=list(ANALYSIS_MODES.keys()), 
        format_func=lambda x: ANALYSIS_MODES[x],
        key="analysis_mode"
    )
    
    sb.selectbox(
        "응답 스타일",
        options=list(RESPONSE_STYLES.keys()),
        format_func=lambda x: RESPONSE_STYLES[x],
        key="response_style"
    )
    
    # Example queries
    sb.subheader("예시 질문")
    c1, c2, c3 = sb.columns(3)
    if c1.button("쌀 가격 전망", key="ex1"):
        process_example(EXAMPLE_QUERIES["example1"])
    if c2.button("기후 영향", key="ex2"):
        process_example(EXAMPLE_QUERIES["example2"])
    if c3.button("곡물 시장", key="ex3"):
        process_example(EXAMPLE_QUERIES["example3"])
    
    sb.subheader("기타 설정")
    sb.toggle("자동 저장", key="auto_save")
    sb.toggle("이미지 자동 생성", key="generate_image")
    
    web_search_enabled = sb.toggle("웹 검색 사용", value=st.session_state.web_search_enabled)
    st.session_state.web_search_enabled = web_search_enabled
    
    if web_search_enabled:
        st.sidebar.info("✅ 웹 검색 결과가 응답에 통합됩니다.")

    # Download the latest response
    latest_response = next(
        (m["content"] for m in reversed(st.session_state.messages) 
         if m["role"] == "assistant" and m["content"].strip()), 
        None
    )
    if latest_response:
        title_match = re.search(r"# (.*?)(\n|$)", latest_response)
        if title_match:
            title = title_match.group(1).strip()
        else:
            first_line = latest_response.split('\n', 1)[0].strip()
            title = first_line[:40] + "..." if len(first_line) > 40 else first_line
        
        sb.subheader("최신 응답 다운로드")
        d1, d2 = sb.columns(2)
        d1.download_button("마크다운으로 다운로드", latest_response, 
                           file_name=f"{title}.md", mime="text/markdown")
        d2.download_button("HTML로 다운로드", md_to_html(latest_response, title),
                           file_name=f"{title}.html", mime="text/html")

    # JSON conversation record upload
    up = sb.file_uploader("대화 기록 불러오기 (.json)", type=["json"], key="json_uploader")
    if up:
        try:
            st.session_state.messages = json.load(up)
            sb.success("대화 기록을 성공적으로 불러왔습니다")
        except Exception as e:
            sb.error(f"불러오기 실패: {e}")

    # JSON conversation record download
    if sb.button("대화 기록을 JSON으로 다운로드"):
        sb.download_button(
            "저장",
            data=json.dumps(st.session_state.messages, ensure_ascii=False, indent=2),
            file_name="conversation_history.json",
            mime="application/json"
        )

    # File Upload
    st.subheader("파일 업로드")
    uploaded_files = st.file_uploader(
        "참고 자료로 사용할 파일 업로드 (txt, csv, pdf)",
        type=["txt", "csv", "pdf"],
        accept_multiple_files=True,
        key="file_uploader"
    )
    
    if uploaded_files:
        file_count = len(uploaded_files)
        st.success(f"{file_count}개 파일이 업로드되었습니다. 질의에 대한 소스로 사용됩니다.")
        
        with st.expander("업로드된 파일 미리보기", expanded=False):
            for idx, file in enumerate(uploaded_files):
                st.write(f"**파일명:** {file.name}")
                ext = file.name.split('.')[-1].lower()
                
                if ext == 'txt':
                    preview = file.read(1000).decode('utf-8', errors='ignore')
                    file.seek(0)
                    st.text_area(
                        f"{file.name} 미리보기",
                        preview + ("..." if len(preview) >= 1000 else ""),
                        height=150
                    )
                elif ext == 'csv':
                    try:
                        df = pd.read_csv(file)
                        file.seek(0)
                        st.write("CSV 미리보기 (최대 5행)")
                        st.dataframe(df.head(5))
                    except Exception as e:
                        st.error(f"CSV 미리보기 실패: {e}")
                elif ext == 'pdf':
                    try:
                        file_bytes = file.read()
                        file.seek(0)
                        
                        pdf_file = io.BytesIO(file_bytes)
                        reader = PyPDF2.PdfReader(pdf_file, strict=False)
                        
                        pc = len(reader.pages)
                        st.write(f"PDF 파일: {pc}페이지")
                        
                        if pc > 0:
                            try:
                                page_text = reader.pages[0].extract_text()
                                preview = page_text[:500] if page_text else "(텍스트 추출 불가)"
                                st.text_area("첫 페이지 미리보기", preview + "...", height=150)
                            except:
                                st.warning("첫 페이지 텍스트 추출 실패")
                    except Exception as e:
                        st.error(f"PDF 미리보기 실패: {e}")

                if idx < file_count - 1:
                    st.divider()

    # Display existing messages
    for m in st.session_state.messages:
        with st.chat_message(m["role"]):
            st.markdown(m["content"], unsafe_allow_html=True)
            
            # Videos
            if "videos" in m and m["videos"]:
                st.subheader("관련 비디오")
                for video in m["videos"]:
                    video_title = video.get('title', '관련 비디오')
                    video_url   = video.get('url', '')
                    thumbnail   = video.get('thumbnail', '')
                    
                    if thumbnail:
                        col1, col2 = st.columns([1, 3])
                        with col1:
                            st.write("🎬")
                        with col2:
                            st.markdown(f"**[{video_title}]({video_url})**")
                            st.write(f"출처: {video.get('source', '알 수 없음')}")
                    else:
                        st.markdown(f"🎬 **[{video_title}]({video_url})**")
                        st.write(f"출처: {video.get('source', '알 수 없음')}")

    # User input
    query = st.chat_input("농산물 가격, 수요 또는 시장 동향 관련 질문을 입력하세요.")
    if query:
        process_input(query, uploaded_files)

    sb.markdown("---")
    sb.markdown("Created by [https://ginigen.com](https://ginigen.com) | [YouTube Channel](https://www.youtube.com/@ginipickaistudio)")

def process_example(topic):
    process_input(topic, [])

def process_input(query: str, uploaded_files):
    if not any(m["role"] == "user" and m["content"] == query for m in st.session_state.messages):
        st.session_state.messages.append({"role": "user", "content": query})

    with st.chat_message("user"):
        st.markdown(query)
    
    with st.chat_message("assistant"):
        placeholder = st.empty()
        message_placeholder = st.empty()
        full_response = ""

        use_web_search = st.session_state.web_search_enabled
        has_uploaded_files = bool(uploaded_files) and len(uploaded_files) > 0
        
        try:
            status = st.status("질문에 답변 준비 중...")
            status.update(label="클라이언트 초기화 중...")
            
            client = get_openai_client()
            
            search_content = None
            video_results = []
            news_results = []
            
            # 농업 데이터셋 분석 결과 가져오기
            status.update(label="농업 데이터셋 분석 중...")
            with st.spinner("데이터셋 분석 중..."):
                dataset_analysis = analyze_dataset_for_query(query)
            
            if use_web_search:
                status.update(label="웹 검색 수행 중...")
                with st.spinner("웹 검색 중..."):
                    search_content = do_web_search(keywords(query, top=5))
                
                try:
                    status.update(label="비디오 검색 중...")
                    video_results = brave_video_search(query, 2)
                    news_results  = brave_news_search(query, 3)
                except Exception as search_err:
                    logging.error(f"미디어 검색 오류: {search_err}")
            
            file_content = None
            if has_uploaded_files:
                status.update(label="업로드된 파일 처리 중...")
                with st.spinner("파일 분석 중..."):
                    file_content = process_uploaded_files(uploaded_files)
            
            valid_videos = []
            for vid in video_results:
                url = vid.get('video_url')
                if url and url.startswith('http'):
                    valid_videos.append({
                        'url': url,
                        'title': vid.get('title', '비디오'),
                        'thumbnail': vid.get('thumbnail_url', ''),
                        'source': vid.get('source', '비디오 출처')
                    })
            
            status.update(label="종합 분석 준비 중...")
            sys_prompt = get_system_prompt(
                mode=st.session_state.analysis_mode,
                style=st.session_state.response_style,
                include_search_results=use_web_search,
                include_uploaded_files=has_uploaded_files
            )

            api_messages = [
                {"role": "system", "content": sys_prompt}
            ]
            
            user_content = query
            # 항상 데이터셋 분석 결과 포함
            user_content += "\n\n" + dataset_analysis
            
            if search_content:
                user_content += "\n\n" + search_content
            if file_content:
                user_content += "\n\n" + file_content
            
            if valid_videos:
                user_content += "\n\n# 관련 동영상\n"
                for i, vid in enumerate(valid_videos):
                    user_content += f"\n{i+1}. **{vid['title']}** - [{vid['source']}]({vid['url']})\n"
            
            api_messages.append({"role": "user", "content": user_content})
            
            try:
                stream = client.chat.completions.create(
                    model="gpt-4.1-mini",
                    messages=api_messages,
                    temperature=1,
                    max_tokens=MAX_TOKENS,
                    top_p=1,
                    stream=True
                )
                
                for chunk in stream:
                    if chunk.choices and len(chunk.choices) > 0 and chunk.choices[0].delta.content is not None:
                        content_delta = chunk.choices[0].delta.content
                        full_response += content_delta
                        message_placeholder.markdown(full_response + "▌", unsafe_allow_html=True)
                
                message_placeholder.markdown(full_response, unsafe_allow_html=True)
                
                if valid_videos:
                    st.subheader("관련 비디오")
                    for video in valid_videos:
                        video_title = video.get('title', '관련 비디오')
                        video_url   = video.get('url', '')
                        
                        st.markdown(f"🎬 **[{video_title}]({video_url})**")
                        st.write(f"출처: {video.get('source', '알 수 없음')}")

                status.update(label="응답 완료!", state="complete")
                
                st.session_state.messages.append({
                    "role": "assistant", 
                    "content": full_response,
                    "videos": valid_videos
                })
                
            except Exception as api_error:
                error_message = str(api_error)
                logging.error(f"API 오류: {error_message}")
                status.update(label=f"오류: {error_message}", state="error")
                raise Exception(f"응답 생성 오류: {error_message}")
            
            if st.session_state.generate_image and full_response:
                with st.spinner("맞춤형 이미지 생성 중..."):
                    try:
                        ip = extract_image_prompt(full_response, query)
                        img, cap = generate_image(ip)
                        if img:
                            st.subheader("AI 생성 이미지")
                            st.image(img, caption=cap, use_container_width=True)
                    except Exception as img_error:
                        logging.error(f"이미지 생성 오류: {str(img_error)}")
                        st.warning("맞춤형 이미지 생성에 실패했습니다.")

            if full_response:
                st.subheader("이 응답 다운로드")
                c1, c2 = st.columns(2)
                c1.download_button(
                    "마크다운", 
                    data=full_response, 
                    file_name=f"{query[:30]}.md",
                    mime="text/markdown"
                )
                c2.download_button(
                    "HTML",
                    data=md_to_html(full_response, query[:30]),
                    file_name=f"{query[:30]}.html",
                    mime="text/html"
                )

            if st.session_state.auto_save and st.session_state.messages:
                try:
                    fn = f"conversation_history_auto_{datetime.now():%Y%m%d_%H%M%S}.json"
                    with open(fn, "w", encoding="utf-8") as fp:
                        json.dump(st.session_state.messages, fp, ensure_ascii=False, indent=2)
                except Exception as e:
                    logging.error(f"자동 저장 실패: {e}")

        except Exception as e:
            error_message = str(e)
            placeholder.error(f"오류 발생: {error_message}")
            logging.error(f"입력 처리 오류: {error_message}")
            ans = f"요청 처리 중 오류가 발생했습니다: {error_message}"
            st.session_state.messages.append({"role": "assistant", "content": ans})

# ──────────────────────────────── main ────────────────────────────────────
def main():
    st.write("==== 애플리케이션 시작 시간:", datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "=====")
    agricultural_price_forecast_app()

if __name__ == "__main__":
    main()