app.py

import streamlit as st
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import plotly.graph_objects as go
from datetime import date
from pathlib import Path
import matplotlib.font_manager as fm
import matplotlib as mpl
import warnings
warnings.filterwarnings('ignore')

# 필요한 추가 라이브러리 로드
try:
    import statsmodels.api as sm
    from statsmodels.tsa.statespace.sarimax import SARIMAX
    from statsmodels.tsa.holtwinters import ExponentialSmoothing, SimpleExpSmoothing, Holt
    from statsmodels.tsa.seasonal import seasonal_decompose
    from sklearn.linear_model import LinearRegression
    from sklearn.metrics import mean_absolute_percentage_error
except ImportError:
    st.error("필요한 라이브러리가 설치되지 않았습니다. 터미널에서 다음 명령을 실행하세요:")
    st.code("pip install statsmodels scikit-learn")
    st.stop()

# -------------------------------------------------
# CONFIG ------------------------------------------
# -------------------------------------------------
CSV_PATH = Path("2025-domae.csv")
MACRO_START, MACRO_END = "1996-01-01", "2030-12-31"
MICRO_START, MICRO_END = "2024-01-01", "2026-12-31"


# 한글 폰트 설정
font_list = [f.name for f in fm.fontManager.ttflist if 'gothic' in f.name.lower() or 
             'gulim' in f.name.lower() or 'malgun' in f.name.lower() or 
             'nanum' in f.name.lower() or 'batang' in f.name.lower()]

if font_list:
    font_name = font_list[0]
    plt.rcParams['font.family'] = font_name
    mpl.rcParams['axes.unicode_minus'] = False
else:
    plt.rcParams['font.family'] = 'DejaVu Sans'

st.set_page_config(page_title="품목별 가격 예측", page_icon="📈", layout="wide")

# -------------------------------------------------
# 품목별 최적 모델 매핑 ---------------------------
# -------------------------------------------------
item_models = {
    "갈치": {"model1": "SARIMA(1,0,1)(1,0,1,12)", "accuracy1": 99.82, "model2": "Holt-Winters", "accuracy2": 99.80},
    "감자": {"model1": "ETS(Multiplicative)", "accuracy1": 99.58, "model2": "SARIMA(1,0,1)(1,0,1,12)", "accuracy2": 98.70},
    "건고추": {"model1": "SARIMA(1,0,1)(1,0,1,12)", "accuracy1": 99.96, "model2": "Holt", "accuracy2": 99.79},
    "건다시마": {"model1": "Naive", "accuracy1": 99.59, "model2": "SeasonalNaive", "accuracy2": 99.34},
    "고구마": {"model1": "SARIMA(1,1,1)(1,1,1,12)", "accuracy1": 99.89, "model2": "ETS(Multiplicative)", "accuracy2": 98.91},
    "고등어": {"model1": "SARIMA(1,0,1)(1,0,1,12)", "accuracy1": 99.48, "model2": "ETS(Additive)", "accuracy2": 99.42},
    "김": {"model1": "SARIMA(0,1,1)(0,1,1,12)", "accuracy1": 99.99, "model2": "SARIMA(0,1,1)(0,1,1,12)", "accuracy2": 99.93},
    "깐마늘(국산)": {"model1": "SeasonalNaive", "accuracy1": 99.79, "model2": "MovingAverage-6 m", "accuracy2": 98.65},
    "깻잎": {"model1": "SARIMA(0,1,1)(0,1,1,12)", "accuracy1": 99.68, "model2": "Holt", "accuracy2": 99.54},
    "녹두": {"model1": "WeightedMA-6 m", "accuracy1": 99.53, "model2": "Fourier + LR", "accuracy2": 99.53},
    "느타리버섯": {"model1": "SARIMA(0,1,1)(0,1,1,12)", "accuracy1": 99.84, "model2": "LinearTrend", "accuracy2": 99.80},
    "당근": {"model1": "Holt", "accuracy1": 99.25, "model2": "ETS(Multiplicative)", "accuracy2": 97.27},
    "들깨": {"model1": "Holt", "accuracy1": 99.57, "model2": "Holt-Winters", "accuracy2": 99.17},
    "땅콩": {"model1": "SARIMA(1,1,1)(1,1,1,12)", "accuracy1": 99.74, "model2": "ETS(Additive)", "accuracy2": 99.37},
    "레몬": {"model1": "WeightedMA-6 m", "accuracy1": 99.99, "model2": "LinearTrend", "accuracy2": 98.99},
    "망고": {"model1": "SARIMA(1,0,1)(1,0,1,12)", "accuracy1": 99.38, "model2": "Holt-Winters", "accuracy2": 99.02},
    "메밀": {"model1": "SARIMA(1,0,1)(1,0,1,12)", "accuracy1": 99.48, "model2": "SARIMA(0,1,1)(0,1,1,12)", "accuracy2": 98.99},
    "멜론": {"model1": "Naive", "accuracy1": 99.07, "model2": "ETS(Multiplicative)", "accuracy2": 99.01},
    "명태": {"model1": "SARIMA(1,0,1)(1,0,1,12)", "accuracy1": 100.00, "model2": "MovingAverage-6 m", "accuracy2": 99.93},
    "무": {"model1": "SARIMA(1,1,1)(1,1,1,12)", "accuracy1": 99.54, "model2": "SeasonalNaive", "accuracy2": 88.29, "special": "accuracy_drop"},
    "물오징어": {"model1": "Holt-Winters", "accuracy1": 99.91, "model2": "ETS(Multiplicative)", "accuracy2": 99.36},
    "미나리": {"model1": "SARIMA(1,0,1)(1,0,1,12)", "accuracy1": 98.71, "model2": "LinearTrend", "accuracy2": 98.54},
    "바나나": {"model1": "MovingAverage-6 m", "accuracy1": 99.81, "model2": "ETS(Multiplicative)", "accuracy2": 98.86},
    "방울토마토": {"model1": "ETS(Multiplicative)", "accuracy1": 99.62, "model2": "Holt", "accuracy2": 98.28},
    "배": {"model1": "ETS(Additive)", "accuracy1": 99.34, "model2": "LinearTrend", "accuracy2": 98.57},
    "배추": {"model1": "Holt", "accuracy1": 99.98, "model2": "MovingAverage-6 m", "accuracy2": 99.71},
    "북어": {"model1": "Fourier + LR", "accuracy1": 99.96, "model2": "MovingAverage-6 m", "accuracy2": 99.94},
    "붉은고추": {"model1": "SARIMA(1,1,1)(1,1,1,12)", "accuracy1": 99.75, "model2": "LinearTrend", "accuracy2": 97.61},
    "브로콜리": {"model1": "Holt", "accuracy1": 99.54, "model2": "Naive", "accuracy2": 99.93},
    "사과": {"model1": "Holt-Winters", "accuracy1": 99.89, "model2": "ETS(Multiplicative)", "accuracy2": 98.91},
    "상추": {"model1": "ETS(Additive)", "accuracy1": 99.11, "model2": "Holt-Winters", "accuracy2": 97.61},
    "새송이버섯": {"model1": "SimpleExpSmoothing", "accuracy1": 99.95, "model2": "Holt-Winters", "accuracy2": 99.40},
    "새우": {"model1": "ETS(Additive)", "accuracy1": 99.87, "model2": "Naive", "accuracy2": 99.96},
    "생강": {"model1": "Naive", "accuracy1": 99.27, "model2": "ETS(Additive)", "accuracy2": 98.53},
    "수박": {"model1": "Naive", "accuracy1": 99.91, "model2": "SARIMA(1,1,1)(1,1,1,12)", "accuracy2": 99.45},
    "시금치": {"model1": "Holt-Winters", "accuracy1": 99.70, "model2": "SeasonalNaive", "accuracy2": 98.73},
    "쌀": {"model1": "SARIMA(0,1,1)(0,1,1,12)", "accuracy1": 99.99, "model2": "Holt-Winters", "accuracy2": 99.88},
    "알배기배추": {"model1": "WeightedMA-6 m", "accuracy1": 98.19, "model2": "SeasonalNaive", "accuracy2": 95.73},
    "양배추": {"model1": "Holt-Winters", "accuracy1": 99.05, "model2": "WeightedMA-6 m", "accuracy2": 97.85},
    "양파": {"model1": "ETS(Additive)", "accuracy1": 99.93, "model2": "WeightedMA-6 m", "accuracy2": 99.51},
    "얼갈이배추": {"model1": "SARIMA(1,1,1)(1,1,1,12)", "accuracy1": 99.77, "model2": "SeasonalNaive", "accuracy2": 98.55},
    "열무": {"model1": "SeasonalNaive", "accuracy1": 99.96, "model2": "Holt", "accuracy2": 99.50},
    "오이": {"model1": "SeasonalNaive", "accuracy1": 99.82, "model2": "ETS(Additive)", "accuracy2": 98.48},
    "전복": {"model1": "Holt", "accuracy1": 99.90, "model2": "Fourier + LR", "accuracy2": 99.90},
    "참깨": {"model1": "WeightedMA-6 m", "accuracy1": 100.00, "model2": "LinearTrend", "accuracy2": 86.44, "special": "accuracy_drop"},
    "찹쌀": {"model1": "SARIMA(1,0,1)(1,0,1,12)", "accuracy1": 99.71, "model2": "Naive", "accuracy2": 98.64, "special": "accuracy_drop"},
    "콩": {"model1": "SARIMA(0,1,1)(0,1,1,12)", "accuracy1": 99.98, "model2": "ETS(Additive)", "accuracy2": 99.68},
    "토마토": {"model1": "SeasonalNaive", "accuracy1": 97.31, "model2": "MovingAverage-6 m", "accuracy2": 97.57},
    "파": {"model1": "MovingAverage-6 m", "accuracy1": 99.92, "model2": "Holt-Winters", "accuracy2": 97.77},
    "파인애플": {"model1": "Naive", "accuracy1": 99.51, "model2": "SARIMA(1,0,1)(1,0,1,12)", "accuracy2": 96.39},
    "파프리카": {"model1": "SARIMA(0,1,1)(0,1,1,12)", "accuracy1": 99.04, "model2": "WeightedMA-6 m", "accuracy2": 99.36},
    "팥": {"model1": "ETS(Additive)", "accuracy1": 99.87, "model2": "Holt-Winters", "accuracy2": 75.08, "special": "accuracy_drop"},
    "팽이버섯": {"model1": "SeasonalNaive", "accuracy1": 99.84, "model2": "Fourier + LR", "accuracy2": 98.49},
    "풋고추": {"model1": "Holt-Winters", "accuracy1": 98.95, "model2": "ETS(Multiplicative)", "accuracy2": 98.73},
    "피망": {"model1": "Fourier + LR", "accuracy1": 99.64, "model2": "WeightedMA-6 m", "accuracy2": 98.93},
    "호박": {"model1": "ETS(Multiplicative)", "accuracy1": 99.98, "model2": "SeasonalNaive", "accuracy2": 96.61},
    "홍합": {"model1": "Naive", "accuracy1": 99.86, "model2": "SeasonalNaive", "accuracy2": 98.56},
}

# 기타 품목에 대한 기본 모델 (리스트에 없는 품목)
default_models = {
    "model1": "SARIMA(1,0,1)(1,0,1,12)", 
    "accuracy1": 99.0, 
    "model2": "ETS(Multiplicative)", 
    "accuracy2": 98.0
}

# -------------------------------------------------
# UTILITIES ---------------------------------------
# -------------------------------------------------
DATE_CANDIDATES = {"date", "ds", "ymd", "날짜", "prce_reg_mm", "etl_ldg_dt"}
ITEM_CANDIDATES = {"item", "품목", "code", "category", "pdlt_nm", "spcs_nm"}
PRICE_CANDIDATES = {"price", "y", "value", "가격", "avrg_prce"}

def _standardize_columns(df: pd.DataFrame) -> pd.DataFrame:
    """Standardize column names to date/item/price and deduplicate."""
    col_map = {}
    for c in df.columns:
        lc = c.lower()
        if lc in DATE_CANDIDATES:
            col_map[c] = "date"
        elif lc in PRICE_CANDIDATES:
            col_map[c] = "price"
        elif lc in ITEM_CANDIDATES:
            # first hit as item, second as species
            if "item" not in col_map.values():
                col_map[c] = "item"
            else:
                col_map[c] = "species"
    df = df.rename(columns=col_map)

    # ── handle duplicated columns after rename ─────────────────────────
    if df.columns.duplicated().any():
        df = df.loc[:, ~df.columns.duplicated()]

    # ── index datetime to column ───────────────────────────────────────
    if "date" not in df.columns and df.index.dtype.kind == "M":
        df.reset_index(inplace=True)
        df.rename(columns={df.columns[0]: "date"}, inplace=True)

    # ── convert YYYYMM string to datetime ──────────────────────────────────────
    if "date" in df.columns and pd.api.types.is_object_dtype(df["date"]):
        if len(df) > 0:
            # 더 유연한 날짜 변환
            try:
                # 샘플 확인 (문자열로 변환하여 안전하게 처리)
                sample = str(df["date"].iloc[0])
                
                # YYYYMM 형식 (6자리)
                if sample.isdigit() and len(sample) == 6:
                    df["date"] = pd.to_datetime(df["date"].astype(str), format="%Y%m", errors="coerce")
                    df["date"] = df["date"] + pd.offsets.MonthEnd(0)  # 해당 월의 마지막 날로 설정
                
                # YYYYMMDD 형식 (8자리)
                elif sample.isdigit() and len(sample) == 8:
                    df["date"] = pd.to_datetime(df["date"].astype(str), format="%Y%m%d", errors="coerce")
                
                # 기타 형식은 자동 감지
                else:
                    df["date"] = pd.to_datetime(df["date"], errors="coerce")
            except:
                # 실패 시 일반 변환 시도
                df["date"] = pd.to_datetime(df["date"], errors="coerce")

    # ── build item from pdlt_nm + spcs_nm if needed ────────────────────
    if "item" not in df.columns and {"pdlt_nm", "spcs_nm"}.issubset(df.columns):
        df["item"] = df["pdlt_nm"].str.strip() + "-" + df["spcs_nm"].str.strip()

    # ── merge item + species ───────────────────────────────────────────
    if {"item", "species"}.issubset(df.columns):
        df["item"] = df["item"].astype(str).str.strip() + "-" + df["species"].astype(str).str.strip()
        df.drop(columns=["species"], inplace=True)

    return df

@st.cache_data(show_spinner=False)
def load_data() -> pd.DataFrame:
    """Load price data from CSV file."""
    try:
        if not CSV_PATH.exists():
            st.error(f"💾 {CSV_PATH} 파일을 찾을 수 없습니다.")
            st.stop()
            
        # CSV 파일 직접 로드
        df = pd.read_csv(CSV_PATH)
        st.sidebar.success(f"CSV 데이터 로드 완료: {len(df)}개 행")
        
        # 데이터 표준화 전 원본 데이터 형태 확인
        st.sidebar.write("원본 데이터 컬럼:", list(df.columns))
        
        # 표준화 전 상세 로그
        before_std = len(df)
        df = _standardize_columns(df)
        after_std = len(df)
        if before_std != after_std:
            st.sidebar.warning(f"표준화 중 {before_std - after_std}개 행이 제외되었습니다.")
        
        # 표준화 후 로그
        st.sidebar.write("표준화 후 컬럼:", list(df.columns))

        # 필수 컬럼 확인
        missing = {c for c in ["date", "item", "price"] if c not in df.columns}
        if missing:
            st.error(f"필수 컬럼 누락: {', '.join(missing)} — 파일 컬럼명을 확인하세요.")
            st.stop()

        # 날짜 데이터 확인
        st.sidebar.write("날짜 컬럼 데이터 샘플:", df["date"].head().tolist())
        
        # 날짜 변환 전후 데이터 수 확인
        before_date_convert = len(df)
        
        # YYYYMM 형식 변환 (숫자로 저장된 경우도 처리)
        try:
            # 데이터 타입 확인
            if pd.api.types.is_integer_dtype(df["date"]):
                # 정수형 YYYYMM을 문자열로 변환 후 처리
                df["date"] = df["date"].astype(str)
                
            # 문자열 형식 처리
            if pd.api.types.is_object_dtype(df["date"]):
                # YYYYMM 형식인지 확인 (6자리 숫자)
                if df["date"].str.match(r'^\d{6}$').all():
                    # 연, 월 구분해서 datetime으로 변환
                    df["year"] = df["date"].str[:4].astype(int)
                    df["month"] = df["date"].str[4:6].astype(int)
                    df["date"] = pd.to_datetime(dict(year=df["year"], month=df["month"], day=1))
                    # 월의 마지막 날로 설정
                    df["date"] = df["date"] + pd.offsets.MonthEnd(0)
                    # 임시 컬럼 삭제
                    df.drop(columns=["year", "month"], inplace=True)
                else:
                    # 일반 변환 시도
                    df["date"] = pd.to_datetime(df["date"], errors="coerce")
        except Exception as e:
            st.sidebar.warning(f"날짜 변환 오류: {str(e)}")
            # 최후의 방법으로 다시 시도
            try:
                df["date"] = pd.to_datetime(df["date"].astype(str), format="%Y%m", errors="coerce")
                df["date"] = df["date"] + pd.offsets.MonthEnd(0)
            except:
                df["date"] = pd.to_datetime(df["date"], errors="coerce")
        
        # 날짜 변환 후 데이터 확인
        st.sidebar.write("날짜 변환 후 샘플:", df["date"].head().tolist())
        after_date_convert = df.dropna(subset=["date"]).shape[0]
        if before_date_convert != after_date_convert:
            st.sidebar.warning(f"날짜 변환 중 {before_date_convert - after_date_convert}개 행이 제외되었습니다.")

        # 가격 데이터 숫자로 변환
        df["price"] = pd.to_numeric(df["price"], errors="coerce")
        
        # NA 데이터 처리 전후 수 확인
        before_na_drop = len(df)
        df = df.dropna(subset=["date", "item", "price"])
        after_na_drop = len(df)
        if before_na_drop != after_na_drop:
            st.sidebar.warning(f"NA 제거 중 {before_na_drop - after_na_drop}개 행이 제외되었습니다.")
        
        # 결과 정렬
        df.sort_values("date", inplace=True)
        
        # 데이터 정보 표시
        if len(df) > 0:
            st.sidebar.write(f"최종 데이터: {len(df)}개 행")
            # datetime 형식인지 확인
            if pd.api.types.is_datetime64_dtype(df["date"]):
                st.sidebar.write(f"데이터 날짜 범위: {df['date'].min().strftime('%Y-%m-%d')} ~ {df['date'].max().strftime('%Y-%m-%d')}")
            else:
                st.sidebar.write(f"데이터 날짜 범위: 날짜 형식 변환 실패. 현재 형식: {type(df['date'].iloc[0])}")
            st.sidebar.write(f"총 품목 수: {df['item'].nunique()}")
            st.sidebar.write(f"품목별 평균 데이터 수: {len(df)/df['item'].nunique():.1f}개")
        else:
            st.error("유효한 데이터가 없습니다!")
            
        return df
    except Exception as e:
        st.error(f"데이터 로드 중 오류 발생: {str(e)}")
        import traceback
        st.code(traceback.format_exc())
        st.stop()

@st.cache_data(show_spinner=False)
def get_items(df: pd.DataFrame):
    return sorted(df["item"].unique())

def get_best_model_for_item(item):
    """품목에 맞는 최적 모델 정보 반환"""
    return item_models.get(item, default_models)

def format_currency(value):
    """원화 형식으로 숫자 포맷팅"""
    if pd.isna(value) or not np.isfinite(value):
        return "N/A"
    return f"{value:,.0f}원"

# -------------------------------------------------
# 모델 구현부 --------------------------------------
# -------------------------------------------------
@st.cache_data(show_spinner=False, ttl=3600)
def prepare_monthly_data(df):
    """월별 데이터 준비"""
    # 월별로 집계
    monthly_df = df.copy()
    monthly_df['year_month'] = monthly_df['date'].dt.strftime('%Y-%m')
    monthly_df = monthly_df.groupby('year_month').agg({'date': 'last', 'price': 'mean'}).reset_index(drop=True)
    monthly_df.sort_values('date', inplace=True)
    
    # 인덱스 설정
    monthly_df.set_index('date', inplace=True)
    
    # 결측치 보간 (월별 데이터에 빈 월이 있을 수 있음)
    if len(monthly_df) > 1:
        monthly_df = monthly_df.asfreq('M', method='ffill')
    
    return monthly_df

def fit_sarima(df, order, seasonal_order, horizon_end):
    """SARIMA 모델 구현"""
    import pandas as pd
    import numpy as np
    from statsmodels.tsa.statespace.sarimax import SARIMAX
    
    # 월별 데이터 준비
    monthly_df = prepare_monthly_data(df)
    
    # 모델 학습
    try:
        model = SARIMAX(
            monthly_df['price'],
            order=order,
            seasonal_order=seasonal_order,
            enforce_stationarity=False,
            enforce_invertibility=False
        )
        results = model.fit(disp=False)
        
        # 예측 기간 계산
        last_date = monthly_df.index[-1]
        end_date = pd.Timestamp(horizon_end)
        periods = (end_date.year - last_date.year) * 12 + (end_date.month - last_date.month)
        
        # 예측 수행
        forecast = results.get_forecast(steps=periods)
        pred_mean = forecast.predicted_mean
        pred_ci = forecast.conf_int()
        
        # Prophet 형식으로 결과 변환
        future_dates = pd.date_range(start=last_date + pd.DateOffset(months=1), periods=periods, freq='M')
        
        fc_df = pd.DataFrame({
            'ds': future_dates,
            'yhat': pred_mean.values,
            'yhat_lower': pred_ci.iloc[:, 0].values,
            'yhat_upper': pred_ci.iloc[:, 1].values
        })
        
        # 월별로 결과 변환 (날짜, 가격)
        fc_df_monthly = pd.DataFrame({
            'ds': pd.date_range(start=monthly_df.index[0], end=future_dates[-1], freq='M'),
        })
        
        # 학습 데이터 기간의 결과 추가
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat'] = monthly_df['price'].values
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_lower'] = monthly_df['price'].values
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_upper'] = monthly_df['price'].values
        
        # 예측 기간의 결과 추가
        fc_df_monthly.loc[len(monthly_df):, 'yhat'] = fc_df['yhat'].values
        fc_df_monthly.loc[len(monthly_df):, 'yhat_lower'] = fc_df['yhat_lower'].values
        fc_df_monthly.loc[len(monthly_df):, 'yhat_upper'] = fc_df['yhat_upper'].values
        
        # yearly, trend 컴포넌트 추가 (Prophet 호환)
        fc_df_monthly['yearly'] = 0
        fc_df_monthly['trend'] = 0
        
        try:
            # 가능하면 계절성 분해
            decomposition = seasonal_decompose(monthly_df['price'], model='multiplicative', period=12)
            trend = decomposition.trend
            seasonal = decomposition.seasonal
            
            # 결과에 계절성 반영
            for i, date in enumerate(fc_df_monthly['ds']):
                month = date.month
                if month in seasonal.index.month:
                    seasonal_value = seasonal[seasonal.index.month == month].mean()
                    fc_df_monthly.loc[i, 'yearly'] = seasonal_value
        except:
            pass
        
        return fc_df_monthly
    
    except Exception as e:
        st.error(f"SARIMA 모델 오류: {str(e)}")
        return None

def fit_ets(df, seasonal_type, horizon_end):
    """ETS 모델 구현"""
    # 월별 데이터 준비
    monthly_df = prepare_monthly_data(df)
    
    # 모델 파라미터 설정
    if seasonal_type == 'multiplicative':
        trend_type = 'add'
        seasonal = 'mul'
    else:  # additive
        trend_type = 'add'
        seasonal = 'add'
        
    # 모델 학습
    try:
        model = ExponentialSmoothing(
            monthly_df['price'],
            trend=trend_type,
            seasonal=seasonal,
            seasonal_periods=12,
            damped=True
        )
        results = model.fit(optimized=True)
        
        # 예측 기간 계산
        last_date = monthly_df.index[-1]
        end_date = pd.Timestamp(horizon_end)
        periods = (end_date.year - last_date.year) * 12 + (end_date.month - last_date.month)
        
        # 예측 수행
        forecast = results.forecast(periods)
        
        # Prophet 형식으로 결과 변환
        future_dates = pd.date_range(start=last_date + pd.DateOffset(months=1), periods=periods, freq='M')
        
        # 신뢰 구간 추정 (ETS는 기본 신뢰 구간을 제공하지 않음)
        std_error = np.std(results.resid)
        lower_bound = forecast - 1.96 * std_error
        upper_bound = forecast + 1.96 * std_error
        
        fc_df = pd.DataFrame({
            'ds': future_dates,
            'yhat': forecast.values,
            'yhat_lower': lower_bound.values,
            'yhat_upper': upper_bound.values
        })
        
        # 월별로 결과 변환
        fc_df_monthly = pd.DataFrame({
            'ds': pd.date_range(start=monthly_df.index[0], end=future_dates[-1], freq='M'),
        })
        
        # 학습 데이터 기간의 결과 추가
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat'] = monthly_df['price'].values
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_lower'] = monthly_df['price'].values
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_upper'] = monthly_df['price'].values
        
        # 예측 기간의 결과 추가
        fc_df_monthly.loc[len(monthly_df):, 'yhat'] = fc_df['yhat'].values
        fc_df_monthly.loc[len(monthly_df):, 'yhat_lower'] = fc_df['yhat_lower'].values
        fc_df_monthly.loc[len(monthly_df):, 'yhat_upper'] = fc_df['yhat_upper'].values
        
        # yearly, trend 컴포넌트 추가 (Prophet 호환)
        fc_df_monthly['yearly'] = 0
        fc_df_monthly['trend'] = 0
        
        try:
            # 가능하면 계절성 분해
            decomposition = seasonal_decompose(monthly_df['price'], model=seasonal_type, period=12)
            trend = decomposition.trend
            seasonal = decomposition.seasonal
            
            # 결과에 계절성 반영
            for i, date in enumerate(fc_df_monthly['ds']):
                month = date.month
                if month in seasonal.index.month:
                    seasonal_value = seasonal[seasonal.index.month == month].mean()
                    fc_df_monthly.loc[i, 'yearly'] = seasonal_value
        except:
            pass
        
        return fc_df_monthly
    
    except Exception as e:
        st.error(f"ETS 모델 오류: {str(e)}")
        return None

def fit_holt(df, horizon_end):
    """Holt 모델 구현"""
    # 월별 데이터 준비
    monthly_df = prepare_monthly_data(df)
    
    # 모델 학습
    try:
        model = Holt(monthly_df['price'], damped=True)
        results = model.fit(optimized=True)
        
        # 예측 기간 계산
        last_date = monthly_df.index[-1]
        end_date = pd.Timestamp(horizon_end)
        periods = (end_date.year - last_date.year) * 12 + (end_date.month - last_date.month)
        
        # 예측 수행
        forecast = results.forecast(periods)
        
        # Prophet 형식으로 결과 변환
        future_dates = pd.date_range(start=last_date + pd.DateOffset(months=1), periods=periods, freq='M')
        
        # 신뢰 구간 추정
        std_error = np.std(results.resid)
        lower_bound = forecast - 1.96 * std_error
        upper_bound = forecast + 1.96 * std_error
        
        fc_df = pd.DataFrame({
            'ds': future_dates,
            'yhat': forecast.values,
            'yhat_lower': lower_bound.values,
            'yhat_upper': upper_bound.values
        })
        
        # 월별로 결과 변환
        fc_df_monthly = pd.DataFrame({
            'ds': pd.date_range(start=monthly_df.index[0], end=future_dates[-1], freq='M'),
        })
        
        # 학습 데이터 기간의 결과 추가
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat'] = monthly_df['price'].values
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_lower'] = monthly_df['price'].values
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_upper'] = monthly_df['price'].values
        
        # 예측 기간의 결과 추가
        fc_df_monthly.loc[len(monthly_df):, 'yhat'] = fc_df['yhat'].values
        fc_df_monthly.loc[len(monthly_df):, 'yhat_lower'] = fc_df['yhat_lower'].values
        fc_df_monthly.loc[len(monthly_df):, 'yhat_upper'] = fc_df['yhat_upper'].values
        
        # yearly, trend 컴포넌트 추가 (Prophet 호환)
        fc_df_monthly['yearly'] = 0
        fc_df_monthly['trend'] = fc_df_monthly['yhat']  # Holt는 추세만 모델링
        
        return fc_df_monthly
    
    except Exception as e:
        st.error(f"Holt 모델 오류: {str(e)}")
        return None

def fit_holt_winters(df, horizon_end):
    """Holt-Winters 모델 구현"""
    # 월별 데이터 준비
    monthly_df = prepare_monthly_data(df)
    
    # 모델 학습
    try:
        model = ExponentialSmoothing(
            monthly_df['price'],
            trend='add',
            seasonal='mul',  # 계절성은 곱셈 방식이 농산물 가격에 더 적합
            seasonal_periods=12,
            damped=True
        )
        results = model.fit(optimized=True)
        
        # 예측 기간 계산
        last_date = monthly_df.index[-1]
        end_date = pd.Timestamp(horizon_end)
        periods = (end_date.year - last_date.year) * 12 + (end_date.month - last_date.month)
        
        # 예측 수행
        forecast = results.forecast(periods)
        
        # Prophet 형식으로 결과 변환
        future_dates = pd.date_range(start=last_date + pd.DateOffset(months=1), periods=periods, freq='M')
        
        # 신뢰 구간 추정
        std_error = np.std(results.resid)
        lower_bound = forecast - 1.96 * std_error
        upper_bound = forecast + 1.96 * std_error
        
        fc_df = pd.DataFrame({
            'ds': future_dates,
            'yhat': forecast.values,
            'yhat_lower': lower_bound.values,
            'yhat_upper': upper_bound.values
        })
        
        # 월별로 결과 변환
        fc_df_monthly = pd.DataFrame({
            'ds': pd.date_range(start=monthly_df.index[0], end=future_dates[-1], freq='M'),
        })
        
        # 학습 데이터 기간의 결과 추가
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat'] = monthly_df['price'].values
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_lower'] = monthly_df['price'].values
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_upper'] = monthly_df['price'].values
        
        # 예측 기간의 결과 추가
        fc_df_monthly.loc[len(monthly_df):, 'yhat'] = fc_df['yhat'].values
        fc_df_monthly.loc[len(monthly_df):, 'yhat_lower'] = fc_df['yhat_lower'].values
        fc_df_monthly.loc[len(monthly_df):, 'yhat_upper'] = fc_df['yhat_upper'].values
        
        # yearly, trend 컴포넌트 추가 (Prophet 호환)
        fc_df_monthly['yearly'] = 0
        fc_df_monthly['trend'] = 0
        
        try:
            # Holt-Winters 모델에서 계절성 추출
            seasonal = results.seasonal_
            
            # 결과에 계절성 반영
            for i, date in enumerate(fc_df_monthly['ds']):
                month = date.month - 1  # 0-indexed
                if month < len(seasonal):
                    fc_df_monthly.loc[i, 'yearly'] = seasonal[month] * fc_df_monthly.loc[i, 'yhat']
                    fc_df_monthly.loc[i, 'trend'] = fc_df_monthly.loc[i, 'yhat'] - fc_df_monthly.loc[i, 'yearly']
        except:
            pass
        
        return fc_df_monthly
    
    except Exception as e:
        st.error(f"Holt-Winters 모델 오류: {str(e)}")
        return None

def fit_moving_average(df, window, horizon_end):
    """이동 평균 모델 구현"""
    # 월별 데이터 준비
    monthly_df = prepare_monthly_data(df)
    
    try:
        # 마지막 window 개월의 평균 계산
        last_values = monthly_df['price'].iloc[-window:]
        ma_value = last_values.mean()
        
        # 예측 기간 계산
        last_date = monthly_df.index[-1]
        end_date = pd.Timestamp(horizon_end)
        periods = (end_date.year - last_date.year) * 12 + (end_date.month - last_date.month)
        
        # 예측 수행 (모든 미래 시점에 동일한 값)
        future_dates = pd.date_range(start=last_date + pd.DateOffset(months=1), periods=periods, freq='M')
        
        # 신뢰 구간 추정
        std_error = last_values.std()
        lower_bound = ma_value - 1.96 * std_error
        upper_bound = ma_value + 1.96 * std_error
        
        fc_df = pd.DataFrame({
            'ds': future_dates,
            'yhat': [ma_value] * len(future_dates),
            'yhat_lower': [lower_bound] * len(future_dates),
            'yhat_upper': [upper_bound] * len(future_dates)
        })
        
        # 월별로 결과 변환
        fc_df_monthly = pd.DataFrame({
            'ds': pd.date_range(start=monthly_df.index[0], end=future_dates[-1], freq='M'),
        })
        
        # 학습 데이터 기간의 결과 추가
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat'] = monthly_df['price'].values
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_lower'] = monthly_df['price'].values
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_upper'] = monthly_df['price'].values
        
        # 예측 기간의 결과 추가
        fc_df_monthly.loc[len(monthly_df):, 'yhat'] = fc_df['yhat'].values
        fc_df_monthly.loc[len(monthly_df):, 'yhat_lower'] = fc_df['yhat_lower'].values
        fc_df_monthly.loc[len(monthly_df):, 'yhat_upper'] = fc_df['yhat_upper'].values
        
        # yearly, trend 컴포넌트 추가 (Prophet 호환)
        fc_df_monthly['yearly'] = 0
        fc_df_monthly['trend'] = fc_df_monthly['yhat']
        
        return fc_df_monthly
    
    except Exception as e:
        st.error(f"이동 평균 모델 오류: {str(e)}")
        return None

def fit_weighted_ma(df, window, horizon_end):
    """가중 이동 평균 모델 구현"""
    # 월별 데이터 준비
    monthly_df = prepare_monthly_data(df)
    
    try:
        # 마지막 window 개월의 가중 평균 계산
        last_values = monthly_df['price'].iloc[-window:].to_numpy()
        
        # 가중치 생성 (최근 데이터에 더 높은 가중치)
        weights = np.arange(1, window + 1)
        weights = weights / np.sum(weights)
        
        wma_value = np.sum(last_values * weights)
        
        # 예측 기간 계산
        last_date = monthly_df.index[-1]
        end_date = pd.Timestamp(horizon_end)
        periods = (end_date.year - last_date.year) * 12 + (end_date.month - last_date.month)
        
        # 예측 수행 (모든 미래 시점에 동일한 값)
        future_dates = pd.date_range(start=last_date + pd.DateOffset(months=1), periods=periods, freq='M')
        
        # 신뢰 구간 추정
        std_error = np.std(last_values)
        lower_bound = wma_value - 1.96 * std_error
        upper_bound = wma_value + 1.96 * std_error
        
        fc_df = pd.DataFrame({
            'ds': future_dates,
            'yhat': [wma_value] * len(future_dates),
            'yhat_lower': [lower_bound] * len(future_dates),
            'yhat_upper': [upper_bound] * len(future_dates)
        })
        
        # 월별로 결과 변환
        fc_df_monthly = pd.DataFrame({
            'ds': pd.date_range(start=monthly_df.index[0], end=future_dates[-1], freq='M'),
        })
        
        # 학습 데이터 기간의 결과 추가
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat'] = monthly_df['price'].values
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_lower'] = monthly_df['price'].values
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_upper'] = monthly_df['price'].values
        
        # 예측 기간의 결과 추가
        fc_df_monthly.loc[len(monthly_df):, 'yhat'] = fc_df['yhat'].values
        fc_df_monthly.loc[len(monthly_df):, 'yhat_lower'] = fc_df['yhat_lower'].values
        fc_df_monthly.loc[len(monthly_df):, 'yhat_upper'] = fc_df['yhat_upper'].values
        
        # yearly, trend 컴포넌트 추가 (Prophet 호환)
        fc_df_monthly['yearly'] = 0
        fc_df_monthly['trend'] = fc_df_monthly['yhat']
        
        return fc_df_monthly
    
    except Exception as e:
        st.error(f"가중 이동 평균 모델 오류: {str(e)}")
        return None

def fit_naive(df, horizon_end):
    """단순 Naive 모델 구현"""
    # 월별 데이터 준비
    monthly_df = prepare_monthly_data(df)
    
    try:
        # 마지막 값 사용
        last_value = monthly_df['price'].iloc[-1]
        
        # 예측 기간 계산
        last_date = monthly_df.index[-1]
        end_date = pd.Timestamp(horizon_end)
        periods = (end_date.year - last_date.year) * 12 + (end_date.month - last_date.month)
        
        # 예측 수행 (모든 미래 시점에 마지막 값)
        future_dates = pd.date_range(start=last_date + pd.DateOffset(months=1), periods=periods, freq='M')
        
        # 신뢰 구간 추정 (과거 12개월 표준편차 사용)
        history_std = monthly_df['price'].iloc[-12:].std() if len(monthly_df) >= 12 else monthly_df['price'].std()
        lower_bound = last_value - 1.96 * history_std
        upper_bound = last_value + 1.96 * history_std
        
        fc_df = pd.DataFrame({
            'ds': future_dates,
            'yhat': [last_value] * len(future_dates),
            'yhat_lower': [lower_bound] * len(future_dates),
            'yhat_upper': [upper_bound] * len(future_dates)
        })
        
        # 월별로 결과 변환
        fc_df_monthly = pd.DataFrame({
            'ds': pd.date_range(start=monthly_df.index[0], end=future_dates[-1], freq='M'),
        })
        
        # 학습 데이터 기간의 결과 추가
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat'] = monthly_df['price'].values
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_lower'] = monthly_df['price'].values
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_upper'] = monthly_df['price'].values
        
        # 예측 기간의 결과 추가
        fc_df_monthly.loc[len(monthly_df):, 'yhat'] = fc_df['yhat'].values
        fc_df_monthly.loc[len(monthly_df):, 'yhat_lower'] = fc_df['yhat_lower'].values
        fc_df_monthly.loc[len(monthly_df):, 'yhat_upper'] = fc_df['yhat_upper'].values
        
        # yearly, trend 컴포넌트 추가 (Prophet 호환)
        fc_df_monthly['yearly'] = 0
        fc_df_monthly['trend'] = fc_df_monthly['yhat']
        
        return fc_df_monthly
    
    except Exception as e:
        st.error(f"Naive 모델 오류: {str(e)}")
        return None

def fit_seasonal_naive(df, horizon_end):
    """계절성 Naive 모델 구현"""
    # 월별 데이터 준비
    monthly_df = prepare_monthly_data(df)
    
    try:
        # 예측 기간 계산
        last_date = monthly_df.index[-1]
        end_date = pd.Timestamp(horizon_end)
        periods = (end_date.year - last_date.year) * 12 + (end_date.month - last_date.month)
        
        # 예측 수행 (각 월에 대해 작년 같은 달 가격 사용)
        future_dates = pd.date_range(start=last_date + pd.DateOffset(months=1), periods=periods, freq='M')
        future_values = []
        lower_bounds = []
        upper_bounds = []
        
        for date in future_dates:
            # 같은 월의 값 찾기
            same_month_values = monthly_df[monthly_df.index.month == date.month]['price']
            
            if len(same_month_values) > 0:
                # 같은 월 가장 최근 값 사용
                forecast_value = same_month_values.iloc[-1]
                
                # 신뢰 구간
                std_error = same_month_values.std() if len(same_month_values) > 1 else monthly_df['price'].std()
                lower_bound = forecast_value - 1.96 * std_error
                upper_bound = forecast_value + 1.96 * std_error
            else:
                # 같은 월 데이터 없으면 전체 평균 사용
                forecast_value = monthly_df['price'].mean()
                std_error = monthly_df['price'].std()
                lower_bound = forecast_value - 1.96 * std_error
                upper_bound = forecast_value + 1.96 * std_error
                
            future_values.append(forecast_value)
            lower_bounds.append(lower_bound)
            upper_bounds.append(upper_bound)
        
        fc_df = pd.DataFrame({
            'ds': future_dates,
            'yhat': future_values,
            'yhat_lower': lower_bounds,
            'yhat_upper': upper_bounds
        })
        
        # 월별로 결과 변환
        fc_df_monthly = pd.DataFrame({
            'ds': pd.date_range(start=monthly_df.index[0], end=future_dates[-1], freq='M'),
        })
        
        # 학습 데이터 기간의 결과 추가
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat'] = monthly_df['price'].values
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_lower'] = monthly_df['price'].values
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_upper'] = monthly_df['price'].values
        
        # 예측 기간의 결과 추가
        fc_df_monthly.loc[len(monthly_df):, 'yhat'] = fc_df['yhat'].values
        fc_df_monthly.loc[len(monthly_df):, 'yhat_lower'] = fc_df['yhat_lower'].values
        fc_df_monthly.loc[len(monthly_df):, 'yhat_upper'] = fc_df['yhat_upper'].values
        
        # yearly, trend 컴포넌트 추가 (Prophet 호환)
        fc_df_monthly['yearly'] = fc_df_monthly['yhat']
        fc_df_monthly['trend'] = 0
        
        return fc_df_monthly
    
    except Exception as e:
        st.error(f"Seasonal Naive 모델 오류: {str(e)}")
        return None

def fit_fourier_lr(df, horizon_end):
    """Fourier + 선형 회귀 모델 구현"""
    from sklearn.linear_model import LinearRegression
    
    # 월별 데이터 준비
    monthly_df = prepare_monthly_data(df)
    
    try:
        # 시간 변수 생성
        y = monthly_df['price'].values
        t = np.arange(len(y))
        
        # Fourier 특성 생성 (연간 계절성)
        p = 12  # 주기 (1년)
        X = np.column_stack([
            t,  # 선형 추세
            np.sin(2 * np.pi * t / p),
            np.cos(2 * np.pi * t / p),
            np.sin(4 * np.pi * t / p),
            np.cos(4 * np.pi * t / p)
        ])
        
        # 모델 학습
        model = LinearRegression()
        model.fit(X, y)
        
        # 예측 기간 계산
        last_date = monthly_df.index[-1]
        end_date = pd.Timestamp(horizon_end)
        periods = (end_date.year - last_date.year) * 12 + (end_date.month - last_date.month)
        
        # 예측 수행
        future_dates = pd.date_range(start=last_date + pd.DateOffset(months=1), periods=periods, freq='M')
        
        # 미래 시점 특성 생성
        t_future = np.arange(len(y), len(y) + periods)
        X_future = np.column_stack([
            t_future,
            np.sin(2 * np.pi * t_future / p),
            np.cos(2 * np.pi * t_future / p),
            np.sin(4 * np.pi * t_future / p),
            np.cos(4 * np.pi * t_future / p)
        ])
        
        # 예측
        forecast = model.predict(X_future)
        
        # 신뢰 구간 추정
        y_pred = model.predict(X)
        mse = np.mean((y - y_pred) ** 2)
        std_error = np.sqrt(mse)
        
        lower_bound = forecast - 1.96 * std_error
        upper_bound = forecast + 1.96 * std_error
        
        fc_df = pd.DataFrame({
            'ds': future_dates,
            'yhat': forecast,
            'yhat_lower': lower_bound,
            'yhat_upper': upper_bound
        })
        
        # 월별로 결과 변환
        fc_df_monthly = pd.DataFrame({
            'ds': pd.date_range(start=monthly_df.index[0], end=future_dates[-1], freq='M'),
        })
        
        # 학습 데이터 기간의 결과 추가
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat'] = monthly_df['price'].values
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_lower'] = monthly_df['price'].values
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_upper'] = monthly_df['price'].values
        
        # 예측 기간의 결과 추가
        fc_df_monthly.loc[len(monthly_df):, 'yhat'] = fc_df['yhat'].values
        fc_df_monthly.loc[len(monthly_df):, 'yhat_lower'] = fc_df['yhat_lower'].values
        fc_df_monthly.loc[len(monthly_df):, 'yhat_upper'] = fc_df['yhat_upper'].values
        
        # yearly, trend 컴포넌트 추가 (Prophet 호환)
        fc_df_monthly['trend'] = model.coef_[0] * np.arange(len(fc_df_monthly)) + model.intercept_
        
        # 계절성 계산
        season_features = np.column_stack([
            np.sin(2 * np.pi * np.arange(len(fc_df_monthly)) / p),
            np.cos(2 * np.pi * np.arange(len(fc_df_monthly)) / p),
            np.sin(4 * np.pi * np.arange(len(fc_df_monthly)) / p),
            np.cos(4 * np.pi * np.arange(len(fc_df_monthly)) / p)
        ])
        
        seasonal_effect = np.dot(season_features, model.coef_[1:5])
        fc_df_monthly['yearly'] = seasonal_effect
        
        return fc_df_monthly
    
    except Exception as e:
        st.error(f"Fourier + LR 모델 오류: {str(e)}")
        return None

def fit_linear_trend(df, horizon_end):
    """선형 추세 모델 구현"""
    from sklearn.linear_model import LinearRegression
    
    # 월별 데이터 준비
    monthly_df = prepare_monthly_data(df)
    
    try:
        # 시간 변수 생성
        y = monthly_df['price'].values
        t = np.arange(len(y)).reshape(-1, 1)
        
        # 모델 학습
        model = LinearRegression()
        model.fit(t, y)
        
        # 예측 기간 계산
        last_date = monthly_df.index[-1]
        end_date = pd.Timestamp(horizon_end)
        periods = (end_date.year - last_date.year) * 12 + (end_date.month - last_date.month)
        
        # 예측 수행
        future_dates = pd.date_range(start=last_date + pd.DateOffset(months=1), periods=periods, freq='M')
        t_future = np.arange(len(y), len(y) + periods).reshape(-1, 1)
        forecast = model.predict(t_future)
        
        # 신뢰 구간 추정
        y_pred = model.predict(t)
        mse = np.mean((y - y_pred) ** 2)
        std_error = np.sqrt(mse)
        
        lower_bound = forecast - 1.96 * std_error
        upper_bound = forecast + 1.96 * std_error
        
        fc_df = pd.DataFrame({
            'ds': future_dates,
            'yhat': forecast,
            'yhat_lower': lower_bound,
            'yhat_upper': upper_bound
        })
        
        # 월별로 결과 변환
        fc_df_monthly = pd.DataFrame({
            'ds': pd.date_range(start=monthly_df.index[0], end=future_dates[-1], freq='M'),
        })
        
        # 학습 데이터 기간의 결과 추가
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat'] = monthly_df['price'].values
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_lower'] = monthly_df['price'].values
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_upper'] = monthly_df['price'].values
        
        # 예측 기간의 결과 추가
        fc_df_monthly.loc[len(monthly_df):, 'yhat'] = fc_df['yhat'].values
        fc_df_monthly.loc[len(monthly_df):, 'yhat_lower'] = fc_df['yhat_lower'].values
        fc_df_monthly.loc[len(monthly_df):, 'yhat_upper'] = fc_df['yhat_upper'].values
        
        # yearly, trend 컴포넌트 추가 (Prophet 호환)
        fc_df_monthly['yearly'] = 0
        fc_df_monthly['trend'] = fc_df_monthly['yhat']
        
        return fc_df_monthly
    
    except Exception as e:
        st.error(f"Linear Trend 모델 오류: {str(e)}")
        return None

def fit_simple_exp_smoothing(df, horizon_end):
    """단순 지수 평활 모델 구현"""
    # 월별 데이터 준비
    monthly_df = prepare_monthly_data(df)
    
    try:
        # 모델 학습
        model = SimpleExpSmoothing(monthly_df['price'])
        results = model.fit(optimized=True)
        
        # 예측 기간 계산
        last_date = monthly_df.index[-1]
        end_date = pd.Timestamp(horizon_end)
        periods = (end_date.year - last_date.year) * 12 + (end_date.month - last_date.month)
        
        # 예측 수행
        forecast = results.forecast(periods)
        
        # 신뢰 구간 추정
        std_error = np.std(results.resid)
        lower_bound = forecast - 1.96 * std_error
        upper_bound = forecast + 1.96 * std_error
        
        # Prophet 형식으로 결과 변환
        future_dates = pd.date_range(start=last_date + pd.DateOffset(months=1), periods=periods, freq='M')
        
        fc_df = pd.DataFrame({
            'ds': future_dates,
            'yhat': forecast.values,
            'yhat_lower': lower_bound.values,
            'yhat_upper': upper_bound.values
        })
        
        # 월별로 결과 변환
        fc_df_monthly = pd.DataFrame({
            'ds': pd.date_range(start=monthly_df.index[0], end=future_dates[-1], freq='M'),
        })
        
        # 학습 데이터 기간의 결과 추가
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat'] = monthly_df['price'].values
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_lower'] = monthly_df['price'].values
        fc_df_monthly.loc[:len(monthly_df)-1, 'yhat_upper'] = monthly_df['price'].values
        
        # 예측 기간의 결과 추가
        fc_df_monthly.loc[len(monthly_df):, 'yhat'] = fc_df['yhat'].values
        fc_df_monthly.loc[len(monthly_df):, 'yhat_lower'] = fc_df['yhat_lower'].values
        fc_df_monthly.loc[len(monthly_df):, 'yhat_upper'] = fc_df['yhat_upper'].values
        
        # yearly, trend 컴포넌트 추가 (Prophet 호환)
        fc_df_monthly['yearly'] = 0
        fc_df_monthly['trend'] = fc_df_monthly['yhat']
        
        return fc_df_monthly
    
    except Exception as e:
        st.error(f"Simple Exponential Smoothing 모델 오류: {str(e)}")
        return None

@st.cache_data(show_spinner=False, ttl=3600)
def fit_optimal_model(df, item_name, horizon_end, model_type="primary"):
    """품목별 최적 모델 적용"""
    # 데이터 준비 및 정리
    df = df.copy()
    df = df.dropna(subset=["date", "price"])
    
    # 품목별 최적 모델 선택
    model_info = get_best_model_for_item(item_name)
    
    if model_type == "primary":
        model_name = model_info["model1"]
        accuracy = model_info["accuracy1"]
    else:  # backup
        model_name = model_info["model2"]
        accuracy = model_info["accuracy2"]
    
    st.info(f"{item_name}에 최적화된 {model_name} 모델 적용 (정확도: {accuracy}%)")
    
    # 특수 처리가 필요한 품목 확인
    needs_monitoring = "special" in model_info and model_info["special"] == "accuracy_drop"
    if needs_monitoring:
        st.warning(f"⚠️ {item_name}는 특정 월에 정확도가 급락할 수 있는 품목입니다. 예측 결과를 주의 깊게 살펴보세요.")
    
    # 모델 선택 및 학습
    if "SARIMA(1,0,1)(1,0,1,12)" in model_name:
        return fit_sarima(df, order=(1,0,1), seasonal_order=(1,0,1,12), horizon_end=horizon_end)
    elif "SARIMA(1,1,1)(1,1,1,12)" in model_name:
        return fit_sarima(df, order=(1,1,1), seasonal_order=(1,1,1,12), horizon_end=horizon_end)
    elif "SARIMA(0,1,1)(0,1,1,12)" in model_name:
        return fit_sarima(df, order=(0,1,1), seasonal_order=(0,1,1,12), horizon_end=horizon_end)
    elif "ETS(Multiplicative)" in model_name:
        return fit_ets(df, seasonal_type="multiplicative", horizon_end=horizon_end)
    elif "ETS(Additive)" in model_name:
        return fit_ets(df, seasonal_type="additive", horizon_end=horizon_end)
    elif "Holt-Winters" in model_name:
        return fit_holt_winters(df, horizon_end=horizon_end)
    elif "Holt" in model_name:
        return fit_holt(df, horizon_end=horizon_end)
    elif "MovingAverage-6 m" in model_name:
        return fit_moving_average(df, window=6, horizon_end=horizon_end)
    elif "WeightedMA-6 m" in model_name:
        return fit_weighted_ma(df, window=6, horizon_end=horizon_end)
    elif "Naive" in model_name and "Seasonal" not in model_name:
        return fit_naive(df, horizon_end=horizon_end)
    elif "SeasonalNaive" in model_name:
        return fit_seasonal_naive(df, horizon_end=horizon_end)
    elif "Fourier + LR" in model_name:
        return fit_fourier_lr(df, horizon_end=horizon_end)
    elif "LinearTrend" in model_name:
        return fit_linear_trend(df, horizon_end=horizon_end)
    elif "SimpleExpSmoothing" in model_name:
        return fit_simple_exp_smoothing(df, horizon_end=horizon_end)
    else:
        st.warning(f"알 수 없는 모델: {model_name}. 기본 모델(SARIMA)을 사용합니다.")
        return fit_sarima(df, order=(1,0,1), seasonal_order=(1,0,1,12), horizon_end=horizon_end)

def fit_ensemble_model(df, item_name, horizon_end):
    """1위와 2위 모델의 앙상블 수행"""
    # 1위 모델 예측
    fc1 = fit_optimal_model(df, item_name, horizon_end, model_type="primary")
    
    # 2위 모델 예측
    fc2 = fit_optimal_model(df, item_name, horizon_end, model_type="backup")
    
    # 두 모델 모두 성공한 경우만 앙상블
    if fc1 is not None and fc2 is not None:
        # 앙상블 가중치 계산 (정확도 기반)
        model_info = get_best_model_for_item(item_name)
        acc1 = model_info["accuracy1"]
        acc2 = model_info["accuracy2"]
        
        # 정확도 차이가 0.2%p 이내인 경우 앙상블 수행
        accuracy_diff = abs(acc1 - acc2)
        
        if accuracy_diff <= 0.2:
            st.success(f"두 모델의 정확도 차이가 {accuracy_diff:.2f}%p로 작아 앙상블을 수행합니다.")
            
            # 정확도 기반 가중치 계산
            total_acc = acc1 + acc2
            w1 = acc1 / total_acc
            w2 = acc2 / total_acc
            
            # 앙상블 결과 생성
            fc_ensemble = fc1.copy()
            fc_ensemble['yhat'] = w1 * fc1['yhat'] + w2 * fc2['yhat']
            fc_ensemble['yhat_lower'] = w1 * fc1['yhat_lower'] + w2 * fc2['yhat_lower']
            fc_ensemble['yhat_upper'] = w1 * fc1['yhat_upper'] + w2 * fc2['yhat_upper']
            
            return fc_ensemble
        else:
            st.info(f"정확도 차이가 {accuracy_diff:.2f}%p로 커서 1위 모델만 사용합니다.")
            return fc1
    
    # 하나라도 실패한 경우 성공한 모델 반환
    return fc1 if fc1 is not None else fc2

# -------------------------------------------------
# MAIN APP ---------------------------------------
# -------------------------------------------------
# 데이터 로드
raw_df = load_data()

if len(raw_df) == 0:
    st.error("데이터가 비어 있습니다. 파일을 확인해주세요.")
    st.stop()

st.sidebar.header("🔍 품목 선택")
selected_item = st.sidebar.selectbox("품목", get_items(raw_df))
current_date = date.today()
st.sidebar.caption(f"오늘: {current_date}")

# 선택된 품목의 최적 모델 정보 표시
model_info = get_best_model_for_item(selected_item)
st.sidebar.subheader("품목별 최적 모델")
st.sidebar.markdown(f"**1위 모델:** {model_info['model1']} (정확도: {model_info['accuracy1']}%)")
st.sidebar.markdown(f"**2위 모델:** {model_info['model2']} (정확도: {model_info['accuracy2']}%)")

# 데이터 필터링
item_df = raw_df.query("item == @selected_item").copy()
if item_df.empty:
    st.error("선택한 품목 데이터 없음")
    st.stop()
    
# 데이터 수 검사
if len(item_df) < 2:
    st.warning(f"선택한 품목 '{selected_item}' 데이터가 너무 적습니다 (데이터 수: {len(item_df)}). 예측이 부정확할 수 있습니다.")
else:
    st.success(f"선택한 품목 '{selected_item}'에 대해 {len(item_df)}개의 데이터가 있습니다.")

# -------------------------------------------------
# MACRO FORECAST 1996‑2030 ------------------------
# -------------------------------------------------
# -------------------------------------------------
# MACRO FORECAST 1996‑2030 ------------------------
# -------------------------------------------------
st.header(f"📈 {selected_item} 가격 예측 대시보드")

# 데이터 필터링 로직
try:
    macro_start_dt = pd.Timestamp("1996-01-01")
    # 데이터의 시작일이 1996년 이후인지 확인
    if item_df["date"].min() > macro_start_dt:
        macro_start_dt = item_df["date"].min()
    
    macro_df = item_df[item_df["date"] >= macro_start_dt].copy()
except Exception as e:
    st.error(f"날짜 필터링 오류: {str(e)}")
    macro_df = item_df.copy()  # 필터링 없이 전체 데이터 사용

# Add diagnostic info
with st.expander("데이터 진단"):
    st.write(f"- 전체 데이터 수: {len(item_df)}")
    st.write(f"- 분석 데이터 수: {len(macro_df)}")
    if len(macro_df) > 0:
        st.write(f"- 기간: {macro_df['date'].min().strftime('%Y-%m-%d')} ~ {macro_df['date'].max().strftime('%Y-%m-%d')}")
        st.dataframe(macro_df.head())
    else:
        st.write("데이터가 없습니다.")

if len(macro_df) < 2:
    st.warning(f"{selected_item}에 대한 데이터가 충분하지 않습니다. 전체 기간 데이터를 표시합니다.")
    fig = go.Figure()
    fig.add_trace(go.Scatter(x=item_df["date"], y=item_df["price"], mode="lines", name="실제 가격"))
    fig.update_layout(title=f"{selected_item} 과거 가격")
    st.plotly_chart(fig, use_container_width=True)
else:
    try:
        # 데이터 충분한 경우 품목별 최적 모델 사용
        use_ensemble = st.checkbox("앙상블 모델 사용 (1위 + 2위 모델 결합)", value=False)
        
        with st.spinner("장기 예측 모델 생성 중..."):
            if use_ensemble:
                fc_macro = fit_ensemble_model(macro_df, selected_item, MACRO_END)
            else:
                fc_macro = fit_optimal_model(macro_df, selected_item, MACRO_END)
        
        if fc_macro is not None:
            # 실제 데이터와 예측 데이터 구분
            cutoff_date = pd.Timestamp("2025-01-01")
            
            # 플롯 생성
            fig = go.Figure()
            
            # 실제 데이터 추가 (1996-2024)
            historical_data = macro_df[macro_df["date"] < cutoff_date].copy()
            if not historical_data.empty:
                fig.add_trace(go.Scatter(
                    x=historical_data["date"], 
                    y=historical_data["price"],
                    mode="lines",
                    name="실제 가격 (1996-2024)",
                    line=dict(color="blue", width=2)
                ))
            
            # 예측 기간 자르기
            forecast_data = fc_macro[fc_macro["ds"] >= cutoff_date].copy()
            
            # 2025-2030 예측 데이터
            if not forecast_data.empty:
                fig.add_trace(go.Scatter(
                    x=forecast_data["ds"], 
                    y=forecast_data["yhat"],
                    mode="lines",
                    name="예측 가격 (2025-2030)",
                    line=dict(color="red", width=2, dash="dash")
                ))
                
                # 신뢰 구간 추가
                fig.add_trace(go.Scatter(
                    x=forecast_data["ds"],
                    y=forecast_data["yhat_upper"],
                    mode="lines",
                    line=dict(width=0),
                    showlegend=False
                ))
                fig.add_trace(go.Scatter(
                    x=forecast_data["ds"],
                    y=forecast_data["yhat_lower"],
                    mode="lines",
                    line=dict(width=0),
                    fill="tonexty",
                    fillcolor="rgba(255, 0, 0, 0.1)",
                    name="95% 신뢰 구간"
                ))
            
            # 음수 예측값 제거
            fig.update_yaxes(range=[0, None])
            
            # 레이아웃 설정
            fig.update_layout(
                title=f"{selected_item} 장기 가격 예측 (1996-2030)",
                xaxis_title="연도",
                yaxis_title="가격 (원)",
                legend=dict(
                    orientation="h",
                    yanchor="bottom",
                    y=1.02,
                    xanchor="right",
                    x=1
                )
            )
            
            # 차트 표시
            st.plotly_chart(fig, use_container_width=True)
            
            # 연도별 예측가 표시
            try:
                latest_price = macro_df.iloc[-1]["price"]
                
                # 연도별 예측가 계산을 위한 함수
                def get_yearly_prediction(year_end):
                    target_date = pd.Timestamp(f"{year_end}-12-31")
                    # 날짜 기반으로 가장 가까운 날짜의 예측값 찾기
                    date_diffs = abs(fc_macro["ds"] - target_date)
                    closest_idx = date_diffs.idxmin()
                    pred_value = fc_macro.loc[closest_idx, "yhat"]
                    pct_change = (pred_value - latest_price) / latest_price * 100
                    return pred_value, pct_change
                
                # 연도별 예측가 표시
                col1, col2, col3 = st.columns(3)
                
                # 2025년 예측가
                pred_2025, pct_2025 = get_yearly_prediction(2025)
                col1.metric("2025년 예측가", format_currency(pred_2025), f"{pct_2025:+.1f}%")
                
                # 2027년 예측가
                pred_2027, pct_2027 = get_yearly_prediction(2027)
                col2.metric("2027년 예측가", format_currency(pred_2027), f"{pct_2027:+.1f}%")
                
                # 2030년 예측가
                pred_2030, pct_2030 = get_yearly_prediction(2030)
                col3.metric("2030년 예측가", format_currency(pred_2030), f"{pct_2030:+.1f}%")
                
                # 추가 연도 예측가 (확장 가능)
                with st.expander("더 많은 연도별 예측가 보기"):
                    col4, col5, col6 = st.columns(3)
                    
                    # 2026년 예측가
                    pred_2026, pct_2026 = get_yearly_prediction(2026)
                    col4.metric("2026년 예측가", format_currency(pred_2026), f"{pct_2026:+.1f}%")
                    
                    # 2028년 예측가
                    pred_2028, pct_2028 = get_yearly_prediction(2028)
                    col5.metric("2028년 예측가", format_currency(pred_2028), f"{pct_2028:+.1f}%")
                    
                    # 2029년 예측가
                    pred_2029, pct_2029 = get_yearly_prediction(2029)
                    col6.metric("2029년 예측가", format_currency(pred_2029), f"{pct_2029:+.1f}%")
                    
            except Exception as e:
                st.error(f"예측가 계산 오류: {str(e)}")
        else:
            st.warning("예측 모델을 생성할 수 없습니다.")
            fig = go.Figure()
            fig.add_trace(go.Scatter(x=macro_df["date"], y=macro_df["price"], mode="lines", name="실제 가격"))
            fig.update_layout(title=f"{selected_item} 과거 가격")
            st.plotly_chart(fig, use_container_width=True)
    except Exception as e:
        st.error(f"장기 예측 오류 발생: {str(e)}")
        import traceback
        st.code(traceback.format_exc())
        fig = go.Figure()
        fig.add_trace(go.Scatter(x=macro_df["date"], y=macro_df["price"], mode="lines", name="실제 가격"))
        fig.update_layout(title=f"{selected_item} 과거 가격")
        st.plotly_chart(fig, use_container_width=True)

# -------------------------------------------------
# MICRO FORECAST 2024‑2026 ------------------------
# -------------------------------------------------
# -------------------------------------------------
# MICRO FORECAST 2024‑2026 ------------------------
# -------------------------------------------------
st.subheader("🔎 2024–2026 단기 예측 (월별)")

# 데이터 필터링 - 최근 3년 데이터 활용
try:
    three_years_ago = pd.Timestamp("2021-01-01")
    if item_df["date"].min() > three_years_ago:
        three_years_ago = item_df["date"].min()
    
    micro_df = item_df[item_df["date"] >= three_years_ago].copy()
except Exception as e:
    st.error(f"단기 예측 데이터 필터링 오류: {str(e)}")
    # 최근 데이터 사용
    micro_df = item_df.sort_values("date").tail(24).copy()

if len(micro_df) < 2:
    st.warning(f"최근 데이터가 충분하지 않습니다.")
    fig = go.Figure()
    fig.add_trace(go.Scatter(x=item_df["date"], y=item_df["price"], mode="lines", name="실제 가격"))
    fig.update_layout(title=f"{selected_item} 최근 가격")
    st.plotly_chart(fig, use_container_width=True)
else:
    try:
        with st.spinner("단기 예측 모델 생성 중..."):
            if use_ensemble:
                fc_micro = fit_ensemble_model(micro_df, selected_item, MICRO_END)
            else:
                fc_micro = fit_optimal_model(micro_df, selected_item, MICRO_END)
            
        if fc_micro is not None:
            # 2024-01-01부터 2026-12-31까지 필터링
            start_date = pd.Timestamp("2024-01-01")
            end_date = pd.Timestamp("2026-12-31")
            
            # 월별 데이터 준비
            monthly_historical = micro_df.copy()
            monthly_historical["year_month"] = monthly_historical["date"].dt.strftime("%Y-%m")
            monthly_historical = monthly_historical.groupby("year_month").agg({
                "date": "first", 
                "price": "mean"
            }).reset_index(drop=True)
            
            monthly_historical = monthly_historical[
                (monthly_historical["date"] >= start_date) & 
                (monthly_historical["date"] <= end_date)
            ]
            
            monthly_forecast = fc_micro[
                (fc_micro["ds"] >= start_date) & 
                (fc_micro["ds"] <= end_date)
            ].copy()
            
            # 월별 차트 생성
            fig = go.Figure()
            
            # 2024년 실제 데이터
            actual_2024 = monthly_historical[
                (monthly_historical["date"] >= pd.Timestamp("2024-01-01")) & 
                (monthly_historical["date"] <= pd.Timestamp("2024-12-31"))
            ]
            
            if not actual_2024.empty:
                fig.add_trace(go.Scatter(
                    x=actual_2024["date"],
                    y=actual_2024["price"],
                    mode="lines+markers",
                    name="2024 실제 가격",
                    line=dict(color="blue", width=2),
                    marker=dict(size=8)
                ))
            
            # 2024년 이후 예측 데이터
            cutoff = pd.Timestamp("2024-12-31")
            future_data = monthly_forecast[monthly_forecast["ds"] > cutoff]
            
            if not future_data.empty:
                fig.add_trace(go.Scatter(
                    x=future_data["ds"],
                    y=future_data["yhat"],
                    mode="lines+markers",
                    name="2025-2026 예측 가격",
                    line=dict(color="red", width=2, dash="dash"),
                    marker=dict(size=8)
                ))
                
                # 신뢰 구간 추가
                fig.add_trace(go.Scatter(
                    x=future_data["ds"],
                    y=future_data["yhat_upper"],
                    mode="lines",
                    line=dict(width=0),
                    showlegend=False
                ))
                fig.add_trace(go.Scatter(
                    x=future_data["ds"],
                    y=future_data["yhat_lower"],
                    mode="lines",
                    line=dict(width=0),
                    fill="tonexty",
                    fillcolor="rgba(255, 0, 0, 0.1)",
                    name="95% 신뢰 구간"
                ))
            
            # 음수 예측값 제거
            fig.update_yaxes(range=[0, None])
            
            # 레이아웃 설정
            fig.update_layout(
                title=f"{selected_item} 월별 단기 예측 (2024-2026)",
                xaxis_title="월",
                yaxis_title="가격 (원)",
                xaxis=dict(
                    tickformat="%Y-%m",
                    dtick="M3",  # 3개월 간격
                    tickangle=45
                ),
                legend=dict(
                    orientation="h",
                    yanchor="bottom",
                    y=1.02,
                    xanchor="right",
                    x=1
                )
            )
            
            # 차트 표시
            st.plotly_chart(fig, use_container_width=True)
            
            # 월별 예측 가격 표시 (2025-2026)
            with st.expander("월별 예측 가격 상세보기"):
                monthly_detail = monthly_forecast[monthly_forecast["ds"] > cutoff].copy()
                monthly_detail["날짜"] = monthly_detail["ds"].dt.strftime("%Y년 %m월")
                monthly_detail["예측가격"] = monthly_detail["yhat"].apply(format_currency)
                monthly_detail["하한값"] = monthly_detail["yhat_lower"].apply(format_currency)
                monthly_detail["상한값"] = monthly_detail["yhat_upper"].apply(format_currency)
                
                st.dataframe(
                    monthly_detail[["날짜", "예측가격", "하한값", "상한값"]], 
                    hide_index=True
                )
            
            # 월별/연도별 예측가 표시 함수
            def get_monthly_prediction(year, month):
                target_date = pd.Timestamp(f"{year}-{month:02d}-01")
                # 가장 가까운 날짜의 예측값 찾기
                date_diffs = abs(monthly_forecast["ds"] - target_date)
                closest_idx = date_diffs.idxmin()
                
                if closest_idx in monthly_forecast.index:
                    pred_value = monthly_forecast.loc[closest_idx, "yhat"]
                    
                    # 현재 가격 기준 변화율 계산
                    latest_price = monthly_historical.iloc[-1]["price"] if not monthly_historical.empty else micro_df.iloc[-1]["price"]
                    pct_change = (pred_value - latest_price) / latest_price * 100
                    
                    return pred_value, pct_change
                else:
                    return None, None
            
            # 2025년과 2026년의 주요 월별 예측가
            st.subheader("주요 월별 예측가")
            
            col1, col2, col3 = st.columns(3)
            
            # 2025년 6월 예측가
            pred_2025_06, pct_2025_06 = get_monthly_prediction(2025, 6)
            if pred_2025_06 is not None:
                col1.metric("2025년 6월", format_currency(pred_2025_06), f"{pct_2025_06:+.1f}%")
            else:
                col1.metric("2025년 6월", "데이터 없음", "0%")
            
            # 2025년 12월 예측가
            pred_2025_12, pct_2025_12 = get_monthly_prediction(2025, 12)
            if pred_2025_12 is not None:
                col2.metric("2025년 12월", format_currency(pred_2025_12), f"{pct_2025_12:+.1f}%")
            else:
                col2.metric("2025년 12월", "데이터 없음", "0%")
            
            # 2026년 12월 예측가
            pred_2026_12, pct_2026_12 = get_monthly_prediction(2026, 12)
            if pred_2026_12 is not None:
                col3.metric("2026년 12월", format_currency(pred_2026_12), f"{pct_2026_12:+.1f}%")
            else:
                col3.metric("2026년 12월", "데이터 없음", "0%")
            
            # 농산물 계절성에 맞는 추가 월별 데이터 표시
            with st.expander("더 많은 월별 예측가 보기"):
                # 분기별로 나눠서 표시
                for year in [2025, 2026]:
                    st.write(f"### {year}년 분기별 예측가")
                    q1, q2, q3, q4 = st.columns(4)
                    
                    # 1분기 (3월)
                    pred_q1, pct_q1 = get_monthly_prediction(year, 3)
                    if pred_q1 is not None:
                        q1.metric(f"{year}년 3월", format_currency(pred_q1), f"{pct_q1:+.1f}%")
                    else:
                        q1.metric(f"{year}년 3월", "데이터 없음", "0%")
                    
                    # 2분기 (6월)
                    pred_q2, pct_q2 = get_monthly_prediction(year, 6)
                    if pred_q2 is not None:
                        q2.metric(f"{year}년 6월", format_currency(pred_q2), f"{pct_q2:+.1f}%")
                    else:
                        q2.metric(f"{year}년 6월", "데이터 없음", "0%")
                    
                    # 3분기 (9월)
                    pred_q3, pct_q3 = get_monthly_prediction(year, 9)
                    if pred_q3 is not None:
                        q3.metric(f"{year}년 9월", format_currency(pred_q3), f"{pct_q3:+.1f}%")
                    else:
                        q3.metric(f"{year}년 9월", "데이터 없음", "0%")
                    
                    # 4분기 (12월)
                    pred_q4, pct_q4 = get_monthly_prediction(year, 12)
                    if pred_q4 is not None:
                        q4.metric(f"{year}년 12월", format_currency(pred_q4), f"{pct_q4:+.1f}%")
                    else:
                        q4.metric(f"{year}년 12월", "데이터 없음", "0%")
            
        else:
            st.warning("단기 예측 모델을 생성할 수 없습니다.")
    except Exception as e:
        st.error(f"단기 예측 오류: {str(e)}")
        st.code(traceback.format_exc())

# -------------------------------------------------
# SEASONALITY & PATTERN ---------------------------
# -------------------------------------------------
if 'fc_micro' in locals() and fc_micro is not None:
    with st.expander("📆 시즈널리티 & 패턴 설명"):
        try:
            # 월별 계절성 분석
            if "yearly" in fc_micro.columns and fc_micro["yearly"].sum() != 0:
                month_season = fc_micro.copy()
                month_season["month"] = month_season["ds"].dt.month
                month_seasonality = month_season.groupby("month")["yearly"].mean()
                
                # 월 이름 설정
                month_names = ["1월", "2월", "3월", "4월", "5월", "6월", "7월", "8월", "9월", "10월", "11월", "12월"]
                
                # 계절성 차트 그리기
                fig = go.Figure()
                fig.add_trace(go.Bar(
                    x=month_names,
                    y=month_seasonality.values,
                    marker_color=['blue' if x >= 0 else 'red' for x in month_seasonality.values]
                ))
                
                fig.update_layout(
                    title=f"{selected_item} 월별 계절성 패턴",
                    xaxis_title="월",
                    yaxis_title="상대적 가격 변동",
                )
                
                st.plotly_chart(fig, use_container_width=True)
                
                # 피크와 저점 계산
                peak_month = month_seasonality.idxmax()
                low_month = month_seasonality.idxmin()
                seasonality_range = month_seasonality.max() - month_seasonality.min()
                
                st.markdown(
                    f"**연간 피크 월:** {month_names[peak_month-1]}  \n"
                    f"**연간 저점 월:** {month_names[low_month-1]}  \n"
                    f"**연간 변동폭:** {seasonality_range:.1f}")
                
                # 계절성이 높은 품목인지 설명
                if abs(seasonality_range) > 30:
                    st.info(f"{selected_item}은(는) 계절성이 매우 강한 품목입니다. 특정 달에 가격이 크게 변동할 수 있습니다.")
                elif abs(seasonality_range) > 10:
                    st.info(f"{selected_item}은(는) 계절성이 중간 정도인 품목입니다.")
                else:
                    st.info(f"{selected_item}은(는) 계절성이 약한 품목입니다. 연중 가격이 비교적 안정적입니다.")
        except Exception as e:
            st.error(f"계절성 분석 오류: {str(e)}")
            st.info("이 품목에 대한 계절성 패턴을 분석할 수 없습니다.")

# -------------------------------------------------
# FOOTER ------------------------------------------
# -------------------------------------------------
st.markdown("---")
st.caption("© 2025 품목별 가격 예측 시스템 | 데이터 분석 자동화")