diff --git a/combined_app.py b/combined_app.py
new file mode 100644
index 0000000..e268da7
--- /dev/null
+++ b/combined_app.py
@@ -0,0 +1,968 @@
+import base64
+import re
+import ast
+import nltk
+import pandas as pd
+from pathlib import Path
+from io import BytesIO
+from PIL import Image, ImageFile
+import streamlit as st
+from streamlit_extras.stylable_container import stylable_container
+import google.generativeai as genai
+from google.cloud import texttospeech
+from google.oauth2 import service_account
+from database import register_user, verify_user, save_learning_history, get_learning_history, update_username, find_username, reset_password
+import extra_streamlit_components as stx
+import time
+
+# Constants and directory setup
+wORK_DIR = Path(__file__).parent
+IMG_DIR, IN_DIR, OUT_DIR = wORK_DIR / "img", wORK_DIR / "input", wORK_DIR / "output"
+
+# Create directories if they don't exist
+IMG_DIR.mkdir(exist_ok=True)
+IN_DIR.mkdir(exist_ok=True)
+OUT_DIR.mkdir(exist_ok=True)
+
+def init_page():
+    st.set_page_config(
+        page_title="앵무새 스쿨",
+        layout="wide",
+        page_icon="🦜"
+    )
+
+def show_auth_page():
+    st.markdown(
+        """
+        <div style='text-align: center; margin-bottom: 30px;'>
+            <h1 style='font-size:48px; color: #4B89DC;'>🔊앵무새 스쿨</h1>
+            <p style='font-size: 20px; color: #555;'>
+                <b>영어공인시험 학습 사이트</b>
+            </p>
+        </div>
+        """, unsafe_allow_html=True)
+
+    # 탭 생성
+    tab1, tab2, tab3 = st.tabs(["로그인", "회원가입", "아이디/비밀번호 찾기"])
+    
+    with tab1:
+        with st.form("login_form", border=True):
+            st.markdown("""
+            <div style='text-align: center; margin-bottom: 20px;'>
+                <h3 style='color: #4B89DC;'>로그인</h3>
+            </div>
+            """, unsafe_allow_html=True)
+            
+            username = st.text_input("아이디", placeholder="아이디를 입력하세요")
+            password = st.text_input("비밀번호", type="password", placeholder="비밀번호를 입력하세요")
+            submitted = st.form_submit_button("로그인", use_container_width=True)
+            
+            if submitted:
+                if not username or not password:
+                    st.error("아이디와 비밀번호를 모두 입력해주세요.")
+                else:
+                    success, user_id = verify_user(username, password)
+                    if success:
+                        # 닉네임(name) 가져오기
+                        import database
+                        conn = database.sqlite3.connect(database.DB_PATH)
+                        c = conn.cursor()
+                        c.execute('SELECT name FROM users WHERE id = ?', (user_id,))
+                        nickname = c.fetchone()[0]
+                        conn.close()
+                        st.session_state["authenticated"] = True
+                        st.session_state["username"] = username  # 아이디
+                        st.session_state["user_id"] = user_id
+                        st.session_state["nickname"] = nickname  # 닉네임
+                        st.success("로그인 성공!")
+                        st.rerun()
+                    else:
+                        st.error("아이디 또는 비밀번호가 올바르지 않습니다.")
+
+    with tab2:
+        with st.form("register_form", border=True):
+            st.markdown("""
+            <div style='text-align: center; margin-bottom: 20px;'>
+                <h3 style='color: #4B89DC;'>회원가입</h3>
+            </div>
+            """, unsafe_allow_html=True)
+            
+            name = st.text_input("닉네임", placeholder="닉네임을 입력하세요")
+            new_username = st.text_input("사용할 아이디", placeholder="아이디를 입력하세요")
+            new_password = st.text_input("사용할 비밀번호", type="password", placeholder="비밀번호를 입력하세요")
+            confirm_password = st.text_input("비밀번호 확인", type="password", placeholder="비밀번호를 다시 입력하세요")
+            email = st.text_input("이메일", placeholder="이메일을 입력하세요")
+            submitted = st.form_submit_button("회원가입", use_container_width=True)
+            
+            if submitted:
+                if not all([new_username, new_password, confirm_password, name, email]):
+                    st.error("모든 항목을 입력해주세요.")
+                elif new_password != confirm_password:
+                    st.error("비밀번호가 일치하지 않습니다.")
+                elif len(new_password) < 6:
+                    st.error("비밀번호는 최소 6자 이상이어야 합니다.")
+                elif not re.match(r"[^@]+@[^@]+\.[^@]+", email):
+                    st.error("올바른 이메일 형식이 아닙니다.")
+                else:
+                    if register_user(new_username, new_password, email, name):
+                        st.success("회원가입이 완료되었습니다! 이제 로그인해주세요.")
+                    else:
+                        st.error("이미 존재하는 아이디 또는 이메일입니다.")
+
+    with tab3:
+        st.markdown("""
+        <div style='text-align: center; margin-bottom: 20px;'>
+            <h3 style='color: #4B89DC;'>아이디/비밀번호 찾기</h3>
+        </div>
+        """, unsafe_allow_html=True)
+
+        find_option = st.radio(
+            "찾으실 항목을 선택하세요",
+            ["아이디 찾기", "비밀번호 재설정"],
+            horizontal=True
+        )
+
+        if find_option == "아이디 찾기":
+            with st.form("find_username_form", border=True):
+                name = st.text_input("닉네임", placeholder="가입 시 등록한 닉네임을 입력하세요")
+                email = st.text_input("이메일", placeholder="가입 시 등록한 이메일을 입력하세요")
+                submitted = st.form_submit_button("아이디 찾기", use_container_width=True)
+
+                if submitted:
+                    if not name or not email:
+                        st.error("닉네임과 이메일을 모두 입력해주세요.")
+                    else:
+                        username = find_username(name, email)
+                        if username:
+                            st.success(f"회원님의 아이디는 **{username}** 입니다.")
+                        else:
+                            st.error("입력하신 정보와 일치하는 계정이 없습니다.")
+
+        else:  # 비밀번호 재설정
+            with st.form("reset_password_form", border=True):
+                username = st.text_input("아이디", placeholder="아이디를 입력하세요")
+                email = st.text_input("이메일", placeholder="가입 시 등록한 이메일을 입력하세요")
+                new_password = st.text_input("새 비밀번호", type="password", placeholder="새로운 비밀번호를 입력하세요")
+                confirm_password = st.text_input("새 비밀번호 확인", type="password", placeholder="새로운 비밀번호를 다시 입력하세요")
+                submitted = st.form_submit_button("비밀번호 재설정", use_container_width=True)
+
+                if submitted:
+                    if not all([username, email, new_password, confirm_password]):
+                        st.error("모든 항목을 입력해주세요.")
+                    elif new_password != confirm_password:
+                        st.error("새 비밀번호가 일치하지 않습니다.")
+                    elif len(new_password) < 6:
+                        st.error("비밀번호는 최소 6자 이상이어야 합니다.")
+                    else:
+                        if reset_password(username, email, new_password):
+                            st.success("비밀번호가 성공적으로 변경되었습니다. 새로운 비밀번호로 로그인해주세요.")
+                        else:
+                            st.error("입력하신 정보와 일치하는 계정이 없습니다.")
+
+def init_session(initial_state: dict = None):
+    if initial_state:
+        for key, value in initial_state.items():
+            if key not in st.session_state:
+                st.session_state[key] = value
+
+def init_score():
+    if "total_score" not in st.session_state:
+        st.session_state["total_score"] = 0
+    if "quiz_data" not in st.session_state:
+        st.session_state["quiz_data"] = []
+    if "answered_questions" not in st.session_state:
+        st.session_state["answered_questions"] = set()
+    if "correct_answers" not in st.session_state:
+        st.session_state["correct_answers"] = 0
+    if "total_questions" not in st.session_state:
+        st.session_state["total_questions"] = 0
+    if "learning_history" not in st.session_state:
+        st.session_state["learning_history"] = []
+    # Initialize quiz-related session state variables
+    if "quiz" not in st.session_state:
+        st.session_state["quiz"] = []
+    if "answ" not in st.session_state:
+        st.session_state["answ"] = []
+    if "audio" not in st.session_state:
+        st.session_state["audio"] = []
+    if "choices" not in st.session_state:
+        st.session_state["choices"] = []
+    if "img" not in st.session_state:
+        st.session_state["img"] = None
+    if "has_image" not in st.session_state:
+        st.session_state["has_image"] = False
+    if "img_bytes" not in st.session_state:
+        st.session_state["img_bytes"] = None
+    if "current_group" not in st.session_state:
+        st.session_state["current_group"] = "default"
+    if "voice" not in st.session_state:
+        st.session_state["voice"] = "ko-KR-Standard-A"  # 기본 음성 설정
+
+def init_question_count():
+    if "question_count" not in st.session_state:
+        st.session_state["question_count"] = 0
+    if "max_questions" not in st.session_state:
+        st.session_state["max_questions"] = 10  # 최대 10문제
+
+def can_generate_more_questions() -> bool:
+    return st.session_state.get("question_count", 0) < st.session_state.get("max_questions", 10)
+
+def uploaded_image(on_change=None, args=None) -> Image.Image | None:
+    with st.sidebar:
+        st.markdown(
+            "<div style='text-align: center; font-weight: bold; font-size: 25px;'>이미지 업로드</div>",
+            unsafe_allow_html=True
+        )
+
+        # 안내 이미지 표시 (실패해도 계속 진행)
+        try:
+            guide_img = Image.open('img/angmose.jpg').resize((300, 300))
+            st.markdown(
+                f"""
+                <div style="text-align: center; padding-bottom: 10px;">
+                    <img src="data:image/png;base64,{img_to_base64(guide_img)}"
+                        width="200"
+                        style="border-radius: 16px; box-shadow: 0 2px 4px rgba(0,0,0,0.1);" />
+                </div>
+                """,
+                unsafe_allow_html=True
+            )
+        except Exception as e:
+            st.warning("안내 이미지를 불러올 수 없습니다.")
+
+        st.markdown(
+            """
+             <div style='text-align: left; font-size: 15px; color: #444; line-height: 1.6; padding-left: 5px;'>
+                이미지를 업로드 하시면<br>
+                AI가 문장을 생성해 퀴즈를 출제합니다.<br>
+                문장을 잘 듣고 퀴즈를 풀어보세요.
+            </div>
+            """,
+            unsafe_allow_html=True
+        )
+
+        # 이미지 상태 초기화
+        if "img_state" not in st.session_state:
+            st.session_state["img_state"] = {
+                "has_image": False,
+                "img_bytes": None,
+                "img": None
+            }
+
+        # 파일 업로더
+        uploaded = st.file_uploader(
+            label="",
+            label_visibility="collapsed",
+            on_change=on_change,
+            args=args,
+            type=["jpg", "jpeg", "png", "gif", "bmp", "webp"]
+        )
+
+        # 새로 업로드된 이미지가 있는 경우
+        if uploaded is not None:
+            try:
+                # 이미지 파일 크기 확인
+                if uploaded.size > 10 * 1024 * 1024:  # 10MB 제한
+                    st.error("이미지 파일 크기는 10MB 이하여야 합니다.")
+                    return None
+
+                # 이미지 로드 및 변환
+                img = Image.open(uploaded)
+                if img.format not in ["JPEG", "PNG", "GIF", "BMP", "WEBP"]:
+                    st.error("지원되지 않는 이미지 형식입니다.")
+                    return None
+
+                img = img.convert("RGB")
+                
+                # 이미지를 세션 상태에 저장
+                buf = BytesIO()
+                img.save(buf, format="PNG")
+                img_bytes = buf.getvalue()
+                
+                # 이미지 상태 업데이트
+                st.session_state["img_state"] = {
+                    "has_image": True,
+                    "img_bytes": img_bytes,
+                    "img": img
+                }
+                
+                with st.container(border=True):
+                    st.image(img, width=300)
+                return img
+            except Exception as e:
+                st.error(f"이미지를 불러올 수 없습니다. 오류: {str(e)}")
+                return None
+
+        # 이전에 업로드된 이미지가 있는 경우
+        elif st.session_state["img_state"]["has_image"]:
+            try:
+                img = st.session_state["img_state"]["img"]
+                if img:
+                    with st.container(border=True):
+                        st.image(img, width=300)
+                    return img
+            except Exception as e:
+                st.error("저장된 이미지를 불러올 수 없습니다. 새로운 이미지를 업로드해주세요.")
+                st.session_state["img_state"] = {
+                    "has_image": False,
+                    "img_bytes": None,
+                    "img": None
+                }
+                return None
+
+        return None
+
+# Utility functions
+def img_to_base64(img: Image.Image) -> str:
+    buf = BytesIO()
+    img.save(buf, format="PNG")
+    return base64.b64encode(buf.getvalue()).decode()
+
+def get_prompt(group: str, difficulty: str = None) -> Path:
+    # Map group to exam type
+    exam_mapping = {
+        "yle": "YLE",
+        "toefl_junior": "TOEFL_JUNIOR",
+        "toeic": "TOEIC",
+        "toefl": "TOEFL"
+    }
+    
+    # Map difficulty to exam level
+    difficulty_mapping = {
+        "easy": "easy",
+        "normal": "medium",
+        "hard": "hard"
+    }
+    
+    exam_type = exam_mapping.get(group, "default")
+    exam_level = difficulty_mapping.get(difficulty, "medium")
+    
+    # First try to get the specific exam type and difficulty prompt
+    if difficulty:
+        prompt_file = f"prompt_{exam_type.lower()}_{exam_level}.txt"
+        path = IN_DIR / prompt_file
+        if path.exists():
+            return path
+    
+    # If no specific prompt found or difficulty not provided, try exam-specific prompt
+    path = IN_DIR / f"prompt_{exam_type.lower()}.txt"
+    if path.exists():
+        return path
+    
+    # If no exam-specific prompt found, use default
+    st.warning(f"⚠️ '{exam_type}' 시험 유형의 프롬프트가 존재하지 않아 기본값을 사용합니다.")
+    return IN_DIR / "prompt_default.txt"
+
+def get_model() -> genai.GenerativeModel:
+    GEMINI_KEY = st.secrets['GEMINI_KEY']
+    GEMINI_MODEL = "gemini-2.0-flash"
+    genai.configure(api_key=GEMINI_KEY, transport="rest")
+    return genai.GenerativeModel(GEMINI_MODEL)
+
+def generate_quiz(img: ImageFile.ImageFile, group: str, difficulty: str):
+    if not can_generate_more_questions():
+        return None, None, None, None
+
+    max_retries = 5  # 재시도 횟수 증가
+    retry_delay = 3  # 대기 시간 증가
+
+    for attempt in range(max_retries):
+        try:
+            with st.spinner(f"문제를 생성하는 중입니다... (시도 {attempt + 1}/{max_retries})"):
+                prompt_desc = IN_DIR / "p1_desc.txt"
+                sys_prompt_desc = prompt_desc.read_text(encoding="utf8")
+                model_desc = get_model()
+                resp_desc = model_desc.generate_content(
+                    [img, f"{sys_prompt_desc}\nDescribe this image"]
+                )
+                description = resp_desc.text.strip()
+
+                quiz_prompt_path = get_prompt(group, difficulty)
+                sys_prompt_quiz = quiz_prompt_path.read_text(encoding="utf8")
+                model_quiz = get_model()
+                
+                # Add exam-specific context to the prompt
+                exam_context = {
+                    "elementary": "YLE 시험 형식에 맞춰",
+                    "middle": "TOEFL Junior 시험 형식에 맞춰",
+                    "high": "TOEIC 시험 형식에 맞춰",
+                    "adult": "TOEFL 시험 형식에 맞춰"
+                }
+                
+                exam_type = exam_context.get(group, "")
+                difficulty_context = {
+                    "easy": "기초 수준의",
+                    "normal": "중급 수준의",
+                    "hard": "고급 수준의"
+                }
+                
+                level = difficulty_context.get(difficulty, "중급 수준의")
+                
+                resp_quiz = model_quiz.generate_content(
+                    f"{sys_prompt_quiz}\n{exam_type} {level} 문제를 생성해주세요.\n{description}"
+                )
+
+                # Try different patterns to match the response
+                quiz_text = resp_quiz.text.strip()
+                
+                # Pattern 1: Standard format with quotes
+                quiz_match = re.search(r'Quiz:\s*["\'](.*?)["\']\s*$', quiz_text, re.MULTILINE)
+                answer_match = re.search(r'Answer:\s*["\'](.*?)["\']\s*$', quiz_text, re.MULTILINE)
+                choices_match = re.search(r'Choices:\s*(\[[^\]]+\](?:,\s*\[[^\]]+\])*)', quiz_text, re.MULTILINE | re.DOTALL)
+                
+                # Pattern 2: Format without quotes
+                if not (quiz_match and answer_match and choices_match):
+                    quiz_match = re.search(r'Quiz:\s*(.*?)\s*$', quiz_text, re.MULTILINE)
+                    answer_match = re.search(r'Answer:\s*(.*?)\s*$', quiz_text, re.MULTILINE)
+                    choices_match = re.search(r'Choices:\s*\[(.*?)\]', quiz_text, re.MULTILINE | re.DOTALL)
+                    
+                    if choices_match:
+                        # Convert comma-separated choices to proper list format
+                        choices_str = choices_match.group(1)
+                        choices = [choice.strip().strip('"\'') for choice in choices_str.split(',')]
+                        choices = [f'"{choice}"' for choice in choices]
+                        choices_str = f"[{', '.join(choices)}]"
+                        choices_match = type('obj', (object,), {'group': lambda x: choices_str})
+
+                if quiz_match and answer_match and choices_match:
+                    quiz_sentence = quiz_match.group(1).strip().strip('"\'')
+                    answer_word = [answer_match.group(1).strip().strip('"\'')]
+                    try:
+                        choices = ast.literal_eval(choices_match.group(1))
+                        if isinstance(choices, str):
+                            choices = [choice.strip().strip('"\'') for choice in choices.split(',')]
+                    except:
+                        # If parsing fails, try to extract choices manually
+                        choices_str = choices_match.group(1)
+                        choices = [choice.strip().strip('"\'') for choice in choices_str.split(',')]
+                    
+                    original_sentence = quiz_sentence.replace("_____", answer_word[0])
+                    st.session_state["question_count"] = st.session_state.get("question_count", 0) + 1
+                    return quiz_sentence, answer_word, choices, original_sentence
+
+                # If all parsing attempts fail, raise error with the full response
+                raise ValueError(f"AI 응답 파싱 실패! AI 응답 내용:\n{quiz_text}")
+
+        except Exception as e:
+            if attempt < max_retries - 1:
+                st.warning(f"문제 생성 중 오류가 발생했습니다. {retry_delay}초 후 다시 시도합니다... ({attempt + 1}/{max_retries})")
+                time.sleep(retry_delay)
+            else:
+                st.error("""
+                문제 생성에 실패했습니다. 다음 중 하나를 시도해보세요:
+                1. 잠시 후 다시 시도
+                2. 다른 이미지로 시도
+                3. 페이지 새로고침
+                """)
+                return None, None, None, None
+
+def synth_speech(text: str, voice: str, audio_encoding: str = None) -> bytes:
+    lang_code = "-".join(voice.split("-")[:2])
+    MP3 = texttospeech.AudioEncoding.MP3
+    WAV = texttospeech.AudioEncoding.LINEAR16
+    audio_type = MP3 if audio_encoding == "mp3" else WAV
+    
+    client = tts_client()
+    resp = client.synthesize_speech(
+        input=texttospeech.SynthesisInput(text=text),
+        voice=texttospeech.VoiceSelectionParams(language_code=lang_code, name=voice),
+        audio_config=texttospeech.AudioConfig(audio_encoding=audio_type),
+    )
+    return resp.audio_content
+
+def tts_client() -> texttospeech.TextToSpeechClient:
+    cred = service_account.Credentials.from_service_account_info(
+        st.secrets["gcp_service_account"]
+    )
+    return texttospeech.TextToSpeechClient(credentials=cred)
+
+def tokenize_sent(text: str) -> list[str]:
+    nltk.download(["punkt", "punkt_tab"], quiet=True)
+    return nltk.tokenize.sent_tokenize(text)
+
+def set_quiz(img: ImageFile.ImageFile, group: str, difficulty: str):
+    if img and not st.session_state["quiz"]:
+        with st.spinner("이미지 퀴즈를 준비 중입니다...🦜"):
+            # 이미지가 변경되었을 때 question_count 초기화
+            if "last_image" not in st.session_state or st.session_state["last_image"] != img:
+                st.session_state["question_count"] = 0
+                st.session_state["last_image"] = img
+            
+            if not can_generate_more_questions():
+                st.warning(f"현재 {st.session_state['question_count']}문제를 풀었어요! 새로운 이미지를 업로드하면 새로운 문제를 풀 수 있습니다.")
+                return
+                
+            quiz_sentence, answer_word, choices, full_desc = generate_quiz(img, group, difficulty)
+            if not quiz_sentence:  # If we've reached the question limit
+                st.warning(f"현재 {st.session_state['question_count']}문제를 풀었어요! 새로운 이미지를 업로드하면 새로운 문제를 풀 수 있습니다.")
+                return
+                
+            if isinstance(choices[0], list):
+                choices = choices[0]
+            answer_words = [answer_word]
+            
+            # Generate simple audio instruction
+            question_audio = "Look at the image carefully."
+            wav_file = synth_speech(question_audio, st.session_state["voice"], "wav")
+            path = OUT_DIR / f"{Path(__file__).stem}.wav"
+            with open(path, "wb") as fp:
+                fp.write(wav_file)
+                
+            quiz_display = f"""이미지를 보고 설명을 잘 들은 후, 빈칸에 들어갈 알맞은 단어를 선택하세요.
+
+**{quiz_sentence}**"""
+            st.session_state["img"] = img
+            st.session_state["quiz"] = [quiz_display]
+            st.session_state["answ"] = answer_words
+            st.session_state["audio"] = [path.as_posix()]
+            st.session_state["choices"] = [choices]
+            st.session_state["quiz_data"] = [{
+                "question": quiz_display,
+                "topic": "지문화",
+                "difficulty": difficulty,
+                "correct": False
+            }]
+
+def show_quiz(difficulty="medium"):
+    zipped = zip(
+        range(len(st.session_state["quiz"])),
+        st.session_state["quiz"],
+        st.session_state["answ"],
+        st.session_state["audio"],
+        st.session_state["choices"],
+    )
+    for idx, quiz, answ, audio, choices in zipped:
+        key_feedback = f"feedback_{idx}"
+        init_session({key_feedback: "", f"submitted_{idx}": False})
+
+        with st.form(f"form_question_{idx}", border=True):
+            st.markdown("""
+            <div style="background-color:#e6f4ea; padding:10px; border-radius:10px; text-align: center;">
+                <h4 style="color:#006d2c; margin: 0;">문제</h4>
+            </div>
+            """, unsafe_allow_html=True)
+
+            st.audio(audio)
+            quiz_display = quiz.replace("**", "").replace(
+                "_____", "<span style='color:black; font-weight:bold;'>_____</span>"
+            )
+            st.markdown(f"<p style='font-size:17px;'>{quiz_display}</p>", unsafe_allow_html=True)
+
+            if not choices:
+                st.error("선택지가 없습니다. 다시 문제를 생성하세요.")
+                continue
+
+            key_choice = f"choice_{idx}_0"
+            init_session({key_choice: ""})
+            if st.session_state[key_choice] not in choices:
+                st.session_state[key_choice] = choices[0]
+            user_choice = st.radio(
+                "보기 중 하나를 선택하세요👇",
+                choices,
+                key=key_choice
+            )
+
+            submitted = st.form_submit_button("정답 제출 ✅", use_container_width=True)
+
+            if submitted and not st.session_state.get(f"submitted_{idx}"):
+                st.session_state[f"submitted_{idx}"] = True
+                
+                with st.spinner("채점 중입니다..."):
+                    is_correct = user_choice == answ[0]
+                    # 마지막 문제 정보 저장
+                    st.session_state["last_question"] = quiz_display
+                    st.session_state["last_user_choice"] = user_choice
+                    st.session_state["last_correct_answer"] = answ[0]
+                    update_score(quiz_display, is_correct)
+
+                    if is_correct:
+                        feedback = "✅ 정답입니다! 🎉"
+                    else:
+                        feedback = f"❌ 오답입니다.\n\n{generate_feedback(user_choice, answ[0])}"
+
+                    st.session_state[key_feedback] = feedback
+
+        feedback = st.session_state.get(key_feedback, "")
+        if feedback:
+            with st.expander("📚 해설 보기", expanded=True):
+                st.markdown(f"**정답:** {answ[0]}")
+                st.markdown(feedback, unsafe_allow_html=True)
+
+def update_score(question: str, is_correct: bool):
+    init_score()
+    
+    # Only update if this question hasn't been answered before
+    if question not in st.session_state["answered_questions"]:
+        st.session_state["answered_questions"].add(question)
+        st.session_state["total_questions"] += 1  # 모든 문제에 대해 문제 수 증가
+        
+        if is_correct:
+            st.session_state["correct_answers"] += 1
+            # 최대 100점까지만 점수 추가
+            if st.session_state["total_score"] < 100:
+                st.session_state["total_score"] += 10
+            
+        # 현재 문제의 피드백 생성
+        feedback = generate_feedback(
+            st.session_state.get("last_user_choice", ""),
+            st.session_state.get("last_correct_answer", "")
+        ) if not is_correct else "정답입니다! 🎉"
+            
+        # Add to current quiz data
+        st.session_state["quiz_data"].append({
+            "question": question,
+            "correct": is_correct,
+            "score": 10 if is_correct else 0,  # 정답은 10점, 오답은 0점
+            "timestamp": pd.Timestamp.now(),
+            "feedback": feedback,
+            "question_content": st.session_state.get("last_question", ""),
+            "user_choice": st.session_state.get("last_user_choice", ""),
+            "correct_answer": st.session_state.get("last_correct_answer", "")
+        })
+        
+        # Save to database if user is authenticated
+        if st.session_state.get("authenticated") and st.session_state.get("user_id"):
+            # 현재까지 푼 문제 수 계산
+            current_question_count = len(st.session_state["answered_questions"])
+            
+            save_learning_history(
+                user_id=st.session_state["user_id"],
+                group_code=st.session_state.get("current_group", "default"),
+                score=10 if is_correct else 0,  # 정답은 10점, 오답은 0점
+                total_questions=current_question_count,  # 현재까지 푼 문제 수
+                question_content=st.session_state.get("last_question", ""),
+                feedback=feedback,
+                user_choice=st.session_state.get("last_user_choice", ""),
+                correct_answer=st.session_state.get("last_correct_answer", "")
+            )
+
+def generate_feedback(user_input: str, answ: str) -> str:
+    try:
+        prompt_path = IN_DIR / "p3_feedback.txt"
+        template = prompt_path.read_text(encoding="utf8")
+        prompt = template.format(user=user_input, correct=answ)
+        model = get_model()
+        response = model.generate_content(
+            f"""다음과 같은 형식으로 피드백을 제공해주세요:
+1. 정답과 오답의 관계 설명
+2. 간단한 학습 조언
+3. 다음에 도움이 될 팁
+
+정답: {answ}
+학생 답변: {user_input}
+
+위 형식에 맞춰 한국어로만 답변해주세요. 번역은 하지 마세요."""
+        )
+        return response.text.strip() if response and response.text else "(⚠️ 응답 없음)"
+    except Exception as e:
+        return f"(⚠️ 피드백 생성 중 오류: {e})"
+
+def show_score_summary():
+    if "quiz_data" not in st.session_state or not st.session_state["quiz_data"]:
+        return
+
+    # Get the latest counts from session state
+    total = st.session_state["total_questions"]
+    correct = st.session_state["correct_answers"]
+    accuracy = round((correct / total) * 100, 1) if total else 0.0
+    score = st.session_state["total_score"]
+
+    # Show current progress
+    st.info(f"현재 {total}문제를 풀었어요! (정답률: {accuracy}%, 현재 점수: {score}점)")
+    
+    # Only show detailed summary when all 10 questions are answered
+    if total < 10:
+        return
+
+    # Create a more visually appealing and accessible score display
+    st.markdown("---")
+    
+    # Score header with emoji
+    st.markdown("""
+    <div style='text-align: center; margin-bottom: 20px;'>
+        <h2 style='color: #4B89DC;'>🏆 최종 점수</h2>
+    </div>
+    """, unsafe_allow_html=True)
+
+    # Create two columns for better layout
+    col1, col2 = st.columns(2)
+
+    with col1:
+        # Score card with large, clear numbers
+        st.markdown(f"""
+        <div style='background-color: #f0f8ff; padding: 20px; border-radius: 10px; text-align: center; box-shadow: 0 2px 4px rgba(0,0,0,0.1);'>
+            <h3 style='color: #4B89DC; margin-bottom: 10px;'>최종 점수</h3>
+            <h1 style='font-size: 48px; color: #2E7D32; margin: 0;'>{score}점</h1>
+        </div>
+        """, unsafe_allow_html=True)
+
+    with col2:
+        # Progress card with clear statistics
+        st.markdown(f"""
+        <div style='background-color: #f0f8ff; padding: 20px; border-radius: 10px; text-align: center; box-shadow: 0 2px 4px rgba(0,0,0,0.1);'>
+            <h3 style='color: #4B89DC; margin-bottom: 10px;'>정답률</h3>
+            <h2 style='color: #2E7D32; margin: 0;'>{accuracy}%</h2>
+            <p style='color: #666; margin-top: 10px;'>맞춘 문제: {correct} / {total}</p>
+        </div>
+        """, unsafe_allow_html=True)
+
+    # Progress bar with better visibility
+    st.markdown(f"""
+    <div style='margin-top: 20px;'>
+        <div style='background-color: #e0e0e0; height: 20px; border-radius: 10px; margin-bottom: 10px;'>
+            <div style='background-color: #4B89DC; width: {accuracy}%; height: 20px; border-radius: 10px;'></div>
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+
+    # Add encouraging message based on performance
+    if total == 10 and correct == 10:
+        st.success("🎉 축하합니다! 100점입니다! 완벽한 성적이에요!")
+    elif accuracy >= 80:
+        st.success("🎉 훌륭해요! 계속 이렇게 잘 해봐요!")
+    elif accuracy >= 60:
+        st.info("👍 잘하고 있어요! 조금만 더 노력해봐요!")
+    else:
+        st.warning("💪 조금 더 연습하면 더 잘할 수 있을 거예요!")
+    
+    clear_all_scores()
+
+def reset_quiz():
+    if st.session_state.get("quiz"):
+        # Add some vertical space before the button
+        st.markdown("<br>", unsafe_allow_html=True)
+        if st.button("🔄 새로운 문제", type="primary"):
+            # Keep authentication state
+            auth_state = {
+                "authenticated": st.session_state.get("authenticated", False),
+                "username": st.session_state.get("username", ""),
+                "user_id": st.session_state.get("user_id", None)
+            }
+            
+            # Keep image state
+            img_state = st.session_state.get("img_state", {
+                "has_image": False,
+                "img_bytes": None,
+                "img": None
+            })
+            
+            # Keep score-related states
+            score_state = {
+                "total_score": st.session_state.get("total_score", 0),
+                "quiz_data": st.session_state.get("quiz_data", []),
+                "answered_questions": st.session_state.get("answered_questions", set()),
+                "correct_answers": st.session_state.get("correct_answers", 0),
+                "total_questions": st.session_state.get("total_questions", 0),
+                "question_count": st.session_state.get("question_count", 0),
+                "last_image": st.session_state.get("last_image", None)
+            }
+            
+            # Clear only current quiz states
+            keys_to_clear = ["quiz", "answ", "audio", "choices"]
+            for key in keys_to_clear:
+                if key in st.session_state:
+                    del st.session_state[key]
+            
+            # Clear form-related states
+            for key in list(st.session_state.keys()):
+                if key.startswith(("submitted_", "feedback_", "choice_", "form_question_")):
+                    del st.session_state[key]
+            
+            # Restore important states
+            st.session_state.update(auth_state)
+            st.session_state["img_state"] = img_state
+            st.session_state.update(score_state)
+            
+            st.rerun()
+
+def show_learning_history():
+    if not st.session_state.get("authenticated") or not st.session_state.get("user_id"):
+        return
+        
+    st.markdown("---")
+    st.markdown("""
+    <div style='text-align: center; margin-bottom: 20px;'>
+        <h2 style='color: #4B89DC;'>📚 학습 기록</h2>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Get learning history from database
+    history = get_learning_history(st.session_state["user_id"])
+    if not history:
+        st.info("아직 학습 기록이 없습니다. 퀴즈를 풀어보세요!")
+        return
+
+    # 데이터프레임 생성 (모든 컬럼 포함)
+    history_df = pd.DataFrame(history, columns=['group_code', 'score', 'total_questions', 'timestamp', 'question_content', 'feedback', 'user_choice', 'correct_answer'])
+    
+    # 날짜/시간 포맷 변경
+    history_df['timestamp'] = pd.to_datetime(history_df['timestamp'])
+    history_df['date'] = history_df['timestamp'].dt.strftime('%Y-%m-%d %H:%M')
+    
+    # 시험 유형 이름 매핑
+    group_name_mapping = {
+        "yle": "YLE",
+        "toefl_junior": "TOEFL JUNIOR",
+        "toeic": "TOEIC",
+        "toefl": "TOEFL"
+    }
+    history_df['group_code'] = history_df['group_code'].map(group_name_mapping)
+    
+    # 정답 여부 표시를 위한 함수
+    def get_result_icon(row):
+        return "✅" if row['score'] > 0 else "❌"
+    history_df['result'] = history_df.apply(get_result_icon, axis=1)
+
+    # 누적 점수 계산 (최대 100점)
+    cumulative_score = []
+    current_score = 0
+    for s in history_df['score']:
+        if s > 0 and current_score < 100:
+            current_score = min(current_score + 10, 100)
+        cumulative_score.append(current_score)
+    history_df['cumulative_score'] = cumulative_score
+
+    # 표시할 컬럼만 선택
+    display_df = history_df[['date', 'group_code', 'result', 'cumulative_score', 'total_questions']]
+    display_df.columns = ['날짜', '시험 유형', '결과', '누적 점수', '문제 수']
+    
+    if not display_df.empty:
+        st.dataframe(
+            display_df,
+            use_container_width=True,
+            hide_index=True
+        )
+    else:
+        st.info("학습 기록이 없습니다.")
+
+def clear_all_scores():
+    if st.button("🗑️ 현재 점수 초기화", type="secondary"):
+        # Only clear current score-related data, not learning history
+        st.session_state["total_score"] = 0
+        st.session_state["quiz_data"] = []
+        st.session_state["answered_questions"] = set()
+        st.session_state["correct_answers"] = 0
+        st.session_state["total_questions"] = 0
+        st.session_state["question_count"] = 0  # Reset question count
+        st.success("현재 점수가 초기화되었습니다.")
+        st.rerun()
+
+# Main application
+if __name__ == "__main__":
+    try:
+        # Initialize page configuration first
+        init_page()
+        
+        # Initialize session state
+        init_score()
+        init_question_count()
+        
+        # 로그인 상태 확인
+        if not st.session_state.get("authenticated", False):
+            show_auth_page()
+        else:
+            # 메인 페이지 타이틀
+            st.markdown(
+                """
+                <div style='text-align: center; margin-bottom: 30px;'>
+                    <h1 style='font-size:48px; color: #4B89DC;'>🔊앵무새 스쿨</h1>
+                    <p style='font-size: 20px; color: #555;'>
+                        <b>영어공인시험 학습 프로그램</b>
+                    </p>
+                </div>
+                """, unsafe_allow_html=True
+            )
+            
+            # 사이드바에 사용자 정보 표시
+            with st.sidebar:
+                st.markdown(f"""
+                <div style='text-align: center; padding: 10px; background-color: #f0f8ff; border-radius: 10px; margin-bottom: 20px;'>
+                    <h3 style='color: #4B89DC;'>👤 닉네임: {st.session_state.get('nickname', '')}</h3>
+                </div>
+                """, unsafe_allow_html=True)
+                
+                # 닉네임 변경 폼
+                with st.expander("✏️ 닉네임 변경", expanded=False):
+                    with st.form("change_nickname_form"):
+                        new_nickname = st.text_input(
+                            "새로운 닉네임",
+                            placeholder="변경할 닉네임을 입력하세요",
+                            value=st.session_state.get('nickname', '')
+                        )
+                        submitted = st.form_submit_button("변경하기", use_container_width=True)
+                        
+                        if submitted:
+                            if not new_nickname:
+                                st.error("닉네임을 입력해주세요.")
+                            elif new_nickname == st.session_state.get('nickname'):
+                                st.info("현재 사용 중인 닉네임과 동일합니다.")
+                            else:
+                                if update_username(st.session_state.get('user_id'), new_nickname):
+                                    st.session_state["nickname"] = new_nickname
+                                    st.success("닉네임이 변경되었습니다!")
+                                    st.rerun()
+                                else:
+                                    st.error("이미 사용 중인 닉네임입니다.")
+                
+                if st.button("로그아웃", use_container_width=True):
+                    # Clear all session state
+                    for key in list(st.session_state.keys()):
+                        del st.session_state[key]
+                    st.rerun()
+            
+            # 메인 컨텐츠
+            init_score()
+            init_question_count()
+            
+            # 1. 시험 종류 선택
+            st.markdown("### 📚 시험 종류 선택")
+            group_display = st.selectbox(
+                "시험 종류를 선택하세요.",
+                ["YLE", "TOEFL JUNIOR", "TOEIC", "TOEFL"],
+                help="선택한 시험 유형에 맞는 퀴즈가 출제됩니다."
+            )
+            group_mapping = {
+                "YLE": "yle",
+                "TOEFL JUNIOR": "toefl_junior",
+                "TOEIC": "toeic",
+                "TOEFL": "toefl"
+            }
+            group_code = group_mapping.get(group_display, "default")
+            st.session_state["current_group"] = group_code
+
+            # 2. 난이도 선택
+            st.markdown("### 🎯 난이도 선택")
+            difficulty_display = st.selectbox(
+                "문제 난이도를 선택하세요.",
+                ["쉬움", "중간", "어려움"],
+                help="선택한 난이도에 따라 문제의 복잡도가 달라집니다."
+            )
+            difficulty_mapping = {
+                "쉬움": "easy",
+                "중간": "normal",
+                "어려움": "hard"
+            }
+            global_difficulty = difficulty_mapping.get(difficulty_display, "normal")
+
+            # 3. 이미지 업로드 or 복원
+            st.markdown("### 🖼️ 이미지 업로드")
+            img = uploaded_image()
+
+            if img:
+                # 새로운 퀴즈 생성이 필요한 경우
+                if not st.session_state.get("quiz"):
+                    set_quiz(img, group_code, global_difficulty)
+                
+                show_quiz(global_difficulty)
+
+                if st.session_state.get("quiz_data"):
+                    show_score_summary()
+                    show_learning_history()
+
+                reset_quiz()
+            else:
+                st.info("이미지를 업로드하면 퀴즈가 시작됩니다!")
+                
+    except Exception as e:
+        st.error(f"오류가 발생했습니다: {str(e)}")
+        st.info("페이지를 새로고침하거나 다시 시도해주세요.") 
\ No newline at end of file