app.py

import streamlit as st
import pandas as pd
import numpy as np
from pptx import Presentation
from pptx.enum.shapes import MSO_SHAPE_TYPE
import re
import io
import time
import plotly.express as px
import plotly.graph_objects as go
from plotly.subplots import make_subplots


# CSS 스타일 정의
def local_css():
    st.markdown(
        """
        <style>
        .main .block-container {
            max-width: 1200px;  # 최대 너비 설정
            padding: 1rem 2rem;  # 좌우 여백 추가
            margin: 0 auto;     # 중앙 정렬
        }
        
        # 기존 CSS 스타일 유지
        .sidebar-option {
            padding: 10px 15px;
            margin: 5px 0;
            border-radius: 5px;
            cursor: pointer;
            transition: background-color 0.3s;
        }
        .sidebar-option:hover {
            background-color: #ff4b4b20;
        }
        .sidebar-option.selected {
            background-color: #ff4b4b;
            color: white;
        }
        div[data-testid="stSidebar"] ul {
            padding-left: 0;
        }
        .stProgress .st-bo {
            background-color: #ff4b4b;
        }
        button[kind="secondary"] {
            background-color: transparent;
            color: #ff4b4b;
            border: 1px solid #ff4b4b;
        }
        button[kind="secondary"]:hover {
            border-color: #ff2b2b;
            color: #ff2b2b;
        }
        div.stButton > button:first-child {
            width: 100%;
            margin-bottom: 10px;
        }
        .custom-subheader {
            font-size: 1.2rem;
            color: #0068c9;
            margin-bottom: 1rem;
        }
        </style>
    """,
        unsafe_allow_html=True,
    )


# 사이드바 메뉴 생성
def sidebar_menu():
    """사이드바 메뉴 생성 및 상태 관리"""
    st.sidebar.title("메뉴")

    menu_options = ["1) 데일리 서베이 통합", "2) 데일리 서베이 통계", "3) PPT 주요응답 추출"]

    # 세션 상태 초기화
    if "current_menu" not in st.session_state:
        st.session_state.current_menu = menu_options[0]

    # 각 메뉴 옵션에 대한 버튼 생성
    for option in menu_options:
        button_style = (
            "secondary" if st.session_state.current_menu != option else "primary"
        )

        if st.sidebar.button(
            option,
            key=f"btn_{option}",
            help=f"{option} 페이지로 이동",
            use_container_width=True,
            type=button_style,
        ):
            st.session_state.current_menu = option
            st.rerun()

    return st.session_state.current_menu


# 파일 읽기 함수
def read_uploaded_file(uploaded_file, show_success=False):
    """향상된 파일 읽기 함수"""
    try:
        # 파일 객체 검증
        if uploaded_file is None:
            return None

        # 파일 크기 확인 (1GB 제한)
        MAX_FILE_SIZE = 1024 * 1024 * 1024  # 1GB in bytes
        if uploaded_file.size > MAX_FILE_SIZE:
            st.error(f"파일 크기가 너무 큽니다. 최대 1GB까지 허용됩니다.")
            return None

        file_type = uploaded_file.name.split(".")[-1].lower()

        # 메모리 효율적인 파일 읽기
        if file_type == "csv":
            try:
                df = pd.read_csv(uploaded_file, low_memory=True)
            except Exception as e:
                st.error(f"CSV 파일 읽기 오류: {str(e)}")
                return None
        else:
            try:
                df = pd.read_excel(uploaded_file, engine="openpyxl")
            except Exception as e:
                st.error(f"Excel 파일 읽기 오류: {str(e)}")
                return None

        if show_success:
            st.success(f"파일 '{uploaded_file.name}' 로드 완료")
        return df

    except Exception as e:
        st.error(f"파일 처리 중 오류 발생: {str(e)}")
        return None


# 중복 키 확인 함수
def check_duplicates(df, key_columns, context=""):
    """데이터프레임의 중복 키 확인"""
    duplicates = df[df.duplicated(subset=key_columns, keep=False)]
    if not duplicates.empty:
        st.warning(f"{context}에서 중복 키가 발견되었습니다:")
        st.dataframe(duplicates[key_columns])
        return True
    return False


# 엑셀 다운로드 데이터 생성
def create_excel_download(df):
    """엑셀 다운로드용 데이터 생성"""
    output = io.BytesIO()
    with pd.ExcelWriter(output, engine="openpyxl") as writer:
        df.to_excel(writer, index=False)
    processed_data = output.getvalue()
    return processed_data


def clean_column_names(df):
    """컬럼명 정리"""
    clean_cols = {}
    for col in df.columns:
        # 앞쪽 번호와 점 제거
        clean_col = re.sub(r"^\d+\.\s*", "", str(col))
        clean_col = clean_col.strip()
        clean_cols[col] = clean_col
    return clean_cols


# 현재 변수 순서 표시 함수를 수정
def display_current_order():
    """변수 순서 표시 함수"""
    st.write("### 현재 변수 구성")

    # 현재 순서 가져오기 (임시 순서가 있으면 사용)
    current_order = (
        st.session_state.temp_column_order
        if "temp_column_order" in st.session_state
        else st.session_state.column_order
    )

    # 현재 그룹 순서에 따라 컬럼 배치
    if st.session_state.current_group_order[0] == "개인정보 변수":
        col1_title = "📋 개인정보 변수"
        col2_title = "📊 서베이 응답 변수"
        col1_cols = [
            c for c in current_order if c in st.session_state.personal_info_cols
        ]
        col2_cols = [
            c for c in current_order if c not in st.session_state.personal_info_cols
        ]
    else:
        col1_title = "📊 서베이 응답 변수"
        col2_title = "📋 개인정보 변수"
        col1_cols = [
            c for c in current_order if c not in st.session_state.personal_info_cols
        ]
        col2_cols = [
            c for c in current_order if c in st.session_state.personal_info_cols
        ]

    col1, col2 = st.columns(2)

    with col1:
        st.write(f"##### {col1_title}")
        for i, col in enumerate(col1_cols, 1):
            st.write(f"{i}. {col}")
        st.info(f"총 {len(col1_cols)}개 변수")

    with col2:
        st.write(f"##### {col2_title}")
        for i, col in enumerate(col2_cols, 1):
            st.write(f"{i}. {col}")
        st.info(f"총 {len(col2_cols)}개 변수")


# 데이터 미리보기 표시 함수
def display_data_preview():
    """데이터 미리보기 표시 함수"""
    st.write("### 데이터 미리보기")
    if st.session_state.combined_survey is not None:
        # 현재 컬럼 순서 사용 (temp_column_order가 있으면 우선 사용)
        current_columns = (
            st.session_state.temp_column_order
            if "temp_column_order" in st.session_state
            else st.session_state.final_column_order
            if "final_column_order" in st.session_state
            else st.session_state.column_order
        )
        st.dataframe(st.session_state.combined_survey[current_columns].head())


# 매칭 키 데이터 정리 함수 수정
def clean_matching_key(df, key_columns):
    """매칭 키 데이터 정리"""
    try:
        # 먼저 key_columns이 df에 있는지 확인
        missing_cols = [col for col in key_columns if col not in df.columns]
        if missing_cols:
            st.error(f"다음 컬럼이 데이터에 존재하지 않습니다: {', '.join(missing_cols)}")
            return None

        df_clean = df.copy()

        # 키 컬럼 데이터 정리
        for col in key_columns:
            # null 값 처리
            df_clean[col] = df_clean[col].fillna("")
            # 문자열로 변환
            df_clean[col] = df_clean[col].astype(str)
            # 공백 제거
            df_clean[col] = df_clean[col].str.strip()
            # 특수문자 제거
            df_clean[col] = df_clean[col].str.replace(r"[^\w\s]", "", regex=True)
            # 대소문자 통일
            df_clean[col] = df_clean[col].str.upper()

        return df_clean
    except Exception as e:
        st.error(f"키 데이터 정리 중 오류 발생: {str(e)}")
        return None


# 매칭 키 성 함수 수정
def create_match_key(df, key_columns):
    """매칭 키 생성"""
    try:
        # null 체크
        if df[key_columns].isnull().any().any():
            st.warning("매칭 키 컬럼에 누락 값이 있습니다.")

        # 키 컬럼들을 결합하여 하나의 매칭 키 생성
        return (
            df[key_columns].fillna("").astype(str).apply(lambda x: "_".join(x), axis=1)
        )
    except Exception as e:
        st.error(f"매칭 키 생성 중 오류 발생: {str(e)}")
        return None


def survey_integration():
    """데일리 서베이 통합 기능"""
    try:
        st.header("데일리 서베이 통합")

        # 세션 상태 초기화
        if "survey_files_processed" not in st.session_state:
            st.session_state.survey_files_processed = False
        if "combined_survey" not in st.session_state:
            st.session_state.combined_survey = None
        if "personal_info_cols" not in st.session_state:
            st.session_state.personal_info_cols = []
        if "first_df_columns" not in st.session_state:
            st.session_state.first_df_columns = None
        if "column_order" not in st.session_state:
            st.session_state.column_order = []
        if "final_column_order" not in st.session_state:
            st.session_state.final_column_order = []

        # 세션 상태 초기화 부분에 show_target_section 추가
        if "show_target_section" not in st.session_state:
            st.session_state.show_target_section = False

        # 1. 데일리 서베이 파일 통합
        st.markdown(
            '<p class="custom-subheader">Daily Survey File Upload</p>',
            unsafe_allow_html=True,
        )

        st.info("동일한 형식의 Daily Survey 파일을 일차별로 선택해주세요")

        survey_files = st.file_uploader(
            "데일리 서베이 파일들을 업로드하세요",
            type=["xlsx", "xls", "csv"],
            accept_multiple_files=True,
            key="survey_files_upload",
        )

        if survey_files:  # 파일이 업로드된 경우
            first_df = read_uploaded_file(survey_files[0])  # 첫 번째 파일 읽기

            if first_df is not None:
                # 첫번째 파일 데이터 미리보기
                st.write("### First Data Preview")
                st.dataframe(first_df.head())

                st.write("### 개인정보 컬럼 선택")

                # 컬럼 선택 상태 초기화
                if "temp_selected_cols" not in st.session_state:
                    st.session_state.temp_selected_cols = []

                col1, col2 = st.columns([3, 1])

                with col1:
                    st.info("질문을 제외하고 '반복되는 개인정보 컬럼'을 모두 선택해주세요.")
                    # 개인정보 컬럼 선택 UI
                    st.session_state.temp_selected_cols = st.multiselect(
                        "개인정보 컬럼 선택",
                        options=first_df.columns.tolist(),
                        default=st.session_state.personal_info_cols,
                        help="Ctrl(Cmd)키를 누른 채로 클릭하여 여러 컬럼을 한 번에 선택할 수 있습니다.",
                    )

                with col2:
                    st.write("")
                    st.write("")
                    if st.button("선택 완료", use_container_width=True):
                        if not st.session_state.temp_selected_cols:
                            st.error("최소 1개 이상의 개인정보 컬럼을 선택해주세요.")
                        else:
                            st.session_state.personal_info_cols = (
                                st.session_state.temp_selected_cols.copy()
                            )
                            st.success(
                                f"{len(st.session_state.personal_info_cols)}개 컬럼이 선택되었습니다:"
                            )
                            for col in st.session_state.personal_info_cols:
                                st.write(f"- {col}")

                    # 확정 버튼
                    if st.button("개인정보 컬럼 확정"):
                        if not st.session_state.temp_selected_cols:
                            st.error("선택된 컬럼이 없습니다.")
                        else:
                            st.session_state.personal_info_cols = (
                                st.session_state.temp_selected_cols.copy()
                            )
                            st.success(
                                f"선택된 개인정보 컬럼 ({len(st.session_state.personal_info_cols)}개): "
                                + ", ".join(st.session_state.personal_info_cols)
                            )
                            st.rerun()

                if st.session_state.personal_info_cols:
                    with st.spinner("서베이 파일 처리 중..."):
                        all_surveys = []
                        processed_count = 0

                        # 1단계: 모든 파일의 컬럼 매핑 생성
                        column_mapping = {}  # 원본 컬럼명 -> 정리된 컬럼명

                        # 각 파일의 컬럼명을 수집하고 매핑 생성
                        for file in survey_files:
                            df = read_uploaded_file(file, show_success=False)
                            if df is not None:
                                # 질문 컬럼만 처리
                                for col in df.columns:
                                    if col not in st.session_state.personal_info_cols:
                                        clean_col = re.sub(
                                            r"^\d+\.\s*", "", str(col)
                                        ).strip()
                                        if col not in column_mapping:
                                            column_mapping[col] = clean_col
                                        elif column_mapping[col] != clean_col:
                                            st.warning(
                                                f"주의: 컬럼 '{col}'이(가) 다른 형식으 나타납니다: '{clean_col}' vs '{column_mapping[col]}'"
                                            )

                        # 2단계: 각 파일 의 데이터 통합
                        for file in survey_files:
                            df = read_uploaded_file(file, show_success=False)
                            if df is not None:
                                # 개인정보 컬럼 복사 (모든 컬럼이 존재하는지 확인)
                                missing_cols = [
                                    col
                                    for col in st.session_state.personal_info_cols
                                    if col not in df.columns
                                ]
                                if missing_cols:
                                    st.warning(
                                        f"파일 '{file.name}'에서 다음 개인정보 컬럼이 누락되었습니다: {', '.join(missing_cols)}"
                                    )
                                    continue

                                df_clean = pd.DataFrame()

                                # 개인정보 컬럼 복사
                                for col in st.session_state.personal_info_cols:
                                    df_clean[col] = df[col]

                                # 질문 컬럼 처리
                                for col in df.columns:
                                    if col not in st.session_state.personal_info_cols:
                                        if col in column_mapping:
                                            clean_col = column_mapping[col]
                                            df_clean[clean_col] = df[col]

                                all_surveys.append(df_clean)
                                processed_count += 1

                        if all_surveys:
                            # 모든 이터프레임을 개인정보 컬럼을 기준으로 병합
                            combined_df = all_surveys[0]
                            for df in all_surveys[1:]:
                                combined_df = pd.merge(
                                    combined_df,
                                    df,
                                    on=st.session_state.personal_info_cols,
                                    how="outer",
                                )

                            # column_order 업데이트 (개인정보 럼 + 정렬된 질문 컬)
                            question_cols = sorted(set(column_mapping.values()))
                            st.session_state.column_order = (
                                st.session_state.personal_info_cols + question_cols
                            )

                            st.session_state.combined_survey = combined_df[
                                st.session_state.column_order
                            ]

                            st.success(f"총 {processed_count}개의 서베이 파일이 성공적으로 처리되었습니다.")

                            # 통합된 데이터 미리보기
                            st.write("### 통합된 데이터 미리보기")
                            total_responses = len(st.session_state.combined_survey)
                            st.write(f"총 {total_responses}개의 응답이 통합되었습니다.")
                            st.dataframe(st.session_state.combined_survey.head())

                            # 초기 column_order 설정 (처음 통합할 때만)
                            if "column_order" not in st.session_state:
                                st.session_state.column_order = list(
                                    st.session_state.combined_survey.columns
                                )

                            # 파일별 응답 수 정보를 테이블로 표시
                            st.write("### 파일별 응답 수")

                            # CSS로 테이블 내 텍스트 가운데 정렬
                            st.markdown(
                                """
                                <style>
                                [data-testid="stDataFrame"] div[data-testid="stDataFrameCell"] {
                                    justify-content: center;
                                }
                                </style>
                            """,
                                unsafe_allow_html=True,
                            )

                            # 응답 수 데이터 생성
                            response_data = pd.DataFrame(
                                [[len(df) for df in all_surveys]], index=["응답 수"]
                            )

                            # 컬럼명을 '파일 1', '파일 2' 등으로 설정
                            response_data.columns = [
                                f"파일 {i+1}" for i in range(len(all_surveys))
                            ]

                            # 데이터레임 표시
                            st.dataframe(
                                response_data,
                                column_config={
                                    col: st.column_config.Column(width=80)
                                    for col in response_data.columns
                                },
                                hide_index=False,
                            )

                            # 변수 정렬 기능
                            st.subheader("2. 변수 순서 조정")

                            # 변수 그룹 설정
                            personal_cols = st.session_state.personal_info_cols
                            survey_cols = [
                                col
                                for col in st.session_state.column_order
                                if col not in personal_cols
                            ]

                            st.write("### 변수 순서 관리")
                            tab1, tab2 = st.tabs(["📊 일괄 변경", "🔄 세부 조정"])

                            with tab1:
                                st.write("##### 변수 그룹별 순서 설정")
                                if "current_group_order" not in st.session_state:
                                    st.session_state.current_group_order = [
                                        "개인정보 변수",
                                        "서베이 응답 변수",
                                    ]

                                if st.session_state.combined_survey is not None:
                                    personal_cols = st.session_state.personal_info_cols
                                    survey_cols = [
                                        col
                                        for col in st.session_state.column_order
                                        if col
                                        not in st.session_state.personal_info_cols
                                    ]

                                    group_order = st.multiselect(
                                        "변수 그룹 순서를 선택하세요",
                                        options=["개인정보 변수", "서베이 응답 변수"],
                                        default=st.session_state.current_group_order,
                                        help="변수 그룹의 순서를 드래그하여 변경할 수 있습니다",
                                    )

                                    # 현재 그룹별 변수 수 표시
                                    st.info(
                                        f"""
                                        현재 변수 성:
                                        - 개인정보 변수: {len(personal_cols)}개
                                        - 서베이 응답 변수: {len(survey_cols)}개
                                    """
                                    )

                                    if st.button("그룹 순서 적용"):
                                        if not group_order:  # group_order가 비어있는 경우 체크
                                            st.error("변수 그룹을 선택해주세요.")
                                        elif (
                                            len(group_order) != 2
                                        ):  # 두 그룹이 모두 선택되지 않은 경우
                                            st.error("두 그룹을 모두 선택해주세요.")
                                        else:
                                            try:
                                                new_order = []
                                                for group in group_order:
                                                    if group == "개인정보 변수":
                                                        new_order.extend(personal_cols)
                                                    elif group == "서베이 응답 변수":
                                                        new_order.extend(
                                                            sorted(survey_cols)
                                                        )

                                                if new_order:
                                                    # session_state 업데이트
                                                    st.session_state.column_order = (
                                                        new_order.copy()
                                                    )
                                                    st.session_state.temp_column_order = (
                                                        new_order.copy()
                                                    )
                                                    st.session_state.current_group_order = (
                                                        group_order
                                                    )

                                                    # 데이터프레임 컬럼 순서 변경
                                                    if all(
                                                        col
                                                        in st.session_state.combined_survey.columns
                                                        for col in new_order
                                                    ):
                                                        st.session_state.combined_survey = st.session_state.combined_survey[
                                                            new_order
                                                        ]
                                                        st.success("변수 그룹 순서가 변경되었습니다!")

                                                        # 변경된 순서 표시
                                                        display_current_order()
                                                        display_data_preview()
                                                    else:
                                                        missing_cols = [
                                                            col
                                                            for col in new_order
                                                            if col
                                                            not in st.session_state.combined_survey.columns
                                                        ]
                                                        st.error(
                                                            f"다음 컬럼이 데이터프레임에 없습니다: {missing_cols}"
                                                        )
                                                else:
                                                    st.error("새로운 순서를 생성할 수 없습니다.")
                                            except Exception as e:
                                                st.error(
                                                    f"순서 변경 중 오류가 발생했습니다: {str(e)}"
                                                )

                                # 변수 순서 확정 버튼 수정
                                if st.button(
                                    "현재 변수 순서 확정",
                                    type="primary",
                                    use_container_width=True,
                                    key="confirm_order_bulk",
                                ):
                                    st.session_state.final_column_order = (
                                        st.session_state.column_order.copy()
                                    )
                                    st.session_state.temp_column_order = (
                                        st.session_state.column_order.copy()
                                    )
                                    st.session_state.combined_survey = (
                                        st.session_state.combined_survey[
                                            st.session_state.column_order
                                        ]
                                    )
                                    st.success("✅ 변수 순서가 확정되었습니다!")
                                    st.session_state.show_target_section = True
                                    st.rerun()

                                # 일괄 변경 탭 내부에 대상자 명단 통합 섹션 추가
                                st.markdown("---")
                                st.subheader("3. 대상자 명단과 통합")
                                st.info("👥 통합된 서베이 데이터와 대상자 명단을 매칭할 수 있습니다.")

                                if "final_column_order" in st.session_state:
                                    target_file = st.file_uploader(
                                        "대상자 명단 파일을 업로드하세요",
                                        type=["xlsx", "xls", "csv"],
                                        key="target_file_upload_detail",
                                    )

                                    if target_file:
                                        target_df = read_uploaded_file(target_file)
                                        if target_df is not None:
                                            st.write("### 대상자 명단 미리보기")
                                            st.dataframe(target_df.head())

                                            # 키 매칭 설정 UI
                                            col1, col2 = st.columns(2)

                                            with col1:
                                                st.write("### 서베이 데이터 키 선택")
                                                # 확정된 순서가 있으면 그 순서를 사용
                                                survey_columns = (
                                                    st.session_state.final_column_order
                                                    if "final_column_order"
                                                    in st.session_state
                                                    else st.session_state.column_order
                                                )
                                                survey_keys = st.multiselect(
                                                    "매칭할 서베이 데이터의 컬럼을 선택하세요",
                                                    survey_columns,
                                                    max_selections=2,
                                                    help="회사, 사번과 같이 고유한 식별이 가능한 컬럼 2개를 선택하세요",
                                                )

                                            with col2:
                                                st.write("### 대상자 명단 키 선택")
                                                target_keys = st.multiselect(
                                                    "매칭할 대상자 명단의 컬럼을 선택하세요",
                                                    target_df.columns.tolist(),
                                                    max_selections=2,
                                                    help="서베이 데이터와 매칭될 컬럼 2개를 선택하세요",
                                                )

                                            if (
                                                len(survey_keys) == 2
                                                and len(target_keys) == 2
                                            ):
                                                try:
                                                    # 원본 데이터 복사
                                                    survey_df = (
                                                        st.session_state.combined_survey.copy()
                                                    )
                                                    target_df_copy = target_df.copy()

                                                    # 데이터 정리 함수
                                                    def clean_key_value(value):
                                                        # 값을 문자열로 변환
                                                        value = str(value)
                                                        # 소수점 제거 (.0 제거)
                                                        if value.endswith(".0"):
                                                            value = value[:-2]
                                                        # 공백 제거
                                                        value = value.strip()
                                                        # 모든 공백 제거
                                                        value = value.replace(" ", "")
                                                        # 대문자 변환
                                                        value = value.upper()
                                                        return value

                                                    # 데이터 정리
                                                    for col in survey_keys:
                                                        survey_df[col] = survey_df[
                                                            col
                                                        ].fillna("")
                                                        survey_df[col] = survey_df[
                                                            col
                                                        ].apply(clean_key_value)

                                                    for col in target_keys:
                                                        target_df_copy[
                                                            col
                                                        ] = target_df_copy[col].fillna(
                                                            ""
                                                        )
                                                        target_df_copy[
                                                            col
                                                        ] = target_df_copy[col].apply(
                                                            clean_key_value
                                                        )

                                                    # 매칭 키 생성
                                                    survey_df["match_key"] = survey_df[
                                                        survey_keys
                                                    ].agg("_".join, axis=1)
                                                    target_df_copy[
                                                        "match_key"
                                                    ] = target_df_copy[target_keys].agg(
                                                        "_".join, axis=1
                                                    )

                                                    # 데이터 통합
                                                    final_df = pd.merge(
                                                        target_df_copy,
                                                        survey_df,
                                                        on="match_key",
                                                        how="left",
                                                        indicator=True,
                                                    )

                                                    # 매칭 결과 분석
                                                    total_targets = len(target_df_copy)
                                                    matched = len(
                                                        final_df[
                                                            final_df["_merge"] == "both"
                                                        ]
                                                    )
                                                    unmatched = len(
                                                        final_df[
                                                            final_df["_merge"]
                                                            == "left_only"
                                                        ]
                                                    )

                                                    col1, col2, col3 = st.columns(3)
                                                    col1.metric(
                                                        "전체 대상자 수", total_targets
                                                    )
                                                    col2.metric("매칭된 대상자 수", matched)
                                                    col3.metric("미매칭 대상자 수", unmatched)

                                                    # 미매칭 데이터 확인
                                                    if unmatched > 0:
                                                        st.warning(
                                                            "⚠️ 매칭되지 않은 데이터가 있습니다."
                                                        )
                                                        if st.button("미매칭 데이터 확인"):
                                                            unmatched_df = final_df[
                                                                final_df["_merge"]
                                                                == "left_only"
                                                            ]
                                                            st.dataframe(
                                                                unmatched_df[
                                                                    target_keys
                                                                ]
                                                            )

                                                    # 최종 데이터 정리
                                                    final_df = final_df.drop(
                                                        ["match_key", "_merge"], axis=1
                                                    )

                                                    # 확정된 변수 순 적용
                                                    if (
                                                        "final_column_order"
                                                        in st.session_state
                                                    ):
                                                        try:
                                                            # 대상자 명단의 컬럼들을 앞쪽에 배치
                                                            target_columns = [
                                                                col
                                                                for col in target_df.columns
                                                                if col
                                                                not in target_keys
                                                            ]

                                                            # 실제로 존재하는 서베이 컬럼만 필터링
                                                            survey_columns = [
                                                                col
                                                                for col in st.session_state.final_column_order
                                                                if col
                                                                in final_df.columns
                                                            ]

                                                            # 최종 컬럼 순서 설정 (실제 존재하는 컬럼만 포함)
                                                            final_columns = []

                                                            # 대상자 명단 컬럼 추가
                                                            for col in target_columns:
                                                                if (
                                                                    col
                                                                    in final_df.columns
                                                                ):
                                                                    final_columns.append(
                                                                        col
                                                                    )

                                                            # 서베이 컬럼 추가
                                                            final_columns.extend(
                                                                survey_columns
                                                            )

                                                            # 누락된 컬럼이 있다면 마지막에 추가
                                                            remaining_cols = [
                                                                col
                                                                for col in final_df.columns
                                                                if col
                                                                not in final_columns
                                                            ]
                                                            final_columns.extend(
                                                                remaining_cols
                                                            )

                                                            # 컬럼 순서 재배치
                                                            final_df = final_df[
                                                                final_columns
                                                            ]

                                                        except Exception as e:
                                                            st.warning(
                                                                f"컬럼 순서 재배치 중 오류가 발생했습니다: {str(e)}"
                                                            )
                                                        st.info("기본 순서로 데이터를 표시합니다.")

                                                    st.write("### 최종 데이터셋 미리보기")
                                                    st.dataframe(final_df.head())

                                                    # 다운로드 버튼
                                                    final_processed_data = (
                                                        create_excel_download(final_df)
                                                    )
                                                    st.download_button(
                                                        label="최종 통합 데이터셋 다운로드",
                                                        data=final_processed_data,
                                                        file_name="최종_통합_데이터셋.xlsx",
                                                        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
                                                    )

                                                except Exception as e:
                                                    st.error(
                                                        f"데이터 통합 중 오류 발생: {str(e)}"
                                                    )

                            with tab2:
                                st.write("##### 🔄 개별 변수 이동")

                                if (
                                    "combined_survey" in st.session_state
                                    and st.session_state.combined_survey is not None
                                ):
                                    # 컬럼 순서 초기화 확인
                                    if "column_order" not in st.session_state:
                                        st.session_state.column_order = list(
                                            st.session_state.combined_survey.columns
                                        )

                                    # 임시 컬럼 순서 초기화
                                    if "temp_column_order" not in st.session_state:
                                        st.session_state.temp_column_order = (
                                            st.session_state.column_order.copy()
                                        )

                                    col1, col2 = st.columns([2, 1])

                                    with col1:
                                        # 변수 선택 UI
                                        available_columns = (
                                            st.session_state.temp_column_order
                                        )
                                        if not available_columns:
                                            available_columns = list(
                                                st.session_state.combined_survey.columns
                                            )

                                        selected_cols = st.multiselect(
                                            "이동할 변수들을 선택하세요",
                                            options=available_columns,
                                            format_func=lambda x: f"📋 {x}"
                                            if x in st.session_state.personal_info_cols
                                            else f"📊 {x}",
                                            key="cols_to_move_select",
                                        )

                                    with col2:
                                        st.write("")
                                        st.write("")
                                        move_type = st.radio(
                                            "이동 방식 선택",
                                            [
                                                "맨 앞으로 이동 ⬆️",
                                                "맨 뒤로 이동 ⬇️",
                                                "특정 변수 기준 이동 ↕️",
                                            ],
                                            key="move_type_radio",
                                        )

                                        # 특정 변수 기준 이동일 때의 추가 옵션
                                        if (
                                            move_type == "특정 변수 기준 이동 ↕️"
                                            and selected_cols
                                        ):
                                            remaining_cols = [
                                                col
                                                for col in available_columns
                                                if col not in selected_cols
                                            ]

                                            if remaining_cols:
                                                reference_col = st.selectbox(
                                                    "기준 변수 선택",
                                                    options=remaining_cols,
                                                    format_func=lambda x: f"📋 {x}"
                                                    if x
                                                    in st.session_state.personal_info_cols
                                                    else f"📊 {x}",
                                                    key="reference_col_select",
                                                )

                                                move_position = st.radio(
                                                    "이동 위치",
                                                    options=[
                                                        "선택한 변수 앞으로⬆️",
                                                        "선택한 변수 뒤로⬇️",
                                                    ],
                                                    key="position_radio",
                                                )
                                            else:
                                                st.warning(
                                                    "선택한 변수를 제외한 이동 가능한 기준 변수가 없습니다."
                                                )
                                        elif move_type == "특정 변수 기준 이동 ↕️":
                                            st.info("이동할 변수를 먼저 선택해주세요.")

                                    # 변수 이동 실행 버튼
                                    move_button_disabled = not selected_cols or (
                                        move_type == "특정 변수 기준 이동 ↕️"
                                        and (
                                            not remaining_cols
                                            if "remaining_cols" in locals()
                                            else True
                                        )
                                    )

                                    if st.button(
                                        "선택한 변수 이동",
                                        key="move_selected_vars",
                                        use_container_width=True,
                                        disabled=move_button_disabled,
                                    ):
                                        try:
                                            new_order = [
                                                col
                                                for col in st.session_state.temp_column_order
                                                if col not in selected_cols
                                            ]

                                            if move_type == "맨 앞으로 이동 ⬆️":
                                                new_order = selected_cols + new_order
                                            elif move_type == "맨 뒤로 이동 ⬇️":
                                                new_order = new_order + selected_cols
                                            elif (
                                                move_type == "특정 변수 기준 이동 ↕️"
                                                and "reference_col_select"
                                                in st.session_state
                                            ):
                                                ref_idx = new_order.index(
                                                    st.session_state.reference_col_select
                                                )
                                                if (
                                                    st.session_state.position_radio
                                                    == "선택한 변수 앞으로⬆️"
                                                ):
                                                    new_order = (
                                                        new_order[:ref_idx]
                                                        + selected_cols
                                                        + new_order[ref_idx:]
                                                    )
                                                else:
                                                    new_order = (
                                                        new_order[: ref_idx + 1]
                                                        + selected_cols
                                                        + new_order[ref_idx + 1 :]
                                                    )

                                            # 순서 업데이트
                                            st.session_state.temp_column_order = (
                                                new_order
                                            )
                                            st.session_state.combined_survey = (
                                                st.session_state.combined_survey[
                                                    new_order
                                                ]
                                            )
                                            st.success("✅ 변수 순서가 변경되었습니다!")

                                            # 현재 순서 및 데이터 미리보기 표시
                                            display_current_order()
                                            st.write("### 데이터 미리보기")
                                            st.dataframe(
                                                st.session_state.combined_survey[
                                                    new_order
                                                ].head()
                                            )

                                            st.rerun()

                                        except Exception as e:
                                            st.error(f"변수 이동 중 오류가 발생했습니다: {str(e)}")

                                    else:
                                        # 현재 순서 및 데이터 미리보기 표시
                                        st.write("### 현재 변수 순서 미리보기")
                                        display_current_order()

                                        st.write("### 데이터 미리보기")
                                        st.dataframe(
                                            st.session_state.combined_survey[
                                                st.session_state.temp_column_order
                                            ].head()
                                        )

                                else:
                                    st.warning("먼저 데이터를 업로드하고 개인정보 컬럼을 선택해주세요.")

                                # 변수 순서 확정 버튼
                                confirm_button = st.button(
                                    "현재 변수 순서 확정",
                                    type="primary",
                                    use_container_width=True,
                                    key="confirm_order_detail",
                                )

                                if confirm_button:
                                    st.session_state.final_column_order = (
                                        st.session_state.temp_column_order.copy()
                                    )
                                    st.session_state.column_order = (
                                        st.session_state.temp_column_order.copy()
                                    )
                                    st.session_state.combined_survey = (
                                        st.session_state.combined_survey[
                                            st.session_state.temp_column_order
                                        ]
                                    )
                                    st.session_state.show_target_section = True
                                    st.success("✅ 변수 순서가 확정되었습니다!")
                                    st.rerun()  # 페이지 리로드

                                # 대상자 통합 섹션 추가
                                if "final_column_order" in st.session_state:
                                    st.markdown("---")
                                    st.subheader("3. 대상자 명단과 통합")
                                    st.info("👥 통합된 서베이 데이터와 대상자 명단을 매칭할 수 있습니다.")

                                    target_file = st.file_uploader(
                                        "대상자 명단 파일을 업로드하세요",
                                        type=["xlsx", "xls", "csv"],
                                        key="target_file_upload_detail_tab2",  # 키 값을 다르게 설정
                                    )

                                    if target_file:
                                        target_df = read_uploaded_file(target_file)
                                        if target_df is not None:
                                            st.write("### 대상자 명단 미리보기")
                                            st.dataframe(target_df.head())

                                            # 키 매칭 설정 UI
                                            col1, col2 = st.columns(2)

                                            with col1:
                                                st.write("### 서베이 데이터 키 선택")
                                                # 확정된 순서가 있으면 그 순서를 사용
                                                survey_columns = (
                                                    st.session_state.final_column_order
                                                    if "final_column_order"
                                                    in st.session_state
                                                    else st.session_state.column_order
                                                )
                                                survey_keys = st.multiselect(
                                                    "매칭할 서베이 데이터의 컬럼을 선택하세요",
                                                    survey_columns,
                                                    max_selections=2,
                                                    help="회사, 사번과 같이 고유한 식별이 가능한 컬럼 2개를 선택하세요",
                                                )

                                            with col2:
                                                st.write("### 대상자 명단 키 선택")
                                                target_keys = st.multiselect(
                                                    "매칭할 대상자 명단의 컬럼을 선택하세요",
                                                    target_df.columns.tolist(),
                                                    max_selections=2,
                                                    help="서베이 데이터와 매칭될 컬럼 2개를 선택하세요",
                                                )

                                            if (
                                                len(survey_keys) == 2
                                                and len(target_keys) == 2
                                            ):
                                                try:
                                                    # 원본 데이터 복사
                                                    survey_df = (
                                                        st.session_state.combined_survey.copy()
                                                    )
                                                    target_df_copy = target_df.copy()

                                                    # 데이터 정리 함수
                                                    def clean_key_value(value):
                                                        # 값을 문자열로 변환
                                                        value = str(value)
                                                        # 소수점 제거 (.0 제거)
                                                        if value.endswith(".0"):
                                                            value = value[:-2]
                                                        # 공백 제거
                                                        value = value.strip()
                                                        # 모든 공백 제거
                                                        value = value.replace(" ", "")
                                                        # 대문자 변환
                                                        value = value.upper()
                                                        return value

                                                    # 데이터 정리
                                                    for col in survey_keys:
                                                        survey_df[col] = survey_df[
                                                            col
                                                        ].fillna("")
                                                        survey_df[col] = survey_df[
                                                            col
                                                        ].apply(clean_key_value)

                                                    for col in target_keys:
                                                        target_df_copy[
                                                            col
                                                        ] = target_df_copy[col].fillna(
                                                            ""
                                                        )
                                                        target_df_copy[
                                                            col
                                                        ] = target_df_copy[col].apply(
                                                            clean_key_value
                                                        )

                                                    # 매칭 키 생성
                                                    survey_df["match_key"] = survey_df[
                                                        survey_keys
                                                    ].agg("_".join, axis=1)
                                                    target_df_copy[
                                                        "match_key"
                                                    ] = target_df_copy[target_keys].agg(
                                                        "_".join, axis=1
                                                    )

                                                    # 데이터 통합
                                                    final_df = pd.merge(
                                                        target_df_copy,
                                                        survey_df,
                                                        on="match_key",
                                                        how="left",
                                                        indicator=True,
                                                    )

                                                    # 매칭 결과 분석
                                                    total_targets = len(target_df_copy)
                                                    matched = len(
                                                        final_df[
                                                            final_df["_merge"] == "both"
                                                        ]
                                                    )
                                                    unmatched = len(
                                                        final_df[
                                                            final_df["_merge"]
                                                            == "left_only"
                                                        ]
                                                    )

                                                    col1, col2, col3 = st.columns(3)
                                                    col1.metric(
                                                        "전체 대상자 수", total_targets
                                                    )
                                                    col2.metric("매칭된 대상자 수", matched)
                                                    col3.metric("미매칭 대상자 수", unmatched)

                                                    # 미매칭 데이터 확인
                                                    if unmatched > 0:
                                                        st.warning(
                                                            "⚠️ 매칭되지 않은 데이터가 있습니다."
                                                        )
                                                        if st.button("미매칭 데이터 확인"):
                                                            unmatched_df = final_df[
                                                                final_df["_merge"]
                                                                == "left_only"
                                                            ]
                                                            st.dataframe(
                                                                unmatched_df[
                                                                    target_keys
                                                                ]
                                                            )

                                                    # 최종 데이터 정리
                                                    final_df = final_df.drop(
                                                        ["match_key", "_merge"], axis=1
                                                    )

                                                    # 확정된 변수 순 적용
                                                    if (
                                                        "final_column_order"
                                                        in st.session_state
                                                    ):
                                                        try:
                                                            # 대상자 명단의 컬럼들을 앞쪽에 배치
                                                            target_columns = [
                                                                col
                                                                for col in target_df.columns
                                                                if col
                                                                not in target_keys
                                                            ]

                                                            # 실제로 존재하는 서베이 컬럼만 필터링
                                                            survey_columns = [
                                                                col
                                                                for col in st.session_state.final_column_order
                                                                if col
                                                                in final_df.columns
                                                            ]

                                                            # 최종 컬럼 순서 설정 (실제 존재하는 컬럼만 포함)
                                                            final_columns = []

                                                            # 대상자 명단 컬럼 추가
                                                            for col in target_columns:
                                                                if (
                                                                    col
                                                                    in final_df.columns
                                                                ):
                                                                    final_columns.append(
                                                                        col
                                                                    )

                                                            # 서베이 컬럼 추가
                                                            final_columns.extend(
                                                                survey_columns
                                                            )

                                                            # 누락된 컬럼이 있다면 마지막에 추가
                                                            remaining_cols = [
                                                                col
                                                                for col in final_df.columns
                                                                if col
                                                                not in final_columns
                                                            ]
                                                            final_columns.extend(
                                                                remaining_cols
                                                            )

                                                            # 컬럼 순서 재배치
                                                            final_df = final_df[
                                                                final_columns
                                                            ]

                                                        except Exception as e:
                                                            st.warning(
                                                                f"컬럼 순서 재배치 중 오류가 발생했습니다: {str(e)}"
                                                            )
                                                        st.info("기본 순서로 데이터를 표시합니다.")

                                                    st.write("### 최종 데이터셋 미리보기")
                                                    st.dataframe(final_df.head())

                                                    # 다운로드 버튼
                                                    final_processed_data = (
                                                        create_excel_download(final_df)
                                                    )
                                                    st.download_button(
                                                        label="최종 통합 데이터셋 다운로드",
                                                        data=final_processed_data,
                                                        file_name="최종_통합_데이터셋.xlsx",
                                                        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
                                                    )

                                                except Exception as e:
                                                    st.error(
                                                        f"데이터 통합 중 오류 발생: {str(e)}"
                                                    )

    except Exception as e:
        st.error(f"처리 중 오류가 발생했습니다: {str(e)}")


def extract_specific_text(file):
    """PPT에서 텍스트 추출"""
    try:
        prs = Presentation(file)
        extracted_texts = []

        for slide in prs.slides:
            slide_texts = []
            for shape in slide.shapes:
                if hasattr(shape, "text") and shape.text.strip():
                    if shape.shape_type == MSO_SHAPE_TYPE.GROUP:
                        for subshape in shape.shapes:
                            if hasattr(subshape, "text") and subshape.text.strip():
                                slide_texts.append(subshape.text.strip())
                    else:
                        slide_texts.append(shape.text.strip())

            if slide_texts:
                extracted_texts.extend(slide_texts)

        return extracted_texts
    except Exception as e:
        st.error(f"PPT 처리 중 오류 발생: {str(e)}")
        return []


def clean_text_for_excel(text):
    """엑셀에서 사용할 수 없는 문자 제거"""
    if not isinstance(text, str):
        return text
    # 줄바꿈, 탭, carriage return 제거
    text = text.replace("\n", " ").replace("\r", " ").replace("\t", " ")
    # 불필요한 공백 제거
    text = re.sub(r"\s+", " ", text).strip()
    return text


def extract_responses():
    """PPT 주요응답 추출 및 분류 기능"""
    st.header("PPT 주요응답 추출 및 분류")

    # PPT 파일 업로드
    uploaded_files = st.file_uploader(
        "PPT 파일을 택하세요", type=["pptx"], accept_multiple_files=True, key="ppt_files"
    )

    if uploaded_files:
        try:
            all_texts = []
            progress_bar = st.progress(0)

            # PPT에서 텍스트 추출
            for i, file in enumerate(uploaded_files):
                texts = extract_specific_text(file)
                if texts:
                    with st.expander(f"파일: {file.name} 추출 결과"):
                        for text in texts:
                            cleaned_text = clean_text_for_excel(
                                re.sub(r"\s+", " ", text).strip()
                            )
                            st.write(cleaned_text)
                    all_texts.extend(texts)
                progress_bar.progress((i + 1) / len(uploaded_files))

            if all_texts:
                st.success(f"총 {len(all_texts)}개의 텍스트가 추출되었습니다!")

                # 제외할 텍스트 설정
                st.subheader("제외할 텍스트 설정")
                excluded_texts_input = st.text_area(
                    "제외할 텍스트를 입력하세요 (줄 바꿈으로 구분)", help="제외할 텍스트를 한 줄씩 입력하세요"
                )
                excluded_texts = excluded_texts_input.splitlines()

                # 제외할 텍스트 필터링
                filtered_texts = [
                    clean_text_for_excel(text)
                    for text in all_texts
                    if text not in excluded_texts
                ]

                st.write("### 필터링된 텍스트:")
                for text in filtered_texts:
                    st.write(text)

                # 질문별 분류 추가
                st.subheader("질문별 분류")
                user_questions_input = st.text_area(
                    "질문을 입력하세요 (줄바꿈으로 구분)", help="각 질문이 하나의 열(헤더)이 됩니다"
                )
                user_questions = user_questions_input.splitlines()

                if user_questions:
                    # 질문별 데이터프레임 생성
                    question_responses = {question: [] for question in user_questions}
                    question_responses["기타"] = []

                    current_question = None

                    # 텍스트 분류
                    for text in filtered_texts:
                        matched = False
                        for question in user_questions:
                            if question in text:
                                current_question = question
                                matched = True
                                break

                        if current_question and not matched:
                            question_responses[current_question].append(text)
                        elif not matched and not current_question:
                            question_responses["기타"].append(text)

                    # 데이터프레임으로 변환
                    max_rows = max(
                        len(responses) for responses in question_responses.values()
                    )
                    for question, responses in question_responses.items():
                        if len(responses) < max_rows:
                            question_responses[question].extend(
                                [""] * (max_rows - len(responses))
                            )

                    df = pd.DataFrame(question_responses)

                    st.write("### 질문별 분류 결과:")
                    st.dataframe(df)

                    # 결과 다운로드
                    output = io.BytesIO()
                    with pd.ExcelWriter(output, engine="openpyxl") as writer:
                        df.applymap(clean_text_for_excel).to_excel(writer, index=False)

                    st.download_button(
                        label="분류 결과 다운로드",
                        data=output.getvalue(),
                        file_name="질문별_분류_결과.xlsx",
                        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
                    )

        except Exception as e:
            st.error(f"처리 중 오류 발생: {str(e)}")


def analyze_survey_data():
    """데일리 서베이 통계 분석 기능"""

    # 파스텔톤 색상 팔레트 함수 수정
    def get_gradient_colors(n, color_type="blue"):
        """그라데이션 색상 생성"""
        if color_type == "blue":
            # 하늘색 계열 그라데이션
            base_rgb = (186, 225, 255)  # 기본 파란색
        else:
            # 회색 계열 그라데이션
            base_rgb = (200, 200, 200)  # 기본 회색

        colors = []
        for i in range(n):
            opacity = 0.3 + (0.7 * i / (n - 1)) if n > 1 else 1
            colors.append(
                f"rgba({base_rgb[0]}, {base_rgb[1]}, {base_rgb[2]}, {opacity})"
            )
        return colors

    st.header("데일리 서베이 통계 분석")

    uploaded_file = st.file_uploader(
        "통계 분석할 통합 데이터 파일을 업로드하세요", type=["xlsx", "xls", "csv"], key="stats_file_upload"
    )

    if uploaded_file:
        df = read_uploaded_file(uploaded_file)
        if df is not None:
            st.success("데이터 로드 완료!")

            # 과목 변수 자동 식별 및 그룹화
            subject_vars = [col for col in df.columns if "[" in col and "]" in col]

            if not subject_vars:
                st.warning("과목 관련 변수([과목명])를 찾을 수 없습니다.")
                return

            # 과목명 추출 및 그룹화
            subject_groups = {}
            for col in subject_vars:
                subject_name = re.search(r"\[(.*?)\]", col).group(1)
                if subject_name not in subject_groups:
                    subject_groups[subject_name] = []
                subject_groups[subject_name].append(col)

            # 과목별 평균 계산
            subject_means = {}
            for subject, columns in subject_groups.items():
                subject_means[subject] = df[columns].mean(axis=1).mean()

            # 과목 순서 선택 UI
            st.subheader("1. 전체 과목별 평균 점수")
            subject_order = st.multiselect(
                "과목 순서를 선택하세요",
                options=list(subject_means.keys()),
                default=list(subject_means.keys()),
            )

            if subject_order:
                # 선택된 순서대로 데이터 재구성
                ordered_means = {
                    subject: float(subject_means[subject]) for subject in subject_order
                }  # float로 유지

                # 전체 평균 계산
                total_mean = sum(ordered_means.values()) / len(ordered_means)
                ordered_means["전체"] = total_mean

                # 과목별 평균 점수 테이블 데이터 (소수점 2자리 문자열)
                display_means = {k: f"{v:.2f}" for k, v in ordered_means.items()}
                mean_df = pd.DataFrame([display_means], index=["평균점수"])
                st.dataframe(mean_df)

                # 값에 따른 색상 설정
                values = list(ordered_means.values())  # float 값 사용
                max_val = max(values)
                min_val = min(values)
                colors = ["#BAE1FF" for _ in values]

                # 최대값과 최소값 색상 변경
                for i, v in enumerate(values):
                    if v == max_val:
                        colors[i] = "#BAFFC9"
                    elif v == min_val:
                        colors[i] = "#FF9B9B"

                # 과목별 평균 점수 차트
                fig = go.Figure(
                    data=[
                        go.Bar(
                            x=list(ordered_means.keys()),
                            y=values,  # float 값 사용
                            text=[f"{v:.2f}" for v in values],  # 여기서 포맷팅
                            textposition="outside",
                            marker_color=colors,
                            textfont=dict(size=12),
                        )
                    ]
                )

                fig.update_layout(
                    title="전체 과목별 평균 점수",
                    xaxis_title="과목",
                    yaxis_title="평균 점수",
                    showlegend=False,
                    bargap=0.3,
                    uniformtext_minsize=8,
                    uniformtext_mode="hide",
                )

                st.plotly_chart(fig)

            # 개인정보 변수 선택 UI
            personal_info_vars = [col for col in df.columns if col not in subject_vars]
            selected_personal_vars = st.multiselect(
                "분석에 사용할 개인정보 변수를 선택하세요",
                options=personal_info_vars,
                help="과목별 평균 점수 비교에 사용할 개인정보 변수들을 선택하세요",
            )

            if selected_personal_vars:
                st.subheader("2. 개인정보 변수별 과목 평균 분석")

                # 과목별 평균을 계산한 새로운 데이터프레임 생성
                subject_scores = pd.DataFrame()
                for subject in subject_order:
                    subject_scores[subject] = df[subject_groups[subject]].mean(axis=1)

                # 전체 평균 계산
                subject_scores["전체"] = subject_scores[subject_order].mean(axis=1)

                # 개인정보 변수 추가
                for var in selected_personal_vars:
                    subject_scores[var] = df[var]

                # 각 선택된 개인정보 변수별 분석
                for var in selected_personal_vars:
                    st.write(f"#### {var}에 따른 과목별 평균 점수")

                    # 그룹별 평균 계산
                    ordered_cols = list(ordered_means.keys())
                    grouped_means = (
                        subject_scores.groupby(var)[ordered_cols].mean().round(2)
                    )

                    # 테이블 표시
                    st.write("그룹별 평균 점수:")
                    st.dataframe(grouped_means)

                    # 막대 그래프 1: 과목별 범례가 개인정보 변수
                    fig1 = go.Figure()

                    # 범주별로 다른 색상 사용
                    colors = get_gradient_colors(len(grouped_means.index))

                    # 각 범주별로 막대 그래프 생성
                    for i, category in enumerate(grouped_means.index):
                        fig1.add_trace(
                            go.Bar(
                                name=category,  # 범주 이름
                                x=ordered_cols,  # x축을 과목으로 변경
                                y=grouped_means.loc[category],
                                text=[f"{v:.2f}" for v in grouped_means.loc[category]],
                                textposition="outside",
                                marker_color=colors[i],  # 범주별 색상 지정
                                textfont=dict(size=12),
                            )
                        )

                    fig1.update_layout(
                        title=f"{var}별 과목 평균 점수",
                        xaxis_title="과목",
                        yaxis_title="평균 점수",
                        barmode="group",
                        bargap=0.15,
                        bargroupgap=0.1,
                        uniformtext_minsize=8,
                        uniformtext_mode="hide",
                        # x축 레이블 회전 및 위치 조정
                        xaxis=dict(
                            tickangle=45,
                            tickmode="array",
                            ticktext=ordered_cols,
                            tickvals=list(range(len(ordered_cols))),
                            tickfont=dict(size=12),
                        ),
                        # y축 범위 설정
                        yaxis=dict(
                            range=[0, 5],  # 최대값을 5로 설정
                        ),
                        # 여백 조정
                        margin=dict(
                            b=150,  # 하단 여백
                            t=100,  # 상단 여백 추가
                        ),
                        # 범례 위치 조정
                        legend=dict(
                            orientation="h",
                            yanchor="bottom",
                            y=1.02,
                            xanchor="right",
                            x=1,
                        ),
                    )

                    st.plotly_chart(fig1)

                    # 막대 그래프 2: 개인정보 변수별 범례가 과목
                    fig2 = go.Figure()

                    # 회색 계열 그라데이션 색상 생성
                    colors = get_gradient_colors(len(ordered_cols), color_type="gray")

                    # 과목별로 막대 그래프 생성
                    for i, subject in enumerate(ordered_cols):
                        # 각 과목별 데이터 준비
                        subject_values = grouped_means[subject]

                        # 호버 텍스트 생성
                        hover_texts = []
                        for idx, value in enumerate(subject_values):
                            category_name = grouped_means.index[idx]
                            hover_text = (
                                f"{var}: {category_name}<br>{subject}: {value:.2f}"
                            )
                            hover_texts.append(hover_text)

                        fig2.add_trace(
                            go.Bar(
                                name=subject,
                                x=grouped_means.index,
                                y=subject_values,
                                text=[f"{v:.2f}" for v in subject_values],
                                textposition="outside",
                                marker_color=colors[i],
                                textfont=dict(size=12, color="black"),
                                hovertext=hover_texts,
                                hoverinfo="text",
                            )
                        )

                    # 레이아웃 데이트 (나머지 코드는 동일)
                    fig2.update_layout(
                        title=f"{var}별 과목 평균 점수 (과목별 범례)",
                        xaxis_title=var,
                        yaxis_title="평균 점수",
                        barmode="group",
                        bargap=0.15,
                        bargroupgap=0.1,
                        uniformtext_minsize=8,
                        uniformtext_mode="hide",
                        xaxis=dict(
                            tickangle=45,
                            tickmode="array",
                            ticktext=grouped_means.index,
                            tickvals=list(range(len(grouped_means.index))),
                            tickfont=dict(size=12),
                        ),
                        yaxis=dict(
                            range=[0, 5],
                        ),
                        margin=dict(
                            b=150,
                            t=100,
                        ),
                        legend=dict(
                            orientation="h",
                            yanchor="bottom",
                            y=1.02,
                            xanchor="right",
                            x=1,
                        ),
                    )

                    st.plotly_chart(fig2)


def main():
    """메인 애플케이션 함수"""
    st.set_page_config(
        page_title="아카데미 데이터 통합 프로그램",
        page_icon="📊",
        layout="wide",
        initial_sidebar_state="expanded",
        menu_items={
            "Get Help": None,
            "Report a bug": None,
            "About": "© 2024 SK mySUNI",
        },
    )

    # CSS 스타일 적용
    local_css()

    # 헤와 타이틀
    st.markdown(
        """
        <div style='text-align: center; margin-bottom: 2rem;'>
            <h1>아카데미 데이터 통합 프로그램</h1>
            <p style='color: #666; font-size: 1.2em;'>데일리 서베이 통합 | 데일리 서베이 통계 | PPT 주요응답 추출</p>
        </div>
    """,
        unsafe_allow_html=True,
    )

    # 사이드 메뉴
    selected_menu = sidebar_menu()

    # 페이지 라우팅
    if st.session_state.current_menu == "1) 데일리 서베이 통합":
        survey_integration()
    elif st.session_state.current_menu == "2) 데일리 서베이 통계":
        analyze_survey_data()
    elif st.session_state.current_menu == "3) PPT 주요응답 추출":
        extract_responses()


# app.py의 맨 마지막에 추가
if __name__ == "__main__":
    main()

"""
Copyright © 2024 SK mySUNI
Created by 배수정RF (soojeong.bae@sk.com)
All Rights Reserved.
"""