app.py

import gradio as gr
import os
import tempfile
from backend import (
    extract_text_from_document, 
    analyze_resume_job_match, 
    tailor_resume, 
    create_word_document,
    create_tailored_resume_from_template,  
    get_available_templates,
    set_openai_api_key,
    set_openai_model
)
import plotly.graph_objects as go
import time as import_time
import json

# Define sample resumes
SAMPLE_RESUMES = {
    "Excellent Match Resume": "excellent_match_resume.docx",
    "Good Match Resume": "good_match_resume.docx",
    "Average Match Resume": "average_match_resume.docx",
    "Poor Match Resume": "poor_match_resume.docx"
}

# Check if sample files exist
for sample_name, sample_path in SAMPLE_RESUMES.items():
    if not os.path.exists(sample_path):
        print(f"Warning: Sample resume file not found: {sample_path}")

# Read default job description
def get_default_job_description():
    try:
        with open("job_desc.txt", "r") as file:
            return file.read()
    except:
        return "Software Architect position requiring cloud expertise, microservices architecture, and leadership skills."

# Function to get color based on percentage
def get_color_for_percentage(percentage):
    if percentage < 40:
        return "#FF4B4B"  # Red for poor match
    elif percentage < 60:
        return "#FFA500"  # Orange for average match
    elif percentage < 80:
        return "#2E86C1"  # Blue for good match
    else:
        return "#2ECC71"  # Green for excellent match

# Function to create match gauge chart
def create_match_gauge(match_percentage):
        if match_percentage < 40:
            color = "#FF4B4B"  # Red
        elif match_percentage < 60:
            color = "#FFA500"  # Orange
        elif match_percentage < 80:
            color = "#2E86C1"  # Blue
        else:
            color = "#2ECC71"  # Green
        
        fig = go.Figure(go.Indicator(
            mode="gauge+number",
            value=match_percentage,
            domain={'x': [0, 1], 'y': [0, 1]},
            title={'text': "Match Percentage"},
            gauge={
                'axis': {'range': [0, 100], 'tickwidth': 1, 'tickcolor': "darkblue"},
                'bar': {'color': color},
                'bgcolor': "white",
                'borderwidth': 2,
                'bordercolor': "gray",
                'steps': [
                    {'range': [0, 40], 'color': 'rgba(255, 75, 75, 0.2)'},  # Light red
                    {'range': [40, 60], 'color': 'rgba(255, 165, 0, 0.2)'},  # Light orange
                    {'range': [60, 80], 'color': 'rgba(46, 134, 193, 0.2)'},  # Light blue
                    {'range': [80, 100], 'color': 'rgba(46, 204, 113, 0.2)'}  # Light green
                ],
            }
        ))
        
        fig.update_layout(
            height=250,
            margin=dict(l=20, r=20, t=50, b=20),
            paper_bgcolor="rgba(0,0,0,0)",
            plot_bgcolor="rgba(0,0,0,0)",
            font={'color': "#444", 'family': "Arial"}
        )
        
        return fig

# Function to handle resume upload
def handle_resume_upload(file):
    if file is None:
        return None, None
    
    # Save uploaded file
    temp_dir = tempfile.mkdtemp()
    temp_path = os.path.join(temp_dir, file.name)
    with open(temp_path, "wb") as f:
        f.write(file)
    
    # Extract text
    resume_text = extract_text_from_document(temp_path)
    template_path = temp_path if temp_path.endswith('.docx') else None
    
    return resume_text, template_path

# Function to handle sample resume selection
def handle_sample_resume(sample_name):
    if not sample_name:
        return None, None
    
    resume_path = SAMPLE_RESUMES[sample_name]
    if os.path.exists(resume_path):
        # Extract text
        resume_text = extract_text_from_document(resume_path)
        template_path = resume_path
        return resume_text, template_path
    else:
        print(f"Sample resume file not found: {resume_path}")
        return None, None

# Function to handle template selection
def handle_template_selection(use_template, selected_template):
    if use_template and selected_template != "None":
        return selected_template
    return None

# Function to analyze resume
def analyze_resume(resume_text, job_description, creativity_level):
    if not resume_text or not job_description:
        return None, "Please provide both a resume and job description."
    
    try:
        analysis_results = analyze_resume_job_match(
            resume_text,
            job_description,
            creativity_level
        )
        
        # Create the match gauge chart
        match_percentage = analysis_results.get("match_percentage", 0)
        gauge_chart = create_match_gauge(match_percentage)
        
        # Determine match category and description
        if match_percentage < 40:
            match_category = "Poor Match"
            match_description = "Your resume needs significant improvements to match this job description."
        elif match_percentage < 60:
            match_category = "Average Match"
            match_description = "Your resume partially matches the job description but could use improvements."
        elif match_percentage < 80:
            match_category = "Good Match"
            match_description = "Your resume matches well with the job description with some room for improvement."
        else:
            match_category = "Excellent Match"
            match_description = "Your resume is very well aligned with the job description!"
        
        # Format the analysis results for display
        formatted_results = f"## Match Analysis\n\n"
        formatted_results += f"**Match Category:** {match_category}\n\n"
        formatted_results += f"**Match Description:** {match_description}\n\n"
        
        # Add skill breakdown
        if "skill_breakdown" in analysis_results:
            formatted_results += "## Skill Breakdown\n\n"
            skill_breakdown = analysis_results["skill_breakdown"]
            
            for skill_type, skill_data in skill_breakdown.items():
                formatted_results += f"### {skill_type.replace('_', ' ').title()}\n"
                formatted_results += f"**Percentage:** {skill_data.get('percentage', 0)}%\n"
                formatted_results += f"**Comments:** {skill_data.get('comments', '')}\n\n"
        
        # Add key matches
        if "key_matches" in analysis_results:
            formatted_results += "## Key Matches\n\n"
            for match in analysis_results["key_matches"]:
                formatted_results += f"- {match}\n"
            formatted_results += "\n"
        
        # Add gaps
        if "gaps" in analysis_results:
            formatted_results += "## Gaps Identified\n\n"
            for gap in analysis_results["gaps"]:
                formatted_results += f"- {gap}\n"
            formatted_results += "\n"
        
        # Add suggestions
        if "suggestions" in analysis_results:
            formatted_results += "## Improvement Suggestions\n\n"
            for suggestion in analysis_results["suggestions"]:
                formatted_results += f"- {suggestion}\n"
            formatted_results += "\n"
        
        # Add summary
        if "summary" in analysis_results:
            formatted_results += "## Summary\n\n"
            formatted_results += analysis_results["summary"]
        
        return analysis_results, formatted_results
    except Exception as e:
        return None, f"Error analyzing resume: {str(e)}"

# Function to tailor resume
def tailor_resume_func(resume_text, job_description, template_path, creativity_level, verbosity):
    if not resume_text or not job_description:
        return None, "Please provide both a resume and job description."
    
    try:
        tailored_resume = tailor_resume(
            resume_text,
            job_description,
            template_path,
            creativity_level,
            verbosity
        )
        
        return tailored_resume, "Resume tailored successfully!"
    except Exception as e:
        return None, f"Error tailoring resume: {str(e)}"

# Function to create and download Word document
def create_word_doc(tailored_resume, template_path):
    if not tailored_resume:
        return None, "No tailored resume to download."
    
    try:
        # Create a temporary file
        temp_dir = tempfile.mkdtemp()
        output_path = os.path.join(temp_dir, "tailored_resume.docx")
        
        # Create Word document
        if template_path and os.path.exists(template_path):
            success = create_tailored_resume_from_template(
                tailored_resume,
                template_path,
                output_path
            )
        else:
            success = create_word_document(
                tailored_resume,
                output_path
            )
        
        if success:
            return output_path, "DOCX file created successfully!"
        else:
            return None, "Failed to create DOCX file."
    except Exception as e:
        return None, f"Error creating DOCX file: {str(e)}"

# Function to update API key
def update_api_key(api_key):
    if not api_key:
        return "Using API key from environment variables if available."
    
    api_configured = set_openai_api_key(api_key)
    if api_configured:
        return "✅ API key configured successfully!"
    else:
        return "❌ Failed to configure API key."

# Function to update model
def update_model(model):
    set_openai_model(model)
    return f"✅ Model set to {model}"

# Main function to create the Gradio interface
def create_interface():
    print("Creating interface...")
    # Define the blocks with custom theme
    with gr.Blocks(title="Resume Helper", theme=gr.themes.Soft(
        primary_hue="blue",
        secondary_hue="indigo",
        font=[gr.themes.GoogleFont("Poppins"), "ui-sans-serif", "system-ui", "sans-serif"],
    )) as app:
        gr.Markdown("# 📄 Resume Helper")
        gr.Markdown("Upload your resume and get AI-powered analysis and tailoring to match job descriptions.")
        
        # State variables
        resume_text = gr.State(None)
        template_path = gr.State(None)
        analysis_results = gr.State(None)
        tailored_resume_text = gr.State(None)
        
        with gr.Row():
            # Left column - Inputs
            with gr.Column(scale=1):
                # Configuration section
                with gr.Accordion("⚙️ Configuration", open=False):
                    api_key = gr.Textbox(
                        label="OpenAI API Key",
                        placeholder="Enter your OpenAI API key (optional)",
                        type="password"
                    )
                    api_status = gr.Markdown("Using API key from environment variables if available.")
                    api_key.change(update_api_key, inputs=[api_key], outputs=[api_status])
                    
                    model_options = ["gpt-4o-mini", "gpt-4o"]
                    model_selector = gr.Dropdown(
                        label="Select AI Model",
                        choices=model_options,
                        value="gpt-4o-mini",
                        info="Choose the OpenAI model to use. GPT-4o-mini is faster and cheaper, while GPT-4o provides more detailed analysis."
                    )
                    model_status = gr.Markdown("")
                    model_selector.change(update_model, inputs=[model_selector], outputs=[model_status])
                
                # Resume upload section
                gr.Markdown("### 📤 Upload Your Resume")
                resume_option = gr.Radio(
                    label="Choose an option:",
                    choices=["Upload my resume", "Use a sample resume"],
                    value="Upload my resume"
                )
                
                # Upload resume file
                upload_file = gr.File(
                    label="Upload your resume (DOCX, PDF)",
                    file_types=[".docx", ".pdf"],
                    visible=True
                )
                
                # Sample resume selection
                sample_resume = gr.Dropdown(
                    label="Select a sample resume:",
                    choices=list(SAMPLE_RESUMES.keys()),
                    visible=False
                )
                
                # Show/hide based on selection
                def update_resume_option(option):
                    return {
                        upload_file: gr.update(visible=option == "Upload my resume"),
                        sample_resume: gr.update(visible=option == "Use a sample resume")
                    }
                
                resume_option.change(update_resume_option, inputs=[resume_option], outputs=[upload_file, sample_resume])
                
                # Template selection
                gr.Markdown("### 📄 Select Resume Template (Optional)")
                templates = get_available_templates()
                print(f"Templates: {templates}")
                use_template = gr.Checkbox(label="Use a resume template", value=False)
                template_selector = gr.Dropdown(
                    label="Choose a template:",
                    choices=["None"] + templates,
                    value="None",
                    visible=False
                )
                print(f"Template selector: ")

                def update_template_visibility(use_template):
                    return gr.update(visible=use_template)
                
                use_template.change(update_template_visibility, inputs=[use_template], outputs=[template_selector])
                
                # Job description
                gr.Markdown("### 📋 Job Description")
                job_description = gr.Textbox(
                    label="Job Description",
                    value=get_default_job_description(),
                    lines=10
                )
                
                # MOVED FROM RIGHT COLUMN: Resume detail level
                gr.Markdown("### 📝 Resume Detail Level")
                verbosity = gr.Radio(
                    label="Choose how detailed your tailored resume should be:",
                    choices=["Concise", "Elaborate"],
                    value="Elaborate"
                )
                
                # MOVED FROM RIGHT COLUMN: Creativity level
                gr.Markdown("### 🎨 Creativity Level")
                creativity_level = gr.Slider(
                    label="Adjust how creative the AI should be when tailoring your resume",
                    minimum=0,
                    maximum=100,
                    value=30,
                    step=10,
                    info="Higher values mean more creative modifications to your resume"
                )
                
                creativity_warning = gr.Markdown(visible=False)
                
                def update_creativity_warning(level):
                    if level > 70:
                        return gr.update(visible=True, value="⚠️ High creativity levels may generate content that significantly modifies your original resume. Review carefully before using.")
                    else:
                        return gr.update(visible=False)
                
                creativity_level.change(update_creativity_warning, inputs=[creativity_level], outputs=[creativity_warning])
                
                # MOVED FROM RIGHT COLUMN: Action buttons
                gr.Markdown("### 🚀 Actions")
                with gr.Row():
                    analyze_btn = gr.Button("🔍 Analyze Resume", variant="primary")
                    tailor_btn = gr.Button("✏️ Tailor Resume", variant="primary")
                    reset_btn = gr.Button("🔄 Reset All", variant="secondary")
                
                # Add loading indicator below the buttons
                loading_indicator = gr.Markdown(visible=False)
            
            # Right column - Results
            with gr.Column(scale=1):
                # Results section - Now directly in the right column, not in an accordion
                with gr.Tabs() as results_tabs:
                    # Analysis tab
                    with gr.TabItem("📊 Analysis"):
                        analysis_plot = gr.Plot(label="Match Percentage")
                        analysis_output = gr.Markdown()
                    
                    # Tailored Resume tab
                    with gr.TabItem("📝 Tailored Resume"):
                        tailored_resume = gr.Textbox(label="Tailored Resume", lines=15)
                        
                        # Create download buttons but initially hide them
                        with gr.Row():
                            download_docx = gr.Button("📄 Download as DOCX", variant="primary", visible=False)
                            download_txt = gr.Button("📝 Download as TXT", variant="primary", visible=False)
                        
                        # Create file components but initially hide them
                        docx_file = gr.File(label="Download DOCX", visible=False)
                        txt_file = gr.File(label="Download TXT", visible=False)
                        
                        download_status = gr.Markdown()

        # Event handlers
        def process_resume_input(resume_opt, upload_file, sample_name, use_template_opt, template_selection):
            if resume_opt == "Upload my resume" and upload_file is not None:
                resume_text, template_path = handle_resume_upload(upload_file)
            elif resume_opt == "Use a sample resume" and sample_name:
                resume_text, template_path = handle_sample_resume(sample_name)
            else:
                resume_text, template_path = None, None
            
            if use_template_opt and template_selection != "None":
                template_path = template_selection
            
            return resume_text, template_path
        
        # Handle file upload
        upload_file.upload(
            lambda file: process_resume_input("Upload my resume", file, None, use_template.value, template_selector.value),
            inputs=[upload_file],
            outputs=[resume_text, template_path]
        )
        
        # Handle sample selection
        sample_resume.change(
            lambda sample: process_resume_input("Use a sample resume", None, sample, use_template.value, template_selector.value),
            inputs=[sample_resume],
            outputs=[resume_text, template_path]
        )
        
        # Handle template selection
        template_selector.change(
            lambda template, resume_txt, current_template: (resume_txt, template if template != "None" else current_template),
            inputs=[template_selector, resume_text, template_path],
            outputs=[resume_text, template_path]
        )
        
        # Analyze button handler with loading indicator
        def analyze_with_loading(resume_txt, job_desc, creativity):
            if not resume_txt:
                return (
                    gr.update(visible=False), 
                    None, 
                    gr.update(visible=False), 
                    "", 
                    gr.update(interactive=True), 
                    gr.update(interactive=True), 
                    gr.update(interactive=True)
                )
            
            # Show loading message and disable buttons
            yield (
                gr.update(visible=True, value="⏳ Analyzing your resume... This may take a moment."), 
                None, 
                gr.update(visible=False), 
                "", 
                gr.update(interactive=False), 
                gr.update(interactive=False), 
                gr.update(interactive=False)
            )
            
            # Perform the actual analysis
            results, formatted_output = analyze_resume(resume_txt, job_desc, creativity)
            
            # Hide loading, show results, and re-enable buttons
            if results:
                match_percentage = results.get("match_percentage", 0)
                gauge_chart = create_match_gauge(match_percentage)
                yield (
                    gr.update(visible=False), 
                    results, 
                    gauge_chart, 
                    formatted_output, 
                    gr.update(interactive=True), 
                    gr.update(interactive=True), 
                    gr.update(interactive=True)
                )
            else:
                yield (
                    gr.update(visible=False), 
                    None, 
                    gr.update(visible=False), 
                    formatted_output, 
                    gr.update(interactive=True), 
                    gr.update(interactive=True), 
                    gr.update(interactive=True)
                )
        
        analyze_btn.click(
            analyze_with_loading,
            inputs=[resume_text, job_description, creativity_level],
            outputs=[
                loading_indicator, 
                analysis_results, 
                analysis_plot, 
                analysis_output, 
                analyze_btn, 
                tailor_btn, 
                reset_btn
            ],
            queue=True
        )
        
        # Tailor button handler with loading indicator
        def tailor_with_loading(resume_txt, job_desc, template, creativity, verbosity_level):
            if not resume_txt:
                return (
                    gr.update(visible=False), 
                    None, 
                    "", 
                    gr.update(visible=False), 
                    gr.update(visible=False), 
                    gr.update(interactive=True), 
                    gr.update(interactive=True), 
                    gr.update(interactive=True)
                )
            
            # Show loading message and disable buttons
            yield (
                gr.update(visible=True, value="⏳ Tailoring your resume... This may take a moment."), 
                None, 
                "", 
                gr.update(visible=False), 
                gr.update(visible=False), 
                gr.update(interactive=False), 
                gr.update(interactive=False), 
                gr.update(interactive=False)
            )
            
            # Perform the actual tailoring
            tailored, message = tailor_resume_func(
                resume_txt, 
                job_desc, 
                template, 
                creativity, 
                verbosity_level.lower()
            )
            
            # Hide loading, show results, and re-enable buttons
            if tailored:
                # Show download buttons only when tailored resume is created
                yield (
                    gr.update(visible=False), 
                    tailored, 
                    tailored, 
                    gr.update(visible=True), 
                    gr.update(visible=True), 
                    gr.update(interactive=True), 
                    gr.update(interactive=True), 
                    gr.update(interactive=True)
                )
            else:
                # Hide download buttons if tailoring fails
                yield (
                    gr.update(visible=False), 
                    None, 
                    message, 
                    gr.update(visible=False), 
                    gr.update(visible=False), 
                    gr.update(interactive=True), 
                    gr.update(interactive=True), 
                    gr.update(interactive=True)
                )
        
        tailor_btn.click(
            tailor_with_loading,
            inputs=[resume_text, job_description, template_path, creativity_level, verbosity],
            outputs=[
                loading_indicator, 
                tailored_resume_text, 
                tailored_resume, 
                download_docx, 
                download_txt, 
                analyze_btn, 
                tailor_btn, 
                reset_btn
            ],
            queue=True
        )
        
        # Download handlers
        def create_docx_handler(tailored_txt, template):
            if not tailored_txt:
                return gr.update(visible=False), "No tailored resume to download."
            
            file_path, message = create_word_doc(tailored_txt, template)
            if file_path:
                return gr.update(visible=True, value=file_path), message
            else:
                return gr.update(visible=False), message
        
        download_docx.click(
            create_docx_handler,
            inputs=[tailored_resume_text, template_path],
            outputs=[docx_file, download_status]
        )
        
        # Download as TXT
        def download_txt_handler(tailored_txt):
            if not tailored_txt:
                return gr.update(visible=False), "No tailored resume to download."
            
            # Create a temporary file
            temp_dir = tempfile.mkdtemp()
            output_path = os.path.join(temp_dir, "tailored_resume.txt")
            
            with open(output_path, "w") as f:
                f.write(tailored_txt)
            
            return gr.update(visible=True, value=output_path), "TXT file created successfully!"
        
        download_txt.click(
            download_txt_handler,
            inputs=[tailored_resume_text],
            outputs=[txt_file, download_status]
        )
        
        # Reset handler
        def reset_all():
            return (
                None, None, None, None,
                gr.update(value=None), 
                gr.update(value="Upload my resume"),
                gr.update(value=None),
                gr.update(value=None),
                gr.update(value="None"),
                gr.update(value=get_default_job_description()),
                gr.update(value="Elaborate"),
                gr.update(value=30),
                gr.update(visible=False),
                gr.update(value=""),
                gr.update(value=""),
                gr.update(visible=False),
                gr.update(visible=False),
                gr.update(visible=False),
                gr.update(visible=False)
            )
        
        reset_btn.click(
            reset_all,
            inputs=[],
            outputs=[
                resume_text, template_path, analysis_results, tailored_resume_text,
                upload_file, resume_option, sample_resume, use_template, template_selector,
                job_description, verbosity, creativity_level, creativity_warning,
                analysis_output, tailored_resume,
                download_docx, download_txt, docx_file, txt_file
            ]
        )

# Footer
        gr.Markdown("---")
        gr.Markdown("### 📝 Disclaimer")
        gr.Markdown("""

This tool uses AI to analyze and tailor resumes. While it strives for accuracy, please review all generated content before using it professionally.

Higher creativity levels may generate content that requires more thorough verification. Always ensure that your resume accurately represents your skills and experience.

""")
    print("Interface created successfully")
    return app

# Launch the app
if __name__ == "__main__":
    app = create_interface()
    app.queue()  # Enable the queue for the app
    app.launch()