app.py

import os
import io
import streamlit as st
import docx
import docx2txt
import tempfile
import time
import re
import math
import concurrent.futures
import pandas as pd
from functools import lru_cache
from transformers import pipeline

# Set page title and hide sidebar
st.set_page_config(
    page_title="Resume-Job Fit Analyzer",
    initial_sidebar_state="collapsed"
)

# Hide sidebar completely with custom CSS
st.markdown("""
<style>
    [data-testid="collapsedControl"] {display: none;}
    section[data-testid="stSidebar"] {display: none;}
</style>
""", unsafe_allow_html=True)

#####################################
# Preload Models
#####################################
@st.cache_resource(show_spinner=True)
def load_models():
    """Load models at startup"""
    with st.spinner("Loading AI models... This may take a minute on first run."):
        models = {}
        # Use bart-base for summarization
        models['summarizer'] = pipeline(
            "summarization", 
            model="facebook/bart-base", 
            max_length=100,
            truncation=True
        )
        
        # Load sentiment model for evaluation
        models['evaluator'] = pipeline(
            "sentiment-analysis", 
            model="distilbert/distilbert-base-uncased-finetuned-sst-2-english"
        )
        
        return models

# Preload models immediately when app starts
models = load_models()

#####################################
# Function: Extract Text from File
#####################################
@st.cache_data(show_spinner=False)
def extract_text_from_file(file_obj):
    """
    Extract text from .docx and .doc files.
    Returns the extracted text or an error message if extraction fails.
    """
    filename = file_obj.name
    ext = os.path.splitext(filename)[1].lower()
    text = ""

    if ext == ".docx":
        try:
            document = docx.Document(file_obj)
            text = "\n".join(para.text for para in document.paragraphs if para.text.strip())
        except Exception as e:
            text = f"Error processing DOCX file: {e}"
    elif ext == ".doc":
        try:
            # For .doc files, we need to save to a temp file
            with tempfile.NamedTemporaryFile(delete=False, suffix='.doc') as temp_file:
                temp_file.write(file_obj.getvalue())
                temp_path = temp_file.name
        
            # Use docx2txt which is generally faster
            try:
                text = docx2txt.process(temp_path)
            except Exception:
                text = "Could not process .doc file. Please convert to .docx format."
        
            # Clean up temp file
            os.unlink(temp_path)
        except Exception as e:
            text = f"Error processing DOC file: {e}"
    elif ext == ".txt":
        try:
            text = file_obj.getvalue().decode("utf-8")
        except Exception as e:
            text = f"Error processing TXT file: {e}"
    else:
        text = "Unsupported file type. Please upload a .docx, .doc, or .txt file."
    
    # Limit text size for faster processing
    return text[:15000] if text else text

#####################################
# Functions for Information Extraction
#####################################

# Cache the extraction functions to avoid reprocessing
@lru_cache(maxsize=32)
def extract_name(text_start):
    """Extract candidate name from the beginning of resume text"""
    # Only use the first 500 characters to speed up processing
    lines = text_start.split('\n')
    
    # Check first few non-empty lines for potential names
    potential_name_lines = [line.strip() for line in lines[:5] if line.strip()]
    
    if potential_name_lines:
        # First line is often the name if it's short and doesn't contain common headers
        first_line = potential_name_lines[0]
        if 5 <= len(first_line) <= 40 and not any(x in first_line.lower() for x in ["resume", "cv", "curriculum", "vitae", "profile"]):
            return first_line
    
    # Look for lines that might contain a name
    for line in potential_name_lines[:3]:
        if len(line.split()) <= 4 and not any(x in line.lower() for x in ["address", "phone", "email", "resume", "cv"]):
            return line

    return "Unknown (please extract from resume)"

def extract_age(text):
    """Extract candidate age from resume text"""
    # Simplified: just check a few common patterns
    age_patterns = [
        r'age:?\s*(\d{1,2})',
        r'(\d{1,2})\s*years\s*old',
    ]
    
    text_lower = text.lower()
    for pattern in age_patterns:
        matches = re.search(pattern, text_lower)
        if matches:
            return matches.group(1)
    
    return "Not specified"

def extract_industry(text, base_summary):
    """Extract expected job industry from resume"""
    # Simplified industry keywords focused on the most common ones
    industry_keywords = {
        "technology": ["software", "programming", "developer", "IT", "tech", "computer"],
        "finance": ["banking", "financial", "accounting", "finance", "analyst"],
        "healthcare": ["medical", "health", "hospital", "clinical", "nurse", "doctor"],
        "education": ["teaching", "teacher", "professor", "education", "university"],
        "marketing": ["marketing", "advertising", "digital marketing", "social media"],
        "engineering": ["engineer", "engineering"],
        "data science": ["data science", "machine learning", "AI", "analytics"],
        "information systems": ["information systems", "ERP", "systems management"]
    }
    
    # Count occurrences of industry keywords - using the summary to speed up
    combined_text = base_summary.lower()
    
    counts = {}
    for industry, keywords in industry_keywords.items():
        counts[industry] = sum(combined_text.count(keyword.lower()) for keyword in keywords)
    
    # Get the industry with the highest count
    if counts:
        likely_industry = max(counts.items(), key=lambda x: x[1])
        if likely_industry[1] > 0:
            return likely_industry[0].capitalize()
    
    # Check for educational background that might indicate industry
    degrees = ["computer science", "business", "engineering", "medicine", "education", "finance", "marketing"]
    
    for degree in degrees:
        if degree in combined_text:
            return f"{degree.capitalize()}-related field"
    
    return "Not clearly specified"

def extract_skills_and_work(text):
    """Extract both skills and work experience at once to save processing time"""
    # Common skill categories - reduced keyword list for speed
    skill_categories = {
        "Programming": ["Python", "Java", "JavaScript", "HTML", "CSS", "SQL", "C++", "C#", "Go"],
        "Data Science": ["Machine Learning", "Data Analysis", "Statistics", "TensorFlow", "PyTorch", "AI", "Algorithms"],
        "Database": ["SQL", "MySQL", "MongoDB", "Database", "NoSQL", "PostgreSQL"],
        "Web Development": ["React", "Angular", "Node.js", "Frontend", "Backend", "Full-Stack"],
        "Software Development": ["Agile", "Scrum", "Git", "DevOps", "Docker", "System Design"],
        "Cloud": ["AWS", "Azure", "Google Cloud", "Cloud Computing"],
        "Security": ["Cybersecurity", "Network Security", "Encryption", "Security"],
        "Business": ["Project Management", "Business Analysis", "Leadership", "Teamwork"],
        "Design": ["UX/UI", "User Experience", "Design Thinking", "Adobe"]
    }
    
    # Work experience extraction
    work_headers = [
        "work experience", "professional experience", "employment history", 
        "work history", "experience"
    ]
    
    next_section_headers = [
        "education", "skills", "certifications", "projects", "achievements"
    ]
    
    # Process everything at once
    lines = text.split('\n')
    text_lower = text.lower()
    
    # Skills extraction
    found_skills = []
    for category, skills in skill_categories.items():
        category_skills = []
        for skill in skills:
            if skill.lower() in text_lower:
                category_skills.append(skill)
        
        if category_skills:
            found_skills.append(f"{category}: {', '.join(category_skills)}")
    
    # Work experience extraction - simplified approach
    work_section = []
    in_work_section = False
    
    for idx, line in enumerate(lines):
        line_lower = line.lower().strip()
        
        # Start of work section
        if not in_work_section:
            if any(header in line_lower for header in work_headers):
                in_work_section = True
                continue
        # End of work section
        elif in_work_section:
            if any(header in line_lower for header in next_section_headers):
                break
            
            if line.strip():
                work_section.append(line.strip())
    
    # Simplified work formatting
    if not work_section:
        work_experience = "Work experience not clearly identified"
    else:
        # Just take the first 5-7 lines of the work section as a summary
        work_lines = []
        company_count = 0
        current_company = ""
        
        for line in work_section:
            # New company entry often has a date
            if re.search(r'(19|20)\d{2}', line):
                company_count += 1
                if company_count <= 3:  # Limit to 3 most recent positions
                    current_company = line
                    work_lines.append(f"**{line}**")
                else:
                    break
            elif company_count <= 3 and len(work_lines) < 10:  # Limit total lines
                work_lines.append(line)
        
        work_experience = "\n• " + "\n• ".join(work_lines[:7]) if work_lines else "Work experience not clearly structured"
    
    skills_formatted = "\n• " + "\n• ".join(found_skills) if found_skills else "No specific technical skills clearly identified"
    
    return skills_formatted, work_experience

#####################################
# Function: Summarize Resume Text
#####################################
def summarize_resume_text(resume_text):
    """
    Generates a structured summary of the resume text
    """
    start_time = time.time()
    
    # First, generate a quick summary using pre-loaded model
    max_input_length = 1024  # Model limit
    
    # Only summarize the first portion of text for speed
    text_to_summarize = resume_text[:min(len(resume_text), max_input_length)]
    base_summary = models['summarizer'](text_to_summarize)[0]['summary_text']
    
    # Extract information in parallel where possible
    with concurrent.futures.ThreadPoolExecutor() as executor:
        # These can run in parallel
        name_future = executor.submit(extract_name, resume_text[:500])  # Only use start of text
        age_future = executor.submit(extract_age, resume_text)
        industry_future = executor.submit(extract_industry, resume_text, base_summary)
        skills_work_future = executor.submit(extract_skills_and_work, resume_text)
        
        # Get results
        name = name_future.result()
        age = age_future.result()
        industry = industry_future.result()
        skills, work_experience = skills_work_future.result()
    
    # Format the structured summary
    formatted_summary = f"Name: {name}\n"
    formatted_summary += f"Age: {age}\n"
    formatted_summary += f"Expected Job Industry: {industry}\n\n"
    formatted_summary += f"Previous Work Experience: {work_experience}\n\n"
    formatted_summary += f"Skills: {skills}"
    
    execution_time = time.time() - start_time
    
    return formatted_summary, execution_time

#####################################
# Function: Extract Job Requirements
#####################################
def extract_job_requirements(job_description):
    """
    Extract key requirements and skills from a job description
    """
    # Common technical skill categories to look for
    tech_skill_categories = {
        "programming_languages": ["Python", "Java", "C++", "JavaScript", "TypeScript", "Go", "Rust", "SQL", "Ruby", "PHP", "Swift", "Kotlin"],
        "web_technologies": ["React", "Angular", "Vue", "Node.js", "HTML", "CSS", "Django", "Flask", "Spring", "REST API", "GraphQL"],
        "data_tech": ["Machine Learning", "TensorFlow", "PyTorch", "Data Science", "AI", "Big Data", "Deep Learning", "NLP", "Computer Vision"],
        "cloud_devops": ["AWS", "Azure", "GCP", "Docker", "Kubernetes", "CI/CD", "Jenkins", "GitHub Actions", "Terraform", "Serverless"],
        "database": ["SQL", "MySQL", "PostgreSQL", "MongoDB", "Redis", "Elasticsearch", "DynamoDB", "Cassandra"],
    }
    
    # Common soft skills to look for
    soft_skills = ["Communication", "Leadership", "Teamwork", "Problem-solving", "Critical thinking", "Adaptability", "Creativity", "Time management"]
    
    # Clean the text for processing
    clean_job_text = job_description.lower()
    
    # Extract job title
    title_patterns = [
        r'^([^:.\n]+?)(position|role|job|opening|vacancy)',
        r'^([^:.\n]+?)\n',
        r'(hiring|looking for(?: a| an)?|recruiting)(?: a| an)? ([^:.\n]+?)(:-|[.:]|\n|$)'
    ]
    
    job_title = "Not specified"
    for pattern in title_patterns:
        title_match = re.search(pattern, clean_job_text, re.IGNORECASE)
        if title_match:
            potential_title = title_match.group(1).strip() if len(title_match.groups()) >= 1 else title_match.group(2).strip()
            if 3 <= len(potential_title) <= 50:  # Reasonable title length
                job_title = potential_title.capitalize()
                break
    
    # Extract years of experience
    exp_patterns = [
        r'(\d+)(?:\+)?\s*(?:years|yrs)(?:\s*of)?\s*(?:experience|exp)',
        r'experience\s*(?:of)?\s*(\d+)(?:\+)?\s*(?:years|yrs)'
    ]
    
    years_required = 0
    for pattern in exp_patterns:
        exp_match = re.search(pattern, clean_job_text, re.IGNORECASE)
        if exp_match:
            try:
                years_required = int(exp_match.group(1))
                break
            except:
                pass
    
    # Extract technical skills
    found_tech_skills = {}
    all_tech_skills = []
    
    for category, skills in tech_skill_categories.items():
        category_skills = []
        for skill in skills:
            if re.search(r'\b' + re.escape(skill.lower()) + r'\b', clean_job_text):
                category_skills.append(skill)
                all_tech_skills.append(skill)
        
        if category_skills:
            found_tech_skills[category] = category_skills
    
    # Extract soft skills
    found_soft_skills = []
    for skill in soft_skills:
        if re.search(r'\b' + re.escape(skill.lower()) + r'\b', clean_job_text):
            found_soft_skills.append(skill)
    
    # Extract educational requirements
    edu_patterns = [
        r"bachelor'?s degree|bs|b\.s\.",
        r"master'?s degree|ms|m\.s\.",
        r"phd|ph\.d\.|doctorate", 
        r"mba|m\.b\.a\."
    ]
    
    education_required = []
    for pattern in edu_patterns:
        if re.search(pattern, clean_job_text, re.IGNORECASE):
            edu_match = re.search(pattern, clean_job_text, re.IGNORECASE).group(0)
            education_required.append(edu_match.capitalize())
    
    # Format the job requirements
    job_requirements = {
        "title": job_title,
        "years_experience": years_required,
        "technical_skills": all_tech_skills,
        "soft_skills": found_soft_skills,
        "education": education_required,
    }
    
    return job_requirements

#####################################
# Function: Analyze Job Fit
#####################################
def analyze_job_fit(resume_summary, job_description):
    """
    Analyze how well the candidate fits the job requirements with the DistilBERT sentiment model.
    """
    start_time = time.time()
    
    # Extract job requirements
    job_requirements = extract_job_requirements(job_description)
    
    # Define skill categories to evaluate against
    resume_lower = resume_summary.lower()
    job_lower = job_description.lower()
    
    # Define keyword categories based on the job description
    # We'll dynamically build these based on the job requirements
    skill_keywords = {
        "technical_skills": job_requirements["technical_skills"],
        "soft_skills": job_requirements["soft_skills"],
        "education": job_requirements["education"],
    }
    
    # Add additional keywords from the job description for comprehensive analysis
    additional_keywords = {
        "problem_solving": ["problem solving", "analytical", "critical thinking", "troubleshooting", "debugging", 
                           "optimization", "solution", "resolve", "analyze"],
        "domain_knowledge": ["industry", "experience", "expertise", "knowledge", "familiar with", "understanding of"],
        "collaboration": ["team", "collaborate", "cooperation", "cross-functional", "communication", "stakeholder"]
    }
    
    # Merge the keywords
    skill_keywords.update(additional_keywords)
    
    # Category weights with descriptive labels
    category_weights = {
        "technical_skills": {"weight": 0.40, "label": "Technical Skills"},
        "soft_skills": {"weight": 0.15, "label": "Soft Skills"},
        "education": {"weight": 0.10, "label": "Education"},
        "problem_solving": {"weight": 0.15, "label": "Problem Solving"},
        "domain_knowledge": {"weight": 0.10, "label": "Domain Knowledge"},
        "collaboration": {"weight": 0.10, "label": "Collaboration"}
    }
    
    # Calculate category scores and store detailed information
    category_scores = {}
    category_details = {}
    found_skills = {}
    
    for category, keywords in skill_keywords.items():
        if not keywords:  # Skip empty categories
            category_scores[category] = 0.0
            category_details[category] = {
                "raw_percentage": 0,
                "adjusted_score": 0,
                "matching_keywords": [],
                "total_keywords": 0,
                "matches": 0
            }
            found_skills[category] = []
            continue
            
        # Find the specific matching keywords for feedback
        category_matches = []
        for keyword in keywords:
            if keyword.lower() in resume_lower:
                category_matches.append(keyword)
        
        found_skills[category] = category_matches
        
        # Count matches but cap at a reasonable level
        matches = len(category_matches)
        total_keywords = len(keywords)
        
        # Calculate raw percentage for this category
        raw_percentage = int((matches / max(1, total_keywords)) * 100)
        
        # Apply logarithmic scaling for more realistic scores
        if matches == 0:
            adjusted_score = 0.0
        else:
            # Logarithmic scaling to prevent perfect scores
            adjusted_score = min(0.95, (math.log(matches + 1) / math.log(min(total_keywords, 8) + 1)))
        
        # Store both raw and adjusted scores for feedback
        category_scores[category] = adjusted_score
        category_details[category] = {
            "raw_percentage": raw_percentage,
            "adjusted_score": int(adjusted_score * 100),
            "matching_keywords": category_matches,
            "total_keywords": total_keywords,
            "matches": matches
        }
    
    # Check for years of experience match
    years_required = job_requirements["years_experience"]
    
    # Extract years of experience from resume
    experience_years = 0
    year_patterns = [
        r'(\d+)\s*(?:\+)?\s*years?\s*(?:of)?\s*experience',
        r'experience\s*(?:of)?\s*(\d+)\s*(?:\+)?\s*years?'
    ]
    
    for pattern in year_patterns:
        exp_match = re.search(pattern, resume_lower)
        if exp_match:
            try:
                experience_years = int(exp_match.group(1))
                break
            except:
                pass
    
    # If we couldn't find explicit years, try to count based on work history
    if experience_years == 0:
        # Try to extract from work experience section
        work_exp_match = re.search(r'work experience:(.*?)(?=\n\n|$)', resume_summary, re.IGNORECASE | re.DOTALL)
        if work_exp_match:
            work_text = work_exp_match.group(1).lower()
            years = re.findall(r'(\d{4})\s*-\s*(\d{4}|present|current)', work_text)
            
            total_years = 0
            for year_range in years:
                start_year = int(year_range[0])
                if year_range[1].isdigit():
                    end_year = int(year_range[1])
                else:
                    end_year = 2025  # Assume "present" is current year
                
                total_years += (end_year - start_year)
            
            experience_years = total_years
    
    # Calculate experience match score
    if years_required > 0:
        if experience_years >= years_required:
            exp_score = 1.0
        else:
            exp_score = experience_years / years_required
    else:
        exp_score = 1.0  # If no specific years required, assume full match
    
    category_scores["experience"] = exp_score
    category_details["experience"] = {
        "raw_percentage": int(exp_score * 100),
        "adjusted_score": int(exp_score * 100),
        "candidate_years": experience_years,
        "required_years": years_required
    }
    
    # Calculate weighted score
    weighted_score = 0
    for category, score in category_scores.items():
        if category in category_weights:
            weighted_score += score * category_weights[category]["weight"]
    
    # Add experience separately (not in the original weights)
    weighted_score = (weighted_score * 0.8) + (category_scores["experience"] * 0.2)
    
    # Apply final curve to keep scores in a realistic range
    match_percentage = min(95, max(35, int(weighted_score * 100)))
    
    # Prepare input for sentiment analysis
    # Create a structured summary of the match for sentiment model
    match_summary = f"""
    Job title: {job_requirements['title']}
    Match percentage: {match_percentage}%
    
    Technical skills match: {category_details['technical_skills']['adjusted_score']}%
    Required technical skills: {', '.join(job_requirements['technical_skills'][:5])}
    Candidate has: {', '.join(found_skills['technical_skills'][:5])}
    
    Experience match: {category_details['experience']['adjusted_score']}%
    Required years: {job_requirements['years_experience']}
    Candidate years: {experience_years}
    
    Education match: {category_details['education']['adjusted_score']}%
    
    Overall profile match: The candidate's skills and experience appear to {match_percentage >= 70 and "match well with" or "partially match with"} the job requirements.
    """
    
    # Use the sentiment model to get a fit classification
    sentiment_result = models['evaluator'](match_summary)
    
    # Map sentiment analysis to our score:
    # NEGATIVE = 0 (poor fit)
    # POSITIVE = 1 (good fit)
    score_mapping = {
        "NEGATIVE": 0,
        "POSITIVE": 1
    }
    
    # Get the sentiment score
    sentiment_score = score_mapping.get(sentiment_result[0]['label'], 0)
    
    # Adjust the score based on the match percentage to get our 0,1,2 scale
    if sentiment_score == 1 and match_percentage >= 85:
        final_score = 2  # Excellent fit
    elif sentiment_score == 1:
        final_score = 1  # Good fit
    else:
        final_score = 0  # Poor fit
    
    # Map to fit status
    fit_status_map = {
        0: "NOT FIT",
        1: "POTENTIAL FIT",
        2: "STRONG FIT"
    }
    
    fit_status = fit_status_map[final_score]
    
    # Generate assessment summary based on the score
    if final_score == 2:
        assessment = f"{final_score}: The candidate is a strong match for this {job_requirements['title']} position, with excellent alignment in technical skills and experience. Their background demonstrates the required expertise in key areas such as {', '.join(found_skills['technical_skills'][:3]) if found_skills['technical_skills'] else 'relevant technical domains'}, and they possess the necessary {experience_years} years of experience (required: {years_required})."
    elif final_score == 1:
        assessment = f"{final_score}: The candidate shows potential for this {job_requirements['title']} position, with some good matches in required skills. They demonstrate experience with {', '.join(found_skills['technical_skills'][:2]) if found_skills['technical_skills'] else 'some relevant technologies'}, but may need development in areas like {', '.join(set(job_requirements['technical_skills']) - set(found_skills['technical_skills']))[:2] if set(job_requirements['technical_skills']) - set(found_skills['technical_skills']) else 'specific technical requirements'}."
    else:
        assessment = f"{final_score}: The candidate does not appear to be a strong match for this {job_requirements['title']} position. Their profile shows limited alignment with key requirements, particularly in {', '.join(set(job_requirements['technical_skills']) - set(found_skills['technical_skills']))[:3] if set(job_requirements['technical_skills']) - set(found_skills['technical_skills']) else 'required technical skills'}, and they have {experience_years} years of experience (required: {years_required})."
    
    execution_time = time.time() - start_time
    
    return assessment, final_score, match_percentage, category_details, job_requirements, execution_time

#####################################
# Main Streamlit Interface
#####################################
st.title("Resume-Job Fit Analyzer")
st.markdown(
    """
Upload your resume file in **.docx**, **.doc**, or **.txt** format and enter a job description to see how well you match with the job requirements. The app performs the following tasks:
1. Extracts text from your resume.
2. Uses AI to generate a structured candidate summary.
3. Analyzes how well your profile fits the specific job requirements.
"""
)

# Resume upload
uploaded_file = st.file_uploader("Upload your resume (.docx, .doc, or .txt)", type=["docx", "doc", "txt"])

# Job description input
job_description = st.text_area("Enter Job Description", height=200, placeholder="Paste the job description here...")

# Process button with optimized flow
if uploaded_file is not None and job_description and st.button("Analyze Job Fit"):
    # Create a placeholder for the progress bar
    progress_bar = st.progress(0)
    status_text = st.empty()
    
    # Step 1: Extract text
    status_text.text("Step 1/3: Extracting text from resume...")
    resume_text = extract_text_from_file(uploaded_file)
    progress_bar.progress(25)
    
    if resume_text.startswith("Error") or resume_text == "Unsupported file type. Please upload a .docx, .doc, or .txt file.":
        st.error(resume_text)
    else:
        # Step 2: Generate summary
        status_text.text("Step 2/3: Analyzing resume and generating summary...")
        summary, summarization_time = summarize_resume_text(resume_text)
        progress_bar.progress(50)
        
        # Display summary
        st.subheader("Your Resume Summary")
        st.markdown(summary)
        st.info(f"Summary generated in {summarization_time:.2f} seconds")
        
        # Step 3: Generate job fit assessment
        status_text.text("Step 3/3: Evaluating job fit...")
        assessment, fit_score, match_percentage, category_details, job_requirements, assessment_time = analyze_job_fit(summary, job_description)
        progress_bar.progress(100)

        # Clear status messages
        status_text.empty()

        # Display job fit results
        st.subheader("Job Fit Assessment")

        # Display fit score with label
        fit_labels = {
            0: "NOT FIT ❌",
            1: "POTENTIAL FIT ⚠️",
            2: "STRONG FIT ✅"
        }
        
        # Show the score prominently
        st.markdown(f"## Overall Result: {fit_labels[fit_score]}")

        # Display match percentage
        if match_percentage >= 85:
            st.success(f"**Match Score:** {match_percentage}% 🌟")
        elif match_percentage >= 70:
            st.success(f"**Match Score:** {match_percentage}% ✅")
        elif match_percentage >= 50:
            st.warning(f"**Match Score:** {match_percentage}% ⚠️")
        else:
            st.error(f"**Match Score:** {match_percentage}% 🔍")

        # Display assessment
        st.markdown("### Assessment")
        st.markdown(assessment)

        # Add detailed score breakdown
        st.markdown("### Score Breakdown")

        # Create a neat table with category scores
        breakdown_data = []
        for category, details in category_details.items():
            if category == "experience":
                label = "Experience"
                matching_info = f"{details['candidate_years']} years (Required: {details['required_years']} years)"
            else:
                # Get the nice label for the category
                label = {"technical_skills": "Technical Skills",
                        "soft_skills": "Soft Skills",
                        "education": "Education",
                        "problem_solving": "Problem Solving",
                        "domain_knowledge": "Domain Knowledge",
                        "collaboration": "Collaboration"}[category]
                
                matching_info = ", ".join(details["matching_keywords"][:3]) if details.get("matching_keywords") else "None detected"
    
            # Add formatted breakdown row
            breakdown_data.append({
                "Category": label,
                "Score": f"{details['adjusted_score']}%",
                "Matching Items": matching_info
            })

        # Convert to DataFrame and display
        breakdown_df = pd.DataFrame(breakdown_data)
        # Remove the index column entirely
        st.table(breakdown_df.set_index('Category').reset_index())  # This removes the numerical index

        # Show a note about how scores are calculated
        with st.expander("How are these scores calculated?"):
            st.markdown("""
            - **Technical Skills** (40% of total): Evaluates programming languages, software tools, and technical requirements
            - **Soft Skills** (15% of total): Assesses communication, teamwork, and interpersonal abilities
            - **Education** (10% of total): Compares educational requirements with candidate's background
            - **Problem Solving** (15% of total): Measures analytical thinking and approach to challenges
            - **Domain Knowledge** (10% of total): Evaluates industry-specific experience and knowledge
            - **Collaboration** (10% of total): Assesses team skills and cross-functional collaboration
            - **Experience** (20% overall modifier): Years of relevant experience compared to job requirements
    
            Scores are calculated based on keyword matches in your resume, with diminishing returns applied (first few skills matter more than later ones).
            """)

        st.info(f"Assessment completed in {assessment_time:.2f} seconds")
        
        # Add potential next steps based on the fit score
        st.subheader("Recommended Next Steps")
        
        if fit_score == 2:
            st.markdown("""
            - Consider applying for this position as you appear to be a strong match
            - Prepare for technical interviews by focusing on your strongest skills
            - Review the job description again to prepare for specific interview questions
            """)
        elif fit_score == 1:
            st.markdown("""
            - Focus on highlighting your strongest matching skills in your application
            - Consider addressing skill gaps in your cover letter by connecting your experience to the requirements
            - Prepare to discuss how your transferable skills apply to this position
            """)
        else:
            st.markdown("""
            - This position may not be the best fit for your current skills and experience
            - Consider roles that better align with your demonstrated strengths
            - If you're set on this type of position, focus on developing skills in the areas mentioned in the job description
            """)