Update app.py

app.py

@@ -1,16 +1,20 @@
-
 import os
 import re
 import time
 from dotenv import load_dotenv
 import streamlit as st
-from gtts import gTTS
 import PyPDF2
 import google.generativeai as genai
 import speech_recognition as sr
 from random import sample
 import random
 from html import escape
+import asyncio
+import edge_tts
+import pandas as pd
+import tempfile
+import traceback
+
 
 # ✅ MUST be the first Streamlit command
 st.set_page_config(page_title="GrillMaster", layout="wide")
@@ -19,7 +23,6 @@ st.set_page_config(page_title="GrillMaster", layout="wide")
 load_dotenv()
 genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
 
-
 # Initialize session state
 for key, default in {
     "generated_questions": [],
@@ -77,257 +80,420 @@ def get_questions(prompt, input_text, num_questions=3, max_retries=10):
 
     return new_questions
 
-
-# def evaluate_answers():
-#     model = genai.GenerativeModel('gemini-1.5-pro-latest')
-#     prompt = """
-#     You are an expert interview evaluator. Assess responses based on:
-#     - Conceptual Understanding
-#     - Communication Skills
-#     - Clarity & Depth of Explanation
-#     - Use of Real-World Examples
-#     - Logical Flow
-
-#     Provide a score (out of 10) and an evaluation summary.
-
-#     **Format:**
-#     **Overall Score:** x/10
-#     **Evaluation Summary:**
-#     - Concept Understanding: .
-#     - Communication: .
-#     - Depth of Explanation: .
-#     - Examples: .
-#     - Logical Flow: .
-#     """
-#     candidate_responses = "\n\n".join(
-#         [f"Q: {entry['question']}\nA: {entry['response']}" for entry in st.session_state["answers"]]
-#     )
-#     full_prompt = f"{prompt}\n\nCandidate Responses:\n{candidate_responses}"
-#     response = model.generate_content(full_prompt)
-#     st.session_state["evaluation_feedback"] = response.text.strip()
-#     match = re.search(r"\*\*Overall Score:\*\* (\d+)/10", response.text)
-#     st.session_state["overall_score"] = int(match.group(1)) if match else 0
-#     st.session_state["percentage_score"] = st.session_state["overall_score"] * 10
-
-import asyncio
-import edge_tts
-
-import re
-import tempfile
-import asyncio
-import edge_tts
-
 async def generate_question_audio(question, voice="en-IE-EmilyNeural"):
     clean_question = re.sub(r'[^A-Za-z0-9.,?! ]+', '', question)
     tts = edge_tts.Communicate(text=clean_question, voice=voice)
     with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
         await tts.save(tmp_file.name)
         return tmp_file.name
-
-
-# === KEYWORD-BASED SCORING LOGIC ===
-
-KEYWORDS = {
-    "Analytics": {
-        "Python": ["loops", "list", "dictionary", "function", "pandas", "numpy"],
-        "SQL": ["join", "group by", "select", "where", "index", "foreign key"],
-        "Machine Learning": ["model", "features", "training", "accuracy", "regression"]
+    
+########################################///////////////////////////////////////////////////#########################################
+
+# HR_PARAMETERS_CONFIG - Updated based on your latest Excel sheet (input_file_0.png)
+# These are the parameters that can be judged from audio/text responses.
+HR_PARAMETERS_CONFIG = {
+    "Voice Modulation": { # Non-Verbal Cues
+        "weight_original": 5, 
+        "rubric": "1-5 (5=Good pace/tone, conversational; 3=Sounds Scripted/Slight Monotony; 1=Flat tone/Robotic)"
+    },
+    "Confidence": { # Personality
+        "weight_original": 7, 
+        "rubric": "1-5 (5=Bold & Confident throughout; 3=Confused/Nervous in parts; 1=Extremely nervous/Timid)"
+    },
+    "Attitude": { # Personality
+        "weight_original": 3, 
+        "rubric": "1-5 (5=Assertive, Positive, Open; 3=Neutral/Mildly defensive; 1=Aggressive/Pessimistic/Dismissive)"
+    },
+    "Flow & Fluency": { # Articulation
+        "weight_original": 20, 
+        "rubric": "1-5 (5=Excellent Fluency, Spontaneous; 3=Initially struggles, then manages/Takes some time; 1=Many fillers/Pauses/Dead silence)"
+    },
+    "Structured thoughts & Clarity": { # Articulation
+        "weight_original": 10, 
+        "rubric": "1-5 (5=Organized, Crisp, Coherent thoughts, e.g. STAR method; 3=Ideas are okay but clarity/structure could be better; 1=Incoherent/Rambling/Struggles to put thoughts into words)"
+    },
+    "Sentence Formation": { # Language Skills
+        "weight_original": 20, 
+        "rubric": "1-5 (5=Good Clarity, Variety in sentence structure, Good Vocab; 3=Decent communication, might find some words difficult; 1=Talks in fragments/one-liners, Hard to understand)"
     },
-    "Finance": {
-        "Fund Accounting": ["NAV", "mutual fund", "reconciliation", "journal entry"],
-        "AML/KYC": ["customer", "verification", "risk", "compliance", "money laundering"]
+    "Basics of Grammar + SVA": { # Language Skills (SVA = Subject-Verb Agreement)
+        "weight_original": 10, 
+        "rubric": "1-5 (5=Good Command over Language, Minimal errors; 3=Average communicator, some errors but understandable; 1=Makes a lot of Grammatical Errors impacting clarity)"
     },
-    "Soft Skills": {
-        "default": ["communication", "teamwork", "problem solving", "motivation", "adaptability"]
+    "Persuasiveness": { # Rapport Building
+        "weight_original": 3, 
+        "rubric": "1-5 (5=Impactful, Convincing Answers, Connects with interviewer; 3=Average or Common Answers; 1=Lacks Presence of Mind/No connection)"
+    },
+    "Quality of Answers": { # Rapport Building
+        "weight_original": 7, 
+        "rubric": "1-5 (5=Handles questions well, Relevant & Thoughtful Answers, Asks good questions; 3=Very Generic Answers; 1=Vague/Lacks Depth/Shallow/Irrelevant)"
     }
 }
 
-def score_answer(answer_text, domain, skill):
-    answer = answer_text.strip().lower()
-    if answer in ["", "[no response]", "no response", "skipped"]:
-        return 0.0
-    if any(phrase in answer for phrase in ["don't know", "not sure", "unaware"]):
-        return 0.0
+# Calculate total original weight for normalization
+TOTAL_ORIGINAL_WEIGHT_HR = sum(param_data["weight_original"] for param_data in HR_PARAMETERS_CONFIG.values()) # Should be 85
 
-    keywords = KEYWORDS.get(domain, {}).get(skill, KEYWORDS["Soft Skills"]["default"])
-    match_count = sum(1 for kw in keywords if kw in answer)
-    match_ratio = match_count / len(keywords) if keywords else 0
+# Add normalized weights to the config for calculating score out of 100
+for param in HR_PARAMETERS_CONFIG:
+    HR_PARAMETERS_CONFIG[param]["weight_normalized"] = (HR_PARAMETERS_CONFIG[param]["weight_original"] / TOTAL_ORIGINAL_WEIGHT_HR) * 100
 
-    if match_ratio == 0:
-        return 1.5
-    elif match_ratio <= 0.5:
-        return 3.0
-    else:
-        return 5.0
 
-# Evaluate candidate answers - YOUR FUNCTION
- 
+########################################///////////////////////////////////////////////////#########################################
+# SUmmary of improvement(function)
 
- 
-def evaluate_answers():
+def generate_improvement_suggestions():
     model = genai.GenerativeModel('gemini-1.5-pro-latest')
     difficulty_level = st.session_state.get("difficulty_level_select", "Beginner")
     level_string = difficulty_level.lower()
 
-    # --- Start: Check for all no-responses ---
-    all_no_response = True
     if not st.session_state.get("answers"):
-        all_no_response = True
-    else:
+        st.session_state.improvement_suggestions = "No answers were recorded to generate improvement suggestions."
+        return
+
+    # Prepare the context for the LLM
+    qa_context = []
+    for i, entry in enumerate(st.session_state["answers"]):
+        qa_context.append(
+            f"Question {i+1}: {entry['question']}\n"
+            f"Candidate's Answer {i+1}: {str(entry.get('response', '[No response provided]'))}"
+        )
+    full_qa_context = "\n\n".join(qa_context)
+
+    initial_evaluation_feedback = st.session_state.get("evaluation_feedback", "Initial evaluation not available.")
+
+    # Remove any previous "Total Calculated Score..." line from the initial feedback
+    # to avoid confusing the LLM when it sees it as part of the context.
+    initial_evaluation_lines = initial_evaluation_feedback.splitlines()
+    cleaned_initial_evaluation = "\n".join(
+        line for line in initial_evaluation_lines if not line.strip().startswith("**Total Calculated Score:**")
+    )
+
+
+    improvement_prompt_template = """
+    You are an expert interview coach. You have the following information about a candidate's mock interview:
+    - Candidate's Level: {level_string}
+    - Questions Asked and Candidate's Answers:
+    {full_qa_context}
+    - Initial Evaluation Feedback Provided to Candidate:
+    ---
+    {cleaned_initial_evaluation}
+    ---
+
+    Based on all this information, your task is to provide DETAILED and CONSTRUCTIVE suggestions for each question to help the candidate improve. Be supportive and encouraging.
+
+    For EACH question, please provide:
+    1.  **How to Improve This Answer:** Specific, actionable advice on what the candidate could have added, clarified, or approached differently to make their answer better for their {level_string} level. Focus on 1-2 key improvement points.
+    2.  **Hints for an Ideal Answer:** Briefly mention 2-3 key concepts, terms, or elements that a strong answer (appropriate for their {level_string} level) would typically include. DO NOT provide a full model answer, just hints and pointers.
+
+    Keep the tone positive and focused on learning.
+
+    Structure your response clearly for each question. Example for one question:
+
+    ---
+    **Regarding Question X: "[Original Question Text Here]"**
+
+    *How to Improve This Answer:*
+    [Your specific suggestion 1 for improvement...]
+    [Your specific suggestion 2 for improvement...]
+
+    *Hints for an Ideal Answer (Key Points to Consider):*
+    - Hint 1 or Key concept 1
+    - Hint 2 or Key concept 2
+    - Hint 3 or Key element 3 (optional)
+    ---
+    (Repeat this structure for all questions)
+    """
+
+    formatted_improvement_prompt = improvement_prompt_template.format(
+        level_string=level_string,
+        full_qa_context=full_qa_context,
+        cleaned_initial_evaluation=cleaned_initial_evaluation
+    )
+
+    try:
+        st.info("🤖 Generating detailed improvement suggestions... Please wait.")
+        response = model.generate_content(formatted_improvement_prompt)
+        st.session_state.improvement_suggestions = response.text.strip()
+        st.session_state.improvement_suggestions_generated = True
+        st.success("Detailed suggestions generated!")
+    except Exception as e:
+        st.error(f"Error generating improvement suggestions: {e}")
+        st.session_state.improvement_suggestions = f"Could not generate suggestions due to an error: {e}"
+        st.session_state.improvement_suggestions_generated = False
+
+########################################///////////////////////////////////////////////////#########################################
+
+# Evaluate candidate answers - YOUR FUNCTION
+
+
+
+def evaluate_answers():
+    model = genai.GenerativeModel('gemini-1.5-pro-latest')
+    # difficulty_level_select is the key for the difficulty selectbox in your sidebar
+    difficulty_level = st.session_state.get("difficulty_level_select", "Beginner") 
+    level_string = difficulty_level.lower()
+    num_answered_questions = len(st.session_state.get("answers", []))
+
+    # Reset improvement suggestions flag when re-evaluating
+    st.session_state.improvement_suggestions_generated = False
+    st.session_state.improvement_suggestions = ""
+
+    meaningful_answers_exist = False
+    if st.session_state.get("answers"):
         for entry in st.session_state["answers"]:
             response_text = str(entry.get('response', '')).strip().lower()
             no_response_placeholders = [
                 "", "[no response provided]", "[no response - timed out]",
                 "[no response]", "no response", "[could not understand audio]",
-                "[no clear response recorded]"
+                "[no clear response recorded]", "[no action - timed out before recording]",
+                "[no speech detected in recording time]", "[no speech recorded - time up]",
+                "[recording stopped manually, possibly empty]",
+                "[no action - did not start recording]",
+                "[no speech detected in recording phase]" 
             ]
             if response_text not in no_response_placeholders:
-                all_no_response = False
+                meaningful_answers_exist = True
                 break
     
-    if all_no_response:
-        st.session_state["evaluation_feedback"] = (
-            "**Overall Score:** 0/10\n"
-            "**Evaluation Summary:**\n"
-            "- Concept Understanding: N/A - No response provided.\n"
-            "- Communication: N/A - No response provided.\n"
-            "- Depth of Explanation: N/A - No response provided.\n"
-            "- Examples: N/A - No response provided.\n"
-            "- Logical Flow: N/A - No response provided.\n\n"
-            "The candidate did not provide any meaningful answers."
-        )
-        st.session_state["overall_score"] = 0
-        st.session_state["percentage_score"] = 0
+    if not meaningful_answers_exist:
+        no_answer_feedback_qualitative = "No meaningful answers were provided for evaluation.\n\n"
+        if st.session_state.selected_domain == "Soft Skills":
+            hr_params_na = "\n".join([f"- {param}: 0/5" for param in HR_PARAMETERS_CONFIG.keys()])
+            no_answer_feedback = (
+                 "No meaningful answers were provided for evaluation.\n\n"
+                f"**Parameter Scores (1-5):**\n{hr_params_na}\n\n"
+                "**Overall Qualitative Feedback:**\nCandidate did not provide responses to evaluate soft skills."
+            )
+            st.session_state["hr_parameter_scores_dict"] = {param: 0.0 for param in HR_PARAMETERS_CONFIG.keys()} # Store zeroed scores
+        else: # Non-HR domains
+            no_answer_feedback = (
+                "No meaningful answers were provided.\n"
+                "**Total Calculated Score:** 0.0 / 0.0 (0.0%)\n\n" # Placeholder for non-HR if no answers
+                "**Overall Evaluation Summary:** N/A"
+            )
+        st.session_state["evaluation_feedback"] = no_answer_feedback
+        st.session_state["overall_score"] = 0.0
+        st.session_state["percentage_score"] = 0.0
         return
-    # --- End: Check for all no-responses ---
-
-    base_assessment_criteria = """
-    Assess responses based on:
-    - Conceptual Understanding (effort and relevance more than perfect accuracy)
-    - Communication Clarity (can the core idea be understood?)
-    - Depth of Explanation (relative to expected level)
-    - Use of Examples (if any, and if appropriate for the level)
-    - Logical Flow (is there a basic structure or train of thought?)
-    """
 
-    if level_string == "beginner":
-        level_specific_instructions = """
-        You are an extremely understanding and encouraging interview evaluator for a **BEGINNER/FRESHER**. Your primary goal is to build confidence.
-        **Scoring Guidelines for Beginners:**
-        - Be VERY lenient. Focus on ANY sign of understanding or effort.
-        - A one-liner, if relevant, deserves a good score (e.g., 6-8/10). Partial correctness with effort: 7-9/10. Generally correct but brief: 8-10/10.(Just doubles the score)
-        - Only score 0/10 if completely irrelevant or no attempt.
-        - If all answers are empty/placeholders (like '[No response]'), overall score MUST be 0/10.
-        Provide highly positive, motivating feedback.
+    # --- BRANCHING FOR HR (SOFT SKILLS) VS OTHER DOMAINS ---
+    if st.session_state.selected_domain == "Soft Skills":
+        hr_prompt_parameter_list = ""
+        for param, config in HR_PARAMETERS_CONFIG.items():
+            hr_prompt_parameter_list += f"- **{param}:** {config['rubric']}\n"
+        
+        hr_prompt_template = f"""
+        You are an experienced HR interview evaluator assessing a candidate's soft skills based on their answers to interview questions.
+        The candidate's performance across ALL answers should inform your scores for the following parameters.
+
+        **Parameters to Score (Assign a score from 1 to 5 for each):**
+        {hr_prompt_parameter_list}
+
+        After providing a score (1-5) for each of the above parameters, also write an **Overall Qualitative Feedback** section. 
+        This section should summarize the candidate's general soft skill strengths and areas for improvement, based on their communication, engagement, and professionalism throughout the interview.
+
+        **REQUIRED OUTPUT FORMAT (Strictly Adhere):**
+
+        **Parameter Scores (1-5):**
+        Voice Modulation: [score]
+        Confidence: [score]
+        Attitude: [score]
+        Flow & Fluency: [score]
+        Structured thoughts & Clarity: [score]
+        Sentence Formation: [score]
+        Basics of Grammar + SVA: [score]
+        Persuasiveness: [score]
+        Quality of Answers: [score]
+
+        **Overall Qualitative Feedback:**
+        [Your holistic qualitative feedback here. Be encouraging and constructive.]
         """
-    elif level_string == "intermediate":
-        level_specific_instructions = """
-        You are a supportive evaluator for an **INTERMEDIATE** candidate. Expect reasonable conceptual grasp.
-        **Scoring Guidelines for Intermediate:**
-        - 7–10: Mostly correct, clear, good understanding.
-        - 4–6: Partially correct, or needs clarity/depth.
-        - 1–3: Largely incorrect or irrelevant.
-        - Overall score 0/10 if all responses are empty.
-        Provide balanced feedback.
+        candidate_responses_formatted_hr = "\n\n".join(
+            [f"Question {i+1}: {entry['question']}\nCandidate's Answer {i+1}: {str(entry.get('response', '[No response provided]'))}" 
+             for i, entry in enumerate(st.session_state["answers"])]
+        )
+        full_prompt_for_hr_evaluation = f"{hr_prompt_template}\n\nCandidate's Interview Answers (Consider all of these for holistic parameter scoring):\n{candidate_responses_formatted_hr}"
+
+        try:
+            response_content = model.generate_content(full_prompt_for_hr_evaluation)
+            full_llm_response_text = response_content.text.strip()
+            
+            print("--- LLM Output for HR Score Extraction ---")
+            print(full_llm_response_text)
+            print("-----------------------------------------")
+
+            hr_parameter_scores_parsed_dict = {} # To store parsed scores for each HR param
+            total_weighted_score_percentage = 0.0
+
+            for param_name_config, config_data in HR_PARAMETERS_CONFIG.items():
+                # Using a more specific regex, anchored to the start of a line (after optional list marker)
+                # re.escape ensures special characters in param_name_config are treated literally.
+                param_score_pattern = re.compile(
+                    r"^\s*(?:[\*\-]\s*)?" + re.escape(param_name_config.split('(')[0].strip()) + r"\s*[:\-–—]?\s*(\d+(?:\.\d+)?)\b", 
+                    re.IGNORECASE | re.MULTILINE
+                ) # \b for word boundary after score
+                
+                match = param_score_pattern.search(full_llm_response_text)
+                param_score = 1.0 # Default to 1 (lowest actual score) if not found or unparseable
+                if match:
+                    try:
+                        score_text = match.group(1)
+                        param_score = float(score_text)
+                        param_score = max(1.0, min(5.0, param_score)) # Clamp score strictly 1-5 for HR
+                        print(f"HR Param '{param_name_config}' - Matched text: '{score_text}', Parsed: {param_score}")
+                    except ValueError:
+                        print(f"HR Param '{param_name_config}' - ValueError parsing score from '{score_text}' in match '{match.group(0)}'. Defaulting to 1.0.")
+                        param_score = 1.0 
+                else:
+                    print(f"HR Param '{param_name_config}' - Score pattern not found. Defaulting to 1.0 for this param.")
+                
+                hr_parameter_scores_parsed_dict[param_name_config] = param_score
+                total_weighted_score_percentage += (param_score / 5.0) * config_data["weight_normalized"] # Use normalized weight
+            
+            st.session_state["hr_parameter_scores_dict"] = hr_parameter_scores_parsed_dict # Store for table display
+            st.session_state["overall_score"] = round(total_weighted_score_percentage, 1) 
+            st.session_state["percentage_score"] = round(total_weighted_score_percentage, 1)
+            
+            # Construct the feedback to be displayed: Parsed scores + Qualitative from LLM
+            # The full_llm_response_text might still be useful if qualitative parsing is tricky
+            parsed_scores_display_text = "**Parsed Parameter Scores (1-5 based on AI Evaluation):**\n"
+            for p_name, p_score in hr_parameter_scores_parsed_dict.items():
+                parsed_scores_display_text += f"- {p_name}: {p_score:.1f}/5\n"
+            
+            qualitative_feedback_hr_extract = "Overall qualitative feedback section not clearly identified in AI response."
+            qualitative_match_hr = re.search(r"\*\*Overall Qualitative Feedback:\*\*(.*)", full_llm_response_text, re.DOTALL | re.IGNORECASE)
+            if qualitative_match_hr:
+                qualitative_feedback_hr_extract = qualitative_match_hr.group(1).strip()
+            
+            st.session_state["evaluation_feedback"] = f"{parsed_scores_display_text}\n\n**Overall Qualitative Feedback from AI:**\n{qualitative_feedback_hr_extract}"
+
+        except Exception as e_hr_eval:
+            st.error(f"Error during HR/Soft Skills evaluation processing: {e_hr_eval}")
+            print(f"HR EVALUATION PROCESSING TRACEBACK:\n{traceback.format_exc()}")
+            st.session_state["evaluation_feedback"] = f"Could not process HR skills evaluation: {e_hr_eval}"
+            st.session_state["overall_score"] = 0.0
+            st.session_state["percentage_score"] = 0.0
+
+    else: # --- NON-HR (Analytics, Finance) Evaluation Logic ---
+        base_assessment_criteria_qualitative_non_hr = """
+        For the OVERALL qualitative summary, assess responses based on:
+        - Conceptual Understanding (effort and relevance more than perfect accuracy for the level)
+        - Communication Clarity (can the core idea be understood?)
+        - Depth of Explanation (relative to expected level)
+        - Use of Examples (if any, and if appropriate for the level)
+        - Logical Flow (is there a basic structure or train of thought?)
         """
-    else: # Advanced
-        level_specific_instructions = """
-        You are a discerning evaluator for an **ADVANCED** candidate. Expect accuracy and depth.
-        **Scoring Guidelines for Advanced:**
-        - 8–10: Accurate, comprehensive, deep understanding.
-        - 5–7: Generally correct but lacks some depth/precision.
-        - 1–4: Significant inaccuracies or superficial.
-        - Overall score 0/10 if all responses are empty.
-        Provide precise feedback.
+        per_question_scoring_guidelines_non_hr = f"""
+        For EACH question and its answer, provide a score from 0 to 5 points.
+        The candidate is at a {level_string} level.
+        Consider the following when assigning the per-question score:
+        - Effort and relevance of the answer.
+        - Clarity of thought for the candidate's level.
+        - Basic logical structure.
+        - Use of examples, if any were given and appropriate.
         """
-
-    evaluation_prompt_template = f"""
-    {level_specific_instructions}
-    {base_assessment_criteria}
-
-    **YOUR RESPONSE MUST STRICTLY START WITH THE OVERALL SCORE ON THE VERY FIRST LINE.**
-    Follow this exact format for your entire output:
-
-    *Overall Score:* [score]/10
-    *Evaluation Summary:*
-    - Concept Understanding: [Your feedback here]
-    - Communication: [Your feedback here]
-    - Depth of Explanation: [Your feedback here]
-    - Examples: [Your feedback here]
-    - Logical Flow: [Your feedback here]
-    [Any additional overall encouraging remarks can optionally follow here]
-
-    The [score] must be a number (e.g., 7 or 7.5) between 0 and 10.
-    """
-
-    candidate_responses_formatted = "\n\n".join(
-        [f"Q: {entry['question']}\nA: {str(entry.get('response', '[No response provided]'))}" for entry in st.session_state["answers"]]
-    )
-    full_prompt_for_evaluation = f"{evaluation_prompt_template}\n\nCandidate Responses:\n{candidate_responses_formatted}"
-
-    try:
-        response_content = model.generate_content(full_prompt_for_evaluation)
-        st.session_state["evaluation_feedback"] = response_content.text.strip()
-        
-        extracted_text_for_scoring = response_content.text.strip()
-        print("--- LLM Output for Score Extraction (evaluate_answers) ---")
-        print(extracted_text_for_scoring)
-        print("----------------------------------------------------------")
+        if level_string == "beginner":
+            level_specific_instructions_non_hr = """
+            You are an **extremely understanding, encouraging, and supportive** interview evaluator for a **BEGINNER/FRESHER**. Your primary goal is to **build confidence**.
+            **Scoring Guidelines for Beginners (0-5 points per question):**
+            - **5 points:** Generally correct and relevant, even if brief. Shows clear effort and basic understanding.
+            - **4 points:** Good attempt, relevant, shows some understanding or key terms (e.g., one/two relevant words).
+            - **3 points:** Tries, somewhat related, or acknowledges question with a vague thought.
+            - **1-2 points:** Minimal effort, mostly irrelevant, but an attempt beyond silence.
+            - **0 points:** Completely irrelevant, no attempt, or placeholder.
+            Provide VERY positive feedback.
+            """
+        elif level_string == "intermediate":
+            level_specific_instructions_non_hr = """Supportive evaluator for **INTERMEDIATE**. Scoring (0-5): 5=Correct/Clear; 3-4=Mostly correct; 1-2=Partial/Gaps; 0=Incorrect."""
+        else: # Advanced
+            level_specific_instructions_non_hr = """Discerning evaluator for **ADVANCED**. Scoring (0-5): 5=Accurate/Comprehensive; 3-4=Correct lacks nuance; 1-2=Inaccurate; 0=Fundamentally incorrect."""
         
-        overall_score_val = 0.0 
+        evaluation_prompt_template_non_hr = f"""
+        {level_specific_instructions_non_hr} 
+        {per_question_scoring_guidelines_non_hr}
+        {base_assessment_criteria_qualitative_non_hr}
+        **YOUR RESPONSE MUST STRICTLY FOLLOW THIS FORMAT. PROVIDE SCORES FOR EACH QUESTION.**
+        Output format:
+
+        **Per-Question Scores:**
+        Question 1 Score: [Score for Q1 out of 5]
+        ... (repeat for all {num_answered_questions} questions provided)
+
+        **Overall Evaluation Summary:**
+        - Concept Understanding: [Overall qualitative feedback here]
+        - Communication: [Overall qualitative feedback here]
+        - Depth of Explanation: [Overall qualitative feedback here]
+        - Examples: [Overall qualitative feedback here]
+        - Logical Flow: [Overall qualitative feedback here]
+        [Any additional overall encouraging remarks can optionally follow here]
+        """
+        candidate_responses_formatted_non_hr = "\n\n".join(
+            [f"Question {i+1}: {entry['question']}\nAnswer {i+1}: {str(entry.get('response', '[No response provided]'))}" for i, entry in enumerate(st.session_state["answers"])]
+        )
+        full_prompt_for_non_hr_evaluation = f"{evaluation_prompt_template_non_hr}\n\nCandidate Responses:\n{candidate_responses_formatted_non_hr}"
+
+        try:
+            response_content_non_hr = model.generate_content(full_prompt_for_non_hr_evaluation)
+            full_llm_response_text_non_hr = response_content_non_hr.text.strip()
+            raw_llm_feedback_non_hr = full_llm_response_text_non_hr
+            
+            print("--- LLM Output for Non-HR Score Extraction ---"); print(full_llm_response_text_non_hr); print("---")
+            
+            total_score_non_hr = 0.0; parsed_scores_count_non_hr = 0; per_question_scores_list_non_hr = []
+            score_line_pattern_non_hr = re.compile(r"Question\s*(\d+)\s*Score:\s*(\d+(?:\.\d+)?)(?:\s*/\s*5)?", re.IGNORECASE)
+            text_to_search_non_hr = full_llm_response_text_non_hr
+            scores_block_match_non_hr = re.search(r"(?i)\*\*Per-Question Scores:\*\*(.*?)(?=\*\*Overall Evaluation Summary:\*\*|\Z)", text_to_search_non_hr, re.DOTALL)
+            
+            if scores_block_match_non_hr: 
+                text_to_search_non_hr = scores_block_match_non_hr.group(1).strip()
+                print(f"Non-HR: Found 'Per-Question Scores' block:\n{text_to_search_non_hr}")
+            else:
+                print("Non-HR: No dedicated 'Per-Question Scores' block found; searching entire response.")
 
-        # Pattern 1: More flexible, looks for "Overall Score" then captures number/10
-        score_pattern_flexible = r"(?i).*Overall Score[\s:]*(\d+(?:\.\d+)?)\s*/\s*10"
-        score_match = re.search(score_pattern_flexible, extracted_text_for_scoring)
 
-        if score_match:
-            try:
-                score_text = score_match.group(1)
-                print(f"Flexible Pattern Matched! Score text: '{score_text}', Full context: '{score_match.group(0)}'")
-                overall_score_val = float(score_text)
-                if overall_score_val.is_integer():
-                    overall_score_val = int(overall_score_val)
-                print(f"Parsed score value: {overall_score_val}")
-            except ValueError:
-                st.warning(f"Flexible pattern matched, but could not parse '{score_text}' as a number. Defaulting score to 0.")
-                print(f"ValueError during parsing (flexible pattern). Score text: '{score_text}'")
-                overall_score_val = 0.0
-        else:
-            # Fallback Pattern: Simplest possible X/10 if "Overall Score" line completely missing/mangled
-            score_pattern_fallback = r"(\d+(?:\.\d+)?)\s*/\s*10"
-            # Search for fallback only if primary pattern fails
-            print(f"Flexible pattern ('{score_pattern_flexible}') did not match. Trying fallback.")
-            score_match_fallback = re.search(score_pattern_fallback, extracted_text_for_scoring)
-            if score_match_fallback:
+            for match_non_hr in score_line_pattern_non_hr.finditer(text_to_search_non_hr):
+                q_num_text_non_hr, score_val_text_non_hr = match_non_hr.group(1), match_non_hr.group(2)
                 try:
-                    score_text = score_match_fallback.group(1)
-                    print(f"Fallback Pattern Matched! Score text: '{score_text}', Full context: '{score_match_fallback.group(0)}'")
-                    overall_score_val = float(score_text)
-                    if overall_score_val.is_integer():
-                        overall_score_val = int(overall_score_val)
-                    print(f"Parsed score value (from fallback): {overall_score_val}")
-                    st.warning("Used fallback regex to find score. LLM format for 'Overall Score' line was unexpected.")
+                    score_non_hr = float(score_val_text_non_hr)
+                    score_non_hr = max(0.0, min(5.0, score_non_hr))
+                    total_score_non_hr += score_non_hr
+                    parsed_scores_count_non_hr += 1
+                    per_question_scores_list_non_hr.append(f"Question {q_num_text_non_hr}: {score_non_hr:.1f}/5")
+                    print(f"Non-HR Matched Q{q_num_text_non_hr} Score: {score_non_hr}")
                 except ValueError:
-                    st.warning(f"Fallback pattern matched, but could not parse '{score_text}' as a number. Score set to 0.")
-                    print(f"ValueError during parsing (fallback pattern). Score text: '{score_text}'")
-                    overall_score_val = 0.0
-            else:
-                st.warning(f"Could not find any 'X/10' score pattern in the LLM response. Score defaulted to 0. LLM Output (first 300 chars):\n{extracted_text_for_scoring[:300]}...")
-                print(f"All score patterns failed. LLM output did not contain a recognizable score.")
-                overall_score_val = 0.0
-        
-        st.session_state["overall_score"] = overall_score_val
-        st.session_state["percentage_score"] = float(overall_score_val) * 10 
-
-    except Exception as e:
-        st.error(f"An error occurred during evaluation or score parsing: {e}")
-        st.session_state["evaluation_feedback"] = (
-            f"Could not evaluate answers due to an error: {e}. "
-            f"LLM output might be missing or malformed."
-        )
-        st.session_state["overall_score"] = 0
-        st.session_state["percentage_score"] = 0
-
+                    print(f"Non-HR Warning: Could not parse score '{score_val_text_non_hr}' from: '{match_non_hr.group(0)}'")
+            
+            if parsed_scores_count_non_hr != num_answered_questions and meaningful_answers_exist: 
+                 st.warning(f"Non-HR Score Count Mismatch: Parsed {parsed_scores_count_non_hr} scores, expected {num_answered_questions}.")
+                 print(f"Non-HR Score Count Mismatch: Expected {num_answered_questions}, got {parsed_scores_count_non_hr}")
+
+            if parsed_scores_count_non_hr == 0 and meaningful_answers_exist: 
+                 st.warning("CRITICAL (Non-HR): No per-question scores parsed from LLM response. Total score set to 0.")
+                 print("CRITICAL (Non-HR): No per-question scores parsed.")
+                 total_score_non_hr = 0.0
+
+            max_score_non_hr = num_answered_questions * 5.0
+            st.session_state["overall_score"] = total_score_non_hr
+            st.session_state["percentage_score"] = (total_score_non_hr / max_score_non_hr) * 100.0 if max_score_non_hr > 0 else 0.0
+            
+            final_feedback_non_hr = f"**Total Calculated Score:** {st.session_state['overall_score']:.1f} / {max_score_non_hr:.1f}  ({st.session_state['percentage_score']:.1f}%)\n\n"
+            if per_question_scores_list_non_hr: 
+                final_feedback_non_hr += "**Parsed Per-Question Scores:**\n" + "\n".join(per_question_scores_list_non_hr) + "\n\n"
+            
+            qual_summary_match_non_hr = re.search(r"\*\*Overall Evaluation Summary:\*\*(.*)", raw_llm_feedback_non_hr, re.DOTALL | re.IGNORECASE)
+            if qual_summary_match_non_hr: 
+                final_feedback_non_hr += "**Overall Qualitative Summary (from AI):**\n" + qual_summary_match_non_hr.group(1).strip()
+            else: 
+                final_feedback_non_hr += "\n---\n**Full AI Response (for context if summary parsing failed):**\n" + raw_llm_feedback_non_hr
+            st.session_state["evaluation_feedback"] = final_feedback_non_hr.strip()
+
+        except Exception as e_non_hr_eval:
+            st.error(f"Error during Non-HR evaluation processing: {e_non_hr_eval}")
+            print(f"NON-HR EVALUATION PROCESSING TRACEBACK:\n{traceback.format_exc()}")
+            st.session_state["evaluation_feedback"] = f"Could not process Non-HR evaluation: {e_non_hr_eval}"
+            st.session_state["overall_score"] = 0.0
+            st.session_state["percentage_score"] = 0.0
+########################################///////////////////////////////////////////////////#########################################
 # --- Prompts for Question Generation ---
 BEGINNER_PROMPT = """
 You are a friendly mock interview trainer conducting a **Beginner-level** spoken interview in the domain of **{domain}**.
@@ -387,7 +553,7 @@ Ensure the questions are clear, to the point, and suitable for a {difficulty_lev
     ❌ Avoid vague or open-ended statements—each question should be concise and specific.
 """
 
-
+########################################///////////////////////////////////////////////////#########################################
 # UI styles
 st.markdown("""
 <style>
@@ -511,17 +677,8 @@ if st.session_state["selected_domain"] == "Soft Skills":
 st.sidebar.subheader("Select Interview Domain:")
 for domain in ["Analytics", "Finance", "Soft Skills"]:
     if st.sidebar.button(domain):
+        st.session_state.clear()  # 🔁 Reset entire session state
         st.session_state["selected_domain"] = domain
-        st.session_state["generated_questions"] = []
-        st.session_state["current_question_index"] = 0
-        st.session_state["answers"] = []
-        st.session_state["evaluation_feedback"] = ""
-        st.session_state["recorded_text"] = ""
-        st.session_state["response_captured"] = False
-        st.session_state["timer_start"] = None
-        st.session_state["show_summary"] = False
-        st.session_state["question_played"] = False
-        st.session_state["recording_complete"] = False
         st.rerun()
 
 if not st.session_state["selected_domain"]:
@@ -550,28 +707,66 @@ else:
         input_text = st.sidebar.text_area("Paste Job Description:")
 
     elif section_choice == "Skills":
-        # Define available skills for each domain
-        skills = {
-            "Analytics": ["Python", "SQL", "Machine Learning", "Statistics", "Business Analytics"],
-            "Finance": ["Fund Accounting", "AML/KYC", "Derivatives"]
+        input_text = ""
+
+        if st.session_state["selected_domain"] == "Finance":
+            finance_levels = ["Level-1", "Level-2", "Level-3"]
+            selected_level = st.sidebar.selectbox("Select a Finance Level:", finance_levels, key="finance_level_select")
+
+            difficulty = st.session_state.get("difficulty", "Beginner")
+
+            if selected_level != "Level-1":
+                st.sidebar.warning(f"🚧 {selected_level} content is still under development. Please select Level-1 to continue.")
+                st.stop()
+
+            # Map difficulty level to column in Excel
+            column_map = {
+                "Beginner": "MODULE 1-EASY",
+                "Intermediate": "MODULE 1-MEDIUM",
+                "Advanced": "MODULE 1-DIFFICULT"
+            }
+
+            selected_column = column_map[difficulty]
+
+            # Load Excel and questions
+            excel_path = os.path.join("data", "CIBOP Mock Questions.xlsx")
+            try:
+                df = pd.read_excel(excel_path, engine="openpyxl")
+                questions_from_excel = df[selected_column].dropna().astype(str).tolist()
+                input_text = selected_column  # Optional, for tracking
+            except Exception as e:
+                st.sidebar.error(f"❌ Error reading Excel file: {e}")
+                st.stop()
+
+            st.sidebar.success(f"✅ Loaded {difficulty}-level questions from {selected_level}")
+
+        else:
+            # For Analytics or any other domain
+            skills = {
+                "Analytics": ["Python", "SQL", "Machine Learning", "Statistics", "Business Analytics"]
             }
-        skill_list = skills.get(st.session_state["selected_domain"], [])
-        if skill_list:
-            selected_skill = st.sidebar.selectbox("Select a Skill:", skill_list, key="skill_select")
-            input_text = selected_skill
-            st.sidebar.markdown(f"✅ Selected Skill: **{selected_skill}**")  # Debug display
+            skill_list = skills.get(st.session_state["selected_domain"], [])
+            if skill_list:
+                selected_skill = st.sidebar.selectbox("Select a Skill:", skill_list, key="skill_select")
+                input_text = selected_skill
+                st.sidebar.markdown(f"✅ Selected Skill: **{selected_skill}**")
+
 
     if st.sidebar.button("Generate Questions"):
         if not input_text.strip():
             st.warning("⚠️ Please provide input based on the selected method.")
             st.stop()
 
-        prompt = f"Ask {num_qs} direct and core-level {difficulty} interview questions related to {input_text}. Do not include intros or numbering."
-        model = genai.GenerativeModel('gemini-1.5-pro-latest')
-        response = model.generate_content([prompt, input_text])
-        lines = response.text.strip().split("\n")
-        questions = [q.strip("* ") for q in lines if q.strip()]
-        st.session_state["generated_questions"] = questions[:num_qs]
+        if st.session_state["selected_domain"] == "Finance" and section_choice == "Skills":
+            st.session_state["generated_questions"] = sample(questions_from_excel, min(num_qs, len(questions_from_excel)))
+        else:
+            prompt = f"Ask {num_qs} direct and core-level {difficulty} interview questions related to {input_text}. Do not include intros or numbering."
+            model = genai.GenerativeModel('gemini-1.5-pro-latest')
+            response = model.generate_content([prompt, input_text])
+            lines = response.text.strip().split("\n")
+            questions = [q.strip("* ") for q in lines if q.strip()]
+            st.session_state["generated_questions"] = questions[:num_qs]
+
         st.session_state["current_question_index"] = 0
         st.session_state["answers"] = []
         st.session_state["evaluation_feedback"] = ""
@@ -696,30 +891,39 @@ if st.session_state["generated_questions"]:
                 st.rerun()
 
 
+# === Summary Display ===
+ 
 # === Summary Display ===
 if st.session_state.get("show_summary", False):
-    # st.balloons()
     st.subheader("📊 Complete Mock Interview Summary")
 
-    feedback_content = st.session_state.get('evaluation_feedback', "Evaluation not yet available.")
-    if not isinstance(feedback_content, str):
-        feedback_content = str(feedback_content)
+    # Fetch values from session state, providing defaults
+    feedback_content_for_display = st.session_state.get('evaluation_feedback', "Evaluation details not available.")
+    if not isinstance(feedback_content_for_display, str):
+        feedback_content_for_display = str(feedback_content_for_display)
     
-    # Escape HTML special characters from the feedback for security
-    escaped_feedback_for_html = escape(feedback_content)
-    # Replace newlines with <br> for HTML display within markdown
-    formatted_feedback_for_markdown = escaped_feedback_for_html.replace("\n", "<br>")
+    # Max score basis is the number of questions that were *generated* for the session
+    num_qs_in_session = len(st.session_state.get("generated_questions", [])) 
+    if num_qs_in_session == 0 and st.session_state.get("answers"): # Fallback if no generated_questions but answers exist
+        num_qs_in_session = len(st.session_state.answers)
+
+    max_score_possible_for_session = num_qs_in_session * 5.0
+    current_percentage_score = st.session_state.get('percentage_score', 0.0)
+    current_overall_score = st.session_state.get('overall_score', 0.0)
 
+    # Display the calculated score and percentage bar first in a card
     st.markdown(f"""
-        <div class='summary-card'>
-            <h4 style="color: #212529;">✅ <strong>Overall Score (Model Evaluation):</strong></h4>{st.session_state.get('percentage_score', 0):.0f}% ({st.session_state.get('overall_score',0)}/10)</h4>
+        <div class='summary-card' style="margin-bottom: 20px;">
+            <h4 style="color: #212529;">✅ <strong>Overall Score:</strong> {current_overall_score:.1f} / {max_score_possible_for_session:.1f} 
+                ({current_percentage_score:.1f}%)
+            </h4>
             <div style='margin:10px 0; position:relative;'>
-                <div style="color: #212529; background-color: #00c851; border-radius:10px; overflow:hidden; height:30px; position:relative;">
+                <div style="background:#eee; border-radius:10px; overflow:hidden; height:30px; position:relative;">
                     <div style="
-                        width:{st.session_state.get('percentage_score', 0)}%;
-                        background:#00c851;
+                        width:{current_percentage_score}%; 
+                        background:#00c851; /* Green for progress */
                         height:100%;
-                        border-radius:10px 0 0 10px;
+                        border-radius:10px 0 0 10px; /* Keep left radius for progress */
                         transition: width 0.4s ease-in-out;
                     "></div>
                     <div style="
@@ -732,17 +936,99 @@ if st.session_state.get("show_summary", False):
                         align-items:center;
                         justify-content:center;
                         font-weight:bold;
-                        color: black !important; 
+                        color: black !important; /* Ensure text is visible on green/grey */
                         font-size: 0.9rem;
-                        user-select:none;
+                        user-select:none; /* Prevent text selection */
                     ">
-                        {st.session_state.get('percentage_score', 0):.0f}%
+                        {current_percentage_score:.1f}% 
                     </div>
                 </div>
             </div>
-            <h4 style="color: #212529;">Detailed Evaluation:</h4>
-            <div style="color: #212529; background-color: #ffffff; padding: 10px; border-radius: 5px; border: 1px solid #eee; margin-top: 5px; white-space: pre-wrap; word-wrap: break-word; max-height: 400px; overflow-y: auto;">
-                {formatted_feedback_for_markdown}
-            </div>
         </div>
     """, unsafe_allow_html=True)
+
+    # Display the detailed evaluation feedback text in a separate section
+    st.markdown("---") 
+    st.markdown("<h4 style='color: #212529;'>Detailed Evaluation & Feedback from AI:</h4>", unsafe_allow_html=True)
+    
+    # Use a styled div for the feedback text block to ensure good readability
+    # Replace newlines with <br> for proper HTML multiline display
+    html_formatted_feedback = feedback_content_for_display.replace('\n', '<br>')
+    st.markdown(f"""
+    <div style="background-color: #ffffff; color: #212529; padding: 15px; border-radius: 8px; border: 1px solid #e0e0e0; margin-top:10px; max-height: 500px; overflow-y: auto; white-space: normal; word-wrap: break-word;">
+    {html_formatted_feedback}
+    </div>
+    """, unsafe_allow_html=True)
+    
+    st.markdown("---") # Separator
+
+    # Buttons for suggestions, download, practice
+    cols_summary_buttons = st.columns([1, 1, 1]) # 3 columns for the buttons
+
+    with cols_summary_buttons[0]:
+        if st.button("💡 Get Improvement Suggestions", key="get_suggestions_btn_final", use_container_width=True):
+            # Regenerate suggestions if not present or explicitly requested again
+            generate_improvement_suggestions() # This function should handle st.info/st.success
+            st.rerun() # Rerun to show the expander or updated suggestions
+
+    # Helper function to prepare summary text for download
+    def prepare_summary_for_download():
+        download_text = f"# GrillMaster Mock Interview Summary\n\n"
+        download_text += f"**Selected Domain:** {st.session_state.get('selected_domain', 'N/A')}\n"
+        dl_difficulty = st.session_state.get('difficulty_level_select', 'N/A')
+        download_text += f"**Difficulty Level:** {dl_difficulty}\n"
+        
+        num_q_for_max_score = len(st.session_state.get("generated_questions", st.session_state.get("answers",[])))
+        max_s_for_dl = num_q_for_max_score * 5.0
+        
+        download_text += f"**Calculated Overall Score:** {st.session_state.get('overall_score', 0.0):.1f} / {max_s_for_dl:.1f} ({st.session_state.get('percentage_score', 0.0):.1f}%)\n\n"
+        
+        download_text += "## Questions & Candidate's Answers:\n"
+        num_answers_actually_given = len(st.session_state.get("answers", []))
+        for i in range(num_q_for_max_score):
+            question_text_dl = st.session_state.generated_questions[i] if i < len(st.session_state.generated_questions) else "Question text not found"
+            answer_text_dl = "[No answer recorded]"
+            if i < num_answers_actually_given:
+                answer_text_dl = str(st.session_state.answers[i].get('response', '[No response provided]'))
+            
+            download_text += f"**Question {i+1}:** {question_text_dl}\n"
+            download_text += f"**Your Answer {i+1}:** {answer_text_dl}\n\n"
+        
+        download_text += "\n## AI Evaluation Details (Includes Parsed Scores and Qualitative Feedback):\n"
+        # st.session_state.evaluation_feedback is now already pre-formatted
+        download_text += st.session_state.get('evaluation_feedback', "No AI evaluation available.")
+        download_text += "\n\n"
+
+        if st.session_state.get("improvement_suggestions_generated", False) and st.session_state.get("improvement_suggestions"):
+            download_text += "\n## Detailed Improvement Suggestions from AI:\n"
+            download_text += st.session_state.get('improvement_suggestions', "No improvement suggestions were generated.")
+        
+        return download_text.encode('utf-8')
+
+    with cols_summary_buttons[1]:
+        summary_bytes_dl_final = prepare_summary_for_download()
+        st.download_button(
+            label="💾 Download Full Summary", 
+            data=summary_bytes_dl_final,
+            file_name=f"GrillMaster_Summary_{st.session_state.get('selected_domain','General')}_{time.strftime('%Y%m%d_%H%M')}.md",
+            mime="text/markdown", 
+            key="download_summary_final_btn", 
+            use_container_width=True
+        )
+    
+    
+
+    # Expander for detailed suggestions, shown if generated
+    if st.session_state.get("improvement_suggestions_generated", False) and st.session_state.get("improvement_suggestions"):
+        with st.expander("🔍 View Detailed Improvement Suggestions", expanded=True): # Default to expanded once generated
+            st.markdown(st.session_state.improvement_suggestions, unsafe_allow_html=True) # LLM might use markdown
+
+    # Conditional button for low scores
+    if current_percentage_score < 50.0:
+        st.warning(f"Your score is {current_percentage_score:.1f}%. Keep practicing! You can also reset all settings to try a new domain or difficulty.")
+        if st.button("🔁 Practice Again & Reset All Settings", key="practice_full_reset_final_btn", use_container_width=True):
+            # Clear all session state keys and re-initialize to defaults
+            keys_to_fully_clear = list(st.session_state.keys())
+            for key_to_del_full in keys_to_fully_clear:
+                del st.session_state[key_to_del_full]
+