Update app.py

app.py

@@ -1,5 +1,3 @@
-import os
-import pathlib
 import json
 import PyPDF2
 import docx
@@ -12,41 +10,34 @@ from reportlab.lib.pagesizes import letter
 from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
 from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
 
-# GOOGLE GEMINI SDK
-import google.generativeai as genai
+import google.generativeai as genai # Replaced openai import
 
-# --- BEGIN: Safe Streamlit paths (prevents '/.streamlit' PermissionError on Spaces) ---
-PROJECT_ROOT = str(pathlib.Path(__file__).parent.resolve())
-os.environ["HOME"] = PROJECT_ROOT
-os.makedirs(os.path.join(PROJECT_ROOT, ".streamlit"), exist_ok=True)
-os.environ["STREAMLIT_CACHE_DIR"] = os.path.join(PROJECT_ROOT, ".streamlit", "cache")
-os.makedirs(os.environ["STREAMLIT_CACHE_DIR"], exist_ok=True)
-# --- END: Safe Streamlit paths ---
-
-# ---------- File utilities ----------
+# Utility Functions
 def read_pdf(file):
-    reader = PyPDF2.PdfReader(file)
+    pdf_reader = PyPDF2.PdfReader(file)
     text = ""
-    for page in reader.pages:
-        text += (page.extract_text() or "")
+    for page in pdf_reader.pages:
+        text += page.extract_text()
     return text
 
+
 def read_docx(file):
-    d = docx.Document(file)
-    return "\n".join(p.text for p in d.paragraphs)
+    doc = docx.Document(file)
+    text = ""
+    for paragraph in doc.paragraphs:
+        text += paragraph.text + "\n"
+    return text
+
 
 def load_resume(uploaded_file):
-    if uploaded_file is None:
-        return None
-    name = uploaded_file.name.lower()
-    if name.endswith(".pdf"):
+    if uploaded_file.name.endswith('.pdf'):
         return read_pdf(uploaded_file)
-    if name.endswith(".docx"):
+    elif uploaded_file.name.endswith('.docx'):
         return read_docx(uploaded_file)
-    st.error("Unsupported file format. Please upload PDF or DOCX.")
-    return None
+    else:
+        st.error("Unsupported file format")
+        return None
 
-# ---------- Resume PDF builder ----------
 def generate_updated_resume(resume_text, match_analysis):
     buffer = BytesIO()
     doc = SimpleDocTemplate(buffer, pagesize=letter,
@@ -54,208 +45,319 @@ def generate_updated_resume(resume_text, match_analysis):
                             topMargin=60, bottomMargin=40)
     styles = getSampleStyleSheet()
 
+    # Custom styles
     header_style = styles['Heading1']
     header_style.fontSize = 16
     header_style.spaceAfter = 18
     header_style.textColor = colors.HexColor('#1a1a1a')
 
     section_header_style = ParagraphStyle(
-        name='SectionHeader', parent=styles['Heading2'],
-        fontSize=13, spaceAfter=12, textColor=colors.HexColor('#0d47a1'),
-        underlineWidth=1, underlineOffset=-3
+        name='SectionHeader',
+        parent=styles['Heading2'],
+        fontSize=13,
+        spaceAfter=12,
+        textColor=colors.HexColor('#0d47a1'),
+        underlineWidth=1,
+        underlineOffset=-3
     )
 
     normal_style = ParagraphStyle(
-        name='NormalText', parent=styles['Normal'],
-        fontSize=10, leading=14, spaceAfter=6,
+        name='NormalText',
+        parent=styles['Normal'],
+        fontSize=10,
+        leading=14,
+        spaceAfter=6,
     )
+
     bullet_style = ParagraphStyle(
-        name='BulletStyle', parent=normal_style,
-        bulletFontName='Helvetica', bulletFontSize=8,
-        bulletIndent=10, leftIndent=20
+        name='BulletStyle',
+        parent=normal_style,
+        bulletFontName='Helvetica',
+        bulletFontSize=8,
+        bulletIndent=10,
+        leftIndent=20
+    )
+
+    recommendation_style = ParagraphStyle(
+        name='RecommendationStyle',
+        parent=styles['Normal'],
+        fontSize=9,
+        textColor=colors.HexColor('#00695c'),
+        leftIndent=25,
+        spaceAfter=4
     )
 
     content = []
     content.append(Paragraph("Updated Resume", header_style))
     content.append(Spacer(1, 12))
 
-    common_sections = ['EXPERIENCE','EDUCATION','SKILLS','PROJECTS','CERTIFICATIONS','SUMMARY','OBJECTIVE']
+    # Resume Content Parsing
+    resume_parts = resume_text.split("\n")
+    current_section = ""
     bullets = []
 
     def flush_bullets():
-        for b in bullets:
-            if b.strip():
-                content.append(Paragraph("• " + b.strip(), bullet_style))
+        for bullet in bullets:
+            content.append(Paragraph(f"• {bullet.strip()}", bullet_style))
         bullets.clear()
 
-    for line in (resume_text or "").splitlines():
-        line = (line or "").strip()
+    common_sections = ['EXPERIENCE', 'EDUCATION', 'SKILLS', 'PROJECTS', 'CERTIFICATIONS', 'SUMMARY', 'OBJECTIVE']
+
+    for line in resume_parts:
+        line = line.strip()
         if not line:
             continue
-        is_section = line.isupper() or any(s in line.upper() for s in common_sections)
+
+        is_section = line.isupper() or any(section in line.upper() for section in common_sections)
+
         if is_section:
             flush_bullets()
+            current_section = line
             content.append(Spacer(1, 12))
-            content.append(Paragraph(line, section_header_style))
+            content.append(Paragraph(current_section, section_header_style))
         else:
             bullets.append(line)
+
     flush_bullets()
 
-    # ATS suggestions section
+    # ATS Recommendations
     if match_analysis.get('ats_optimization_suggestions'):
         content.append(Spacer(1, 20))
         content.append(Paragraph("ATS Optimization Recommendations", section_header_style))
         content.append(Spacer(1, 10))
-        for s in match_analysis['ats_optimization_suggestions']:
-            section = s.get('section','')
-            current = s.get('current_content','')
-            change = s.get('suggested_change','')
-            keywords = ', '.join(s.get('keywords_to_add',[]) or [])
-            formatting = s.get('formatting_suggestion','')
-            reason = s.get('reason','')
-
-            content.append(Paragraph(f"• Section: {section}", bullet_style))
+
+        for suggestion in match_analysis['ats_optimization_suggestions']:
+            section = suggestion.get('section', '')
+            current = suggestion.get('current_content', '')
+            suggested = suggestion.get('suggested_change', '')
+            keywords = ', '.join(suggestion.get('keywords_to_add', []))
+            formatting = suggestion.get('formatting_suggestion', '')
+            reason = suggestion.get('reason', '')
+            content.append(Paragraph(f"• Section: {section}", recommendation_style))
             if current:
-                content.append(Paragraph(f"  Current: {current}", bullet_style))
-            content.append(Paragraph(f"  Suggestion: {change}", bullet_style))
+                content.append(Paragraph(f" Current: {current}", recommendation_style))
+            content.append(Paragraph(f" Suggestion: {suggested}", recommendation_style))
             if keywords:
-                content.append(Paragraph(f"  Keywords to Add: {keywords}", bullet_style))
+                content.append(Paragraph(f" Keywords to Add: {keywords}", recommendation_style))
             if formatting:
-                content.append(Paragraph(f"  Formatting: {formatting}", bullet_style))
+                content.append(Paragraph(f" Formatting: {formatting}", recommendation_style))
             if reason:
-                content.append(Paragraph(f"  Reason: {reason}", bullet_style))
+                content.append(Paragraph(f" Reason: {reason}", recommendation_style))
             content.append(Spacer(1, 6))
 
     doc.build(content)
     buffer.seek(0)
     return buffer
 
+def generate_updated_resume1(resume_text, match_analysis):
+    buffer = BytesIO()
+    doc = SimpleDocTemplate(buffer, pagesize=letter)
+    styles = getSampleStyleSheet()
+
+    # Modify existing styles
+    styles['Heading1'].fontSize = 14
+    styles['Heading1'].spaceAfter = 16
+    styles['Heading1'].textColor = colors.HexColor('#2c3e50')
+    styles['Heading2'].fontSize = 12
+    styles['Heading2'].spaceAfter = 12
+    styles['Heading2'].textColor = colors.HexColor('#34495e')
+    styles['Normal'].fontSize = 10
+    styles['Normal'].spaceAfter = 8
+    styles['Normal'].leading = 14
+
+    # Add a custom style for recommendations
+    styles.add(ParagraphStyle(
+        name='RecommendationStyle',
+        parent=styles['Normal'],
+        fontSize=10,
+        spaceAfter=8,
+        leading=14,
+        leftIndent=20,
+        textColor=colors.HexColor('#2980b9')
+    ))
+
+    # Create content
+    content = []
+
+    # Add header
+    content.append(Paragraph("Updated Resume", styles['Heading1']))
+    content.append(Spacer(1, 12))
+
+    # Add existing resume content with proper formatting
+    resume_parts = resume_text.split("\n")
+    current_section = None
+    for part in resume_parts:
+        if part.strip(): # Skip empty lines
+            # Detect section headers (uppercase or common section names)
+            common_sections = ['EXPERIENCE', 'EDUCATION', 'SKILLS', 'PROJECTS', 'CERTIFICATIONS']
+            is_section = part.isupper() or any(section in part.upper() for section in common_sections)
+
+            if is_section:
+                current_section = part
+                content.append(Paragraph(part, styles['Heading2']))
+            else:
+                content.append(Paragraph(part, styles['Normal']))
+            content.append(Spacer(1, 6))
+
+    # Add ATS optimization recommendations
+    if match_analysis.get('ats_optimization_suggestions'):
+        content.append(Spacer(1, 12))
+        content.append(Paragraph("ATS Optimization Recommendations", styles['Heading2']))
+        content.append(Spacer(1, 8))
+
+        for suggestion in match_analysis['ats_optimization_suggestions']:
+            content.append(Paragraph(f"• Section: {suggestion['section']}", styles['RecommendationStyle']))
+            if suggestion.get('current_content'):
+                content.append(Paragraph(f" Current: {suggestion['current_content']}", styles['RecommendationStyle']))
+            content.append(Paragraph(f" Suggestion: {suggestion['suggested_change']}", styles['RecommendationStyle']))
+            if suggestion.get('keywords_to_add'):
+                content.append(Paragraph(f" Keywords to Add: {', '.join(suggestion['keywords_to_add'])}", styles['RecommendationStyle']))
+            if suggestion.get('formatting_suggestion'):
+                content.append(
+                    Paragraph(f" Formatting: {suggestion['formatting_suggestion']}", styles['RecommendationStyle']))
+            content.append(Spacer(1, 6))
 
-# ---------- Gemini helpers ----------
-def _configure_model(api_key: str):
-    genai.configure(api_key=api_key)
-    return genai.GenerativeModel("gemini-1.5-flash")
+    # Build PDF
+    doc.build(content)
+    buffer.seek(0)
+    return buffer
 
-def _parse_json_or_show(raw_text: str) -> dict:
-    """Try JSON parse; if fails, show the raw output and propagate an empty dict."""
-    if raw_text is None:
-        raise ValueError("Empty response from model.")
-    txt = raw_text.strip()
-    try:
-        return json.loads(txt)
-    except Exception:
-        st.error("The model did not return valid JSON. Raw output shown below to help you debug:")
-        st.code(raw_text)
-        return {}
 
 class JobAnalyzer:
     def __init__(self, api_key: str):
-        self.model = _configure_model(api_key)
+        # Configure Google Generative AI
+        genai.configure(api_key=api_key)
+        self.model = genai.GenerativeModel("gemini-1.5-flash") # You can choose a different model
 
     def analyze_job(self, job_description: str) -> dict:
-        prompt = f"""
-Return ONLY valid JSON for this job description with keys:
-1) "key_technical_skills"
-2) "soft_skills"
-3) "years_experience"
-4) "education_requirements"
-5) "key_responsibilities"
-6) "company_culture_indicators"
-7) "required_certifications"
-8) "industry_type"
-9) "job_level"
-10) "key_technologies"
-
-Job Description:
-{job_description}
+        prompt = """
+Analyze this job description and provide a detailed JSON with:
+1. Key technical skills required
+2. Soft skills required
+3. Years of experience required
+4. Education requirements
+5. Key responsibilities
+6. Company culture indicators
+7. Required certifications
+8. Industry type
+9. Job level (entry, mid, senior)
+10. Key technologies mentioned
+
+Format the response as a JSON object with these categories.
+Job Description: {description}
 """
         try:
-            resp = self.model.generate_content(prompt)
-            return _parse_json_or_show(getattr(resp, "text", None))
+            response = self.model.generate_content(prompt.format(description=job_description))
+            # Assuming the response text is a valid JSON string
+            parsed_response = json.loads(response.text)
+            return parsed_response
         except Exception as e:
-            st.error(f"Error analyzing job description: {e}")
+            st.error(f"Error analyzing job description: {str(e)}")
             return {}
 
     def analyze_resume(self, resume_text: str) -> dict:
-        prompt = f"""
-Return ONLY valid JSON for this resume with keys:
-1) "technical_skills"
-2) "soft_skills"
-3) "years_experience"
-4) "education_details"
-5) "key_achievements"
-6) "core_competencies"
-7) "industry_experience"
-8) "leadership_experience"
-9) "technologies_used"
-10) "projects_completed"
-
-Resume:
-{resume_text}
+        prompt = """
+Analyze this resume and provide a detailed JSON with:
+1. Technical skills
+2. Soft skills
+3. Years of experience
+4. Education details
+5. Key achievements
+6. Core competencies
+7. Industry experience
+8. Leadership experience
+9. Technologies used
+10. Projects completed
+
+Format the response as a JSON object with these categories.
+Resume: {resume}
 """
         try:
-            resp = self.model.generate_content(prompt)
-            return _parse_json_or_show(getattr(resp, "text", None))
+            response = self.model.generate_content(prompt.format(resume=resume_text))
+            # Assuming the response text is a valid JSON string
+            parsed_response = json.loads(response.text)
+            return parsed_response
+        except json.JSONDecodeError as e:
+            st.error(
+                f"Error parsing resume analysis response: {str(e)}. Please check the resume text for any formatting issues.")
+            return {}
         except Exception as e:
-            st.error(f"Error analyzing resume: {e}")
+            st.error(f"Error analyzing resume: {str(e)}")
             return {}
 
     def analyze_match(self, job_analysis: dict, resume_analysis: dict) -> dict:
-        prompt = f"""Respond ONLY with valid JSON. Compare and return EXACT keys:
+        prompt = """You are a professional resume analyzer. Compare the provided job requirements and resume to generate a detailed analysis in valid JSON format. IMPORTANT: Respond ONLY with a valid JSON object and NO additional text or formatting.
+Job Requirements: {job}
+Resume Details: {resume}
 
+Generate a response following this EXACT structure:
 {{
   "overall_match_percentage":"85%",
-  "matching_skills":[{{"skill_name":"Python","is_match":true}}],
+  "matching_skills":[{{"skill_name":"Python","is_match":true}},{{"skill_name":"AWS","is_match":true}}],
   "missing_skills":[{{"skill_name":"Docker","is_match":false,"suggestion":"Consider obtaining Docker certification"}}],
-  "skills_gap_analysis":{{"technical_skills":"...", "soft_skills":"..."}},
-  "experience_match_analysis":"...",
-  "education_match_analysis":"...",
-  "recommendations_for_improvement":[{{"recommendation":"...", "section":"...", "guidance":"..."}}],
-  "ats_optimization_suggestions":[{{"section":"...", "current_content":"...", "suggested_change":"...", "keywords_to_add":["..."], "formatting_suggestion":"...", "reason":"..."}}],
-  "key_strengths":"...",
-  "areas_of_improvement":"..."
+  "skills_gap_analysis":{{"technical_skills":"Specific technical gap analysis","soft_skills":"Specific soft skills gap analysis"}},
+  "experience_match_analysis":"Detailed experience match analysis",
+  "education_match_analysis":"Detailed education match analysis",
+  "recommendations_for_improvement":[{{"recommendation":"Add metrics","section":"Experience","guidance":"Quantify achievements with specific numbers"}}],
+  "ats_optimization_suggestions":[{{"section":"Skills","current_content":"Current format","suggested_change":"Specific change needed","keywords_to_add":["keyword1","keyword2"],"formatting_suggestion":"Specific format change","reason":"Detailed reason"}}],
+  "key_strengths":"Specific key strengths",
+  "areas_of_improvement":"Specific areas to improve"
 }}
 
-Job Requirements:
-{job}
-
-Resume Details:
-{resume}
-"""
+Focus on providing detailed, actionable insights for each field. Keep the JSON structure exact but replace the example content with detailed analysis based on the provided job and resume."""
         try:
-            resp = self.model.generate_content(
+            response = self.model.generate_content(
                 prompt.format(
                     job=json.dumps(job_analysis, indent=2),
                     resume=json.dumps(resume_analysis, indent=2)
                 )
             )
-            return _parse_json_or_show(getattr(resp, "text", None))
+            try:
+                # Clean up the response content
+                response_content = response.text.strip()
+                # Remove any leading/trailing whitespace or quotes
+                response_content = response_content.strip('"\'')
+                # Parse the JSON
+                parsed_response = json.loads(response_content)
+                return parsed_response
+            except json.JSONDecodeError as e:
+                st.error(f"Error parsing match analysis response. Please try again.")
+                print(f"Debug - Response content: {response.text}")
+                print(f"Debug - Error details: {str(e)}")
+                return {}
+            return parsed_response
         except Exception as e:
-            st.error(f"Error analyzing match: {e}")
+            st.error(f"Error analyzing match: {str(e)}")
             return {}
 
 
 class CoverLetterGenerator:
     def __init__(self, api_key: str):
-        self.model = _configure_model(api_key)
-
-    def generate_cover_letter(self, job_analysis: dict, resume_analysis: dict, match_analysis: dict, tone: str = "professional") -> str:
-        prompt = f"""
-Generate a tailored cover letter. Be concise, ATS-friendly, specific, and include a strong CTA.
-
-Job:
-{job_analysis}
-
-Resume:
-{resume_analysis}
-
-Match:
-{match_analysis}
-
+        # Configure Google Generative AI
+        genai.configure(api_key=api_key)
+        self.model = genai.GenerativeModel("gemini-1.5-flash") # You can choose a different model
+
+    def generate_cover_letter(self, job_analysis: dict, resume_analysis: dict, match_analysis: dict,
+                                tone: str = "professional") -> str:
+        prompt = """
+Generate a compelling cover letter using this information:
+Job Details: {job}
+Candidate Details: {resume}
+Match Analysis: {match}
 Tone: {tone}
+
+Requirements:
+1. Make it personal and specific
+2. Highlight the strongest matches
+3. Address potential gaps professionally
+4. Keep it concise but impactful
+5. Use the specified tone: {tone}
+6. Include specific examples from the resume
+7. Make it ATS-friendly
+8. Add a strong call to action
 """
         try:
-            resp = self.model.generate_content(
+            response = self.model.generate_content(
                 prompt.format(
                     job=json.dumps(job_analysis, indent=2),
                     resume=json.dumps(resume_analysis, indent=2),
@@ -263,127 +365,157 @@ Tone: {tone}
                     tone=tone
                 )
             )
-            return (getattr(resp, "text", None) or "").strip()
+            return response.text
         except Exception as e:
-            st.error(f"Error generating cover letter: {e}")
+            st.error(f"Error generating cover letter: {str(e)}")
             return ""
 
 
-# ---------- Streamlit UI ----------
 def main():
     st.set_page_config(page_title="LinkedIn Job Application Assistant - HireReady 📝", layout="wide")
 
-    api_key = st.sidebar.text_input("Enter Google (Gemini) API Key 🗝️", type="password")
+    # API key input
+    api_key = st.sidebar.text_input("Enter Google AI Studio API Key 🗝️", type="password") # Changed label
     if not api_key:
-        st.warning("🔑 Enter your Google Gemini API key to continue.")
+        st.warning("🔑 Please enter your Google AI Studio API key to continue.")
         return
 
     st.title("LinkedIn Job Application Assistant - HireReady 🚀")
-    st.markdown("Analyze a job description and your resume, get a match report, a cover letter, and an updated resume.")
+    st.markdown("""
+    Optimize your job application by analyzing job requirements 📋, matching your resume 📜, and generating tailored cover letters 💌.
+    """)
 
-    analyzer = JobAnalyzer(api_key)
-    letter_gen = CoverLetterGenerator(api_key)
+    # Initialize analyzers
+    # Pass the API key during initialization
+    job_analyzer = JobAnalyzer(api_key)
+    cover_letter_gen = CoverLetterGenerator(api_key)
 
+    # File Upload Section
     col1, col2 = st.columns(2)
     with col1:
         st.subheader("Job Description 📋")
         job_desc = st.text_area("Paste the job description here", height=300)
     with col2:
         st.subheader("Your Resume 📜")
-        resume_file = st.file_uploader("Upload your resume (PDF/DOCX)", type=['pdf', 'docx'])
+        resume_file = st.file_uploader("Upload your resume", type=['pdf', 'docx'])
 
     if job_desc and resume_file:
         with st.spinner("🔍 Analyzing your application..."):
+            # Load and analyze resume
             resume_text = load_resume(resume_file)
-            if not resume_text:
-                st.error("Couldn't read the resume file.")
-                return
-
-            job_analysis = analyzer.analyze_job(job_desc)
-            resume_analysis = analyzer.analyze_resume(resume_text)
-            match_analysis = analyzer.analyze_match(job_analysis, resume_analysis)
-
-            if not job_analysis or not resume_analysis or not match_analysis:
-                st.error("Insufficient data returned from the model.")
-                return
-
-            st.header("Analysis Results 📊")
-            c1, c2, c3 = st.columns(3)
-            with c1:
-                st.metric("Overall Match 🎯", f"{match_analysis.get('overall_match_percentage', '0%')}")
-            with c2:
-                st.metric("Skills Match 🧠", f"{len(match_analysis.get('matching_skills', []))} skills")
-            with c3:
-                st.metric("Skills to Develop 📈", f"{len(match_analysis.get('missing_skills', []))} skills")
-
-            tab1, tab2, tab3, tab4, tab5 = st.tabs([
-                "Skills Analysis 📊", "Experience Match 🗂️", "Recommendations 💡", "Cover Letter 💌", "Updated Resume 📝"
-            ])
-
-            with tab1:
-                st.subheader("Matching Skills")
-                for s in match_analysis.get('matching_skills', []):
-                    st.success(f"✅ {s.get('skill_name','')}")
-
-                st.subheader("Missing Skills")
-                for s in match_analysis.get('missing_skills', []):
-                    st.warning(f"⚠️ {s.get('skill_name','')}")
-                    if s.get('suggestion'):
-                        st.info(f"Suggestion: {s['suggestion']}")
-
-                data = pd.DataFrame({
-                    'Status': ['Matching', 'Missing'],
-                    'Count': [len(match_analysis.get('matching_skills', [])),
-                              len(match_analysis.get('missing_skills', []))]
-                })
-                fig = px.bar(data, x='Status', y='Count', color='Status',
-                             color_discrete_sequence=['#5cb85c', '#d9534f'],
-                             title='Skills Analysis')
-                fig.update_layout(xaxis_title='Status', yaxis_title='Count')
-                st.plotly_chart(fig)
-
-            with tab2:
-                st.write("### Experience Match Analysis 🗂️")
-                st.write(match_analysis.get('experience_match_analysis', ''))
-                st.write("### Education Match Analysis 🎓")
-                st.write(match_analysis.get('education_match_analysis', ''))
-
-            with tab3:
-                st.write("### Key Recommendations 🔑")
-                for rec in match_analysis.get('recommendations_for_improvement', []):
-                    st.info(f"**{rec.get('recommendation','')}**")
-                    st.write(f"**Section:** {rec.get('section','')}")
-                    st.write(f"**Guidance:** {rec.get('guidance','')}")
-
-                st.write("### ATS Optimization Suggestions 🤖")
-                for sug in match_analysis.get('ats_optimization_suggestions', []):
-                    st.write("---")
-                    st.warning(f"**Section to Modify:** {sug.get('section','')}")
-                    if sug.get('current_content'):
-                        st.write(f"**Current Content:** {sug['current_content']}")
-                    st.write(f"**Suggested Change:** {sug.get('suggested_change','')}")
-                    if sug.get('keywords_to_add'):
-                        st.write(f"**Keywords to Add:** {', '.join(sug['keywords_to_add'])}")
-                    if sug.get('formatting_suggestion'):
-                        st.write(f"**Formatting Changes:** {sug['formatting_suggestion']}")
-                    if sug.get('reason'):
-                        st.info(f"**Reason for Change:** {sug['reason']}")
-
-            with tab4:
-                st.write("### Cover Letter Generator 🖊️")
-                tone = st.selectbox("Select tone 🎭", ["Professional 👔", "Enthusiastic 😃", "Confident 😎", "Friendly 👋"])
-                if st.button("Generate Cover Letter ✍️"):
-                    with st.spinner("✍️ Crafting your cover letter..."):
-                        cover = letter_gen.generate_cover_letter(job_analysis, resume_analysis, match_analysis, tone.lower().split()[0])
-                        st.markdown("### Your Custom Cover Letter 💌")
-                        st.text_area("", cover, height=400)
-                        st.download_button("Download Cover Letter 📥", cover, "cover_letter.txt", "text/plain")
-
-            with tab5:
-                st.write("### Updated Resume 📝")
-                updated_pdf = generate_updated_resume(resume_text, match_analysis)
-                st.download_button("Download Updated Resume 📥", updated_pdf, "updated_resume.pdf", mime="application/pdf")
+            if resume_text:
+                # Perform analysis
+                job_analysis = job_analyzer.analyze_job(job_desc)
+                resume_analysis = job_analyzer.analyze_resume(resume_text)
+                match_analysis = job_analyzer.analyze_match(job_analysis, resume_analysis)
+
+                if not job_analysis or not resume_analysis or not match_analysis:
+                    st.error("Insufficient data returned from the API. Please try again.")
+                    return
+
+                # Display Results
+                st.header("Analysis Results 📊")
+
+                # Match Overview
+                col1, col2, col3 = st.columns(3)
+                with col1:
+                    st.metric(
+                        "Overall Match 🎯",
+                        f"{match_analysis.get('overall_match_percentage', '0%')}"
+                    )
+                with col2:
+                    st.metric(
+                        "Skills Match 🧠",
+                        f"{len(match_analysis.get('matching_skills', []))} skills"
+                    )
+                with col3:
+                    st.metric(
+                        "Skills to Develop 📈",
+                        f"{len(match_analysis.get('missing_skills', []))} skills"
+                    )
+
+                # Detailed Analysis Tabs
+                tab1, tab2, tab3, tab4, tab5 = st.tabs([
+                    "Skills Analysis 📊", "Experience Match 🗂️", "Recommendations 💡", "Cover Letter 💌", "Updated Resume 📝"
+                ])
+
+                with tab1:
+                    st.subheader("Matching Skills")
+                    for skill in match_analysis.get('matching_skills', []):
+                        st.success(f"✅ {skill['skill_name']}")
+
+                    st.subheader("Missing Skills")
+                    for skill in match_analysis.get('missing_skills', []):
+                        st.warning(f"⚠️ {skill['skill_name']}")
+                        st.info(f"Suggestion: {skill['suggestion']}")
+
+                    # Skills analysis graph
+                    matching_skills_count = len(match_analysis.get('matching_skills', []))
+                    missing_skills_count = len(match_analysis.get('missing_skills', []))
+                    skills_data = pd.DataFrame({
+                        'Status': ['Matching', 'Missing'],
+                        'Count': [matching_skills_count, missing_skills_count]
+                    })
+                    fig = px.bar(skills_data, x='Status', y='Count', color='Status',
+                                 color_discrete_sequence=['#5cb85c', '#d9534f'], title='Skills Analysis')
+                    fig.update_layout(xaxis_title='Status', yaxis_title='Count')
+                    st.plotly_chart(fig)
+
+                with tab2:
+                    st.write("### Experience Match Analysis 🗂️")
+                    st.write(match_analysis.get('experience_match_analysis', ''))
+                    st.write("### Education Match Analysis 🎓")
+                    st.write(match_analysis.get('education_match_analysis', ''))
+
+                with tab3:
+                    st.write("### Key Recommendations 🔑")
+                    for rec in match_analysis.get('recommendations_for_improvement', []):
+                        st.info(f"**{rec['recommendation']}**")
+                        st.write(f"**Section:** {rec['section']}")
+                        st.write(f"**Guidance:** {rec['guidance']}")
+
+                    st.write("### ATS Optimization Suggestions 🤖")
+                    for suggestion in match_analysis.get('ats_optimization_suggestions', []):
+                        st.write("---")
+                        st.warning(f"**Section to Modify:** {suggestion['section']}")
+                        if suggestion.get('current_content'):
+                            st.write(f"**Current Content:** {suggestion['current_content']}")
+                        st.write(f"**Suggested Change:** {suggestion['suggested_change']}")
+                        if suggestion.get('keywords_to_add'):
+                            st.write(f"**Keywords to Add:** {', '.join(suggestion['keywords_to_add'])}")
+                        if suggestion.get('formatting_suggestion'):
+                            st.write(f"**Formatting Changes:** {suggestion['formatting_suggestion']}")
+                        if suggestion.get('reason'):
+                            st.info(f"**Reason for Change:** {suggestion['reason']}")
+
+                with tab4:
+                    st.write("### Cover Letter Generator 🖊️")
+                    tone = st.selectbox("Select tone 🎭", ["Professional 👔", "Enthusiastic 😃", "Confident 😎", "Friendly 👋"])
+
+                    if st.button("Generate Cover Letter ✍️"):
+                        with st.spinner("✍️ Crafting your cover letter..."):
+                            cover_letter = cover_letter_gen.generate_cover_letter(
+                                job_analysis, resume_analysis, match_analysis, tone.lower().split()[0])
+                            st.markdown("### Your Custom Cover Letter 💌")
+                            st.text_area("", cover_letter, height=400)
+                            st.download_button(
+                                "Download Cover Letter 📥",
+                                cover_letter,
+                                "cover_letter.txt",
+                                "text/plain"
+                            )
+
+                with tab5:
+                    st.write("### Updated Resume 📝")
+                    updated_resume = generate_updated_resume(resume_text, match_analysis)
+                    # Provide a download button for the updated resume
+                    st.download_button(
+                        "Download Updated Resume 📥",
+                        updated_resume,
+                        "updated_resume.pdf",
+                        mime="application/pdf"
+                    )
 
 
 if __name__ == "__main__":
-    main()
+    main()