Update src/app.py

src/app.py

@@ -58,8 +58,6 @@ from reportlab.lib.pagesizes import letter
 from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
 from reportlab.lib.styles import getSampleStyleSheet
 from reportlab.lib.units import inch
-from reportlab.graphics.charts.barcharts import VerticalBarChart
-from reportlab.graphics.shapes import Drawing
 
 # Claude Chatbot Class
 class ClaudeChatbot:
@@ -80,7 +78,7 @@ class ClaudeChatbot:
         headers = {
             "Authorization": f"Bearer {self.api_key}",
             "Content-Type": "application/json",
-            "HTTP-Referer": "https://your-app-url.com",  # Replace with your actual URL
+            "HTTP-Referer": "https://your-app-url.com",
             "X-Title": "AI Resume Analyzer"
         }
         
@@ -125,7 +123,7 @@ def download_nltk_data():
             nltk.download('punkt', quiet=True)
             nltk.download('stopwords', quiet=True)
             nltk.download('wordnet', quiet=True)
-            nltk.download('punkt_tab', quiet=True)  # For newer NLTK versions
+            nltk.download('punkt_tab', quiet=True)
 
 # Initialize tools with better error handling
 @st.cache_resource
@@ -139,7 +137,6 @@ def init_tools():
             st.success("✅ spaCy model loaded successfully")
         except OSError:
             try:
-                # Try to download the model automatically
                 import subprocess
                 import sys
                 with st.spinner("Downloading spaCy model..."):
@@ -163,17 +160,14 @@ def init_tools():
     
     return nlp, grammar_tool
 
-# Fallback functions for when dependencies are missing
 def simple_fuzzy_match(keyword, text):
     """Simple fuzzy matching fallback when fuzzywuzzy is not available"""
     keyword_lower = keyword.lower()
     text_lower = text.lower()
     
-    # Exact match
     if keyword_lower in text_lower:
         return 100
     
-    # Check for partial matches with some tolerance
     keyword_words = keyword_lower.split()
     matches = sum(1 for word in keyword_words if word in text_lower)
     return (matches / len(keyword_words)) * 100 if keyword_words else 0
@@ -182,15 +176,12 @@ def basic_grammar_check(text):
     """Basic grammar check when language_tool_python is not available"""
     issues = []
     
-    # Check for common issues
     sentences = sent_tokenize(text)
     
     for i, sentence in enumerate(sentences):
-        # Check for sentences that are too long
         if len(sentence.split()) > 30:
             issues.append(f"Sentence {i+1} might be too long ({len(sentence.split())} words)")
         
-        # Check for repeated words
         words = sentence.lower().split()
         for j in range(len(words) - 1):
             if words[j] == words[j + 1] and len(words[j]) > 3:
@@ -206,12 +197,11 @@ class ResumeAnalyzer:
         try:
             self.stop_words = set(stopwords.words('english'))
         except LookupError:
-            # Fallback stop words
             self.stop_words = {'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by', 'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'should', 'could', 'can', 'may', 'might', 'must'}
         
         self.lemmatizer = WordNetLemmatizer()
         
-        # Expanded job role keywords dictionary (15 total roles)
+        # Job role keywords dictionary
         self.job_keywords = {
             "Data Scientist": ["python", "machine learning", "statistics", "pandas", "numpy", "scikit-learn", 
                               "tensorflow", "pytorch", "sql", "data analysis", "visualization", "jupyter", "r", "statistics", "deep learning"],
@@ -233,16 +223,6 @@ class ResumeAnalyzer:
                                 "business process", "gap analysis", "user stories", "workflow", "project management"],
             "Full Stack Developer": ["html", "css", "javascript", "react", "angular", "vue", "node.js", "express",
                                    "mongodb", "postgresql", "rest api", "graphql", "version control", "responsive design"],
-            "Machine Learning Engineer": ["tensorflow", "pytorch", "keras", "scikit-learn", "mlops", "model deployment",
-                                        "feature engineering", "model optimization", "docker", "kubernetes", "python", "deep learning"],
-            "Cloud Architect": ["aws", "azure", "gcp", "cloud migration", "serverless", "microservices", "containerization",
-                              "infrastructure as code", "cost optimization", "scalability", "security"],
-            "Sales Manager": ["sales", "crm", "lead generation", "client relationship", "negotiation", "revenue growth",
-                             "pipeline management", "forecasting", "team leadership", "quota attainment"],
-            "Project Manager": ["project management", "pmp", "agile", "scrum", "kanban", "risk management",
-                               "stakeholder communication", "budget management", "timeline", "resource allocation"],
-            "Quality Assurance Engineer": ["testing", "automation", "selenium", "junit", "test cases", "bug tracking",
-                                         "regression testing", "performance testing", "api testing", "quality standards"]
         }
         
         # Common skills database
@@ -265,14 +245,12 @@ class ResumeAnalyzer:
     def extract_text_from_pdf(self, file):
         """Extract text from PDF file"""
         try:
-            # Try pdfplumber first
             with pdfplumber.open(file) as pdf:
                 text = ""
                 for page in pdf.pages:
                     text += page.extract_text() or ""
             return text
         except:
-            # Fallback to PyPDF2
             try:
                 pdf_reader = PyPDF2.PdfReader(file)
                 text = ""
@@ -302,23 +280,18 @@ class ResumeAnalyzer:
 
     def preprocess_text(self, text):
         """Clean and preprocess text"""
-        # Remove special characters and digits
         text = re.sub(r'[^a-zA-Z\s]', '', text)
-        # Convert to lowercase
         text = text.lower()
-        # Tokenize
+        
         try:
             tokens = word_tokenize(text)
         except LookupError:
-            # Fallback tokenization
             tokens = text.split()
         
-        # Remove stopwords and lemmatize
         try:
             tokens = [self.lemmatizer.lemmatize(token) for token in tokens 
                      if token not in self.stop_words and len(token) > 2]
         except LookupError:
-            # Fallback without lemmatization
             tokens = [token for token in tokens 
                      if token not in self.stop_words and len(token) > 2]
         
@@ -328,7 +301,6 @@ class ResumeAnalyzer:
         """Extract different sections from resume"""
         sections = {}
         
-        # Define section patterns
         section_patterns = {
             'education': r'(education|academic|qualification|degree|university|college)',
             'experience': r'(experience|employment|work|career|professional|job|position)',
@@ -351,7 +323,6 @@ class ResumeAnalyzer:
                     continue
                 
                 if capturing:
-                    # Stop if we hit another section
                     if any(re.search(p, line.lower()) for p in section_patterns.values() if p != pattern):
                         break
                     if line.strip():
@@ -373,7 +344,6 @@ class ResumeAnalyzer:
                 found_technical.append(skill)
         
         for skill in self.soft_skills:
-            # Use more flexible matching for soft skills
             skill_words = skill.lower().split()
             if all(word in text_lower for word in skill_words):
                 found_soft.append(skill)
@@ -391,11 +361,9 @@ class ResumeAnalyzer:
         found_keywords = []
         for keyword in keywords:
             if FUZZYWUZZY_AVAILABLE:
-                # Use fuzzy matching
                 if fuzz.partial_ratio(keyword, text_lower) > 80:
                     found_keywords.append(keyword)
             else:
-                # Use simple matching
                 if simple_fuzzy_match(keyword, text_lower) > 80:
                     found_keywords.append(keyword)
         
@@ -406,7 +374,7 @@ class ResumeAnalyzer:
         """Check grammar and language quality"""
         if self.grammar_tool and GRAMMAR_TOOL_AVAILABLE:
             try:
-                matches = self.grammar_tool.check(text[:5000])  # Limit text length
+                matches = self.grammar_tool.check(text[:5000])
                 return matches
             except:
                 return basic_grammar_check(text)
@@ -455,12 +423,10 @@ class ResumeAnalyzer:
         experience = sections.get('experience', '')
         skills = sections.get('skills', '')
         
-        # Extract key information
         degree_match = re.search(r'(bachelor|master|phd|degree|engineering|science|business)', 
                                 education.lower())
         experience_years = len(re.findall(r'\b\d{4}\b', experience))
         
-        # Create summary template
         summary_parts = []
         
         if degree_match:
@@ -472,7 +438,6 @@ class ResumeAnalyzer:
         if experience_years > 0:
             summary_parts.append(f"with {experience_years}+ years of experience")
         
-        # Add skills context
         tech_skills, soft_skills = self.extract_skills(text)
         if tech_skills:
             main_skills = ', '.join(tech_skills[:3])
@@ -603,7 +568,11 @@ def main():
                 st.error("❌ Claude API Not Available")
     
     # Initialize analyzer
-    analyzer = ResumeAnalyzer()
+    try:
+        analyzer = ResumeAnalyzer()
+    except Exception as e:
+        st.error(f"Error initializing analyzer: {str(e)}")
+        return
     
     # Sidebar for job role selection
     st.sidebar.header("Analysis Settings")
@@ -629,321 +598,365 @@ def main():
         file_type = uploaded_file.type
         
         with st.spinner("Extracting text from resume..."):
-            if file_type == "application/pdf":
-                text = analyzer.extract_text_from_pdf(uploaded_file)
-            elif file_type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
-                text = analyzer.extract_text_from_docx(uploaded_file)
-            else:  # txt
-                text = analyzer.extract_text_from_txt(uploaded_file)
-        
-        if "Error" not in text:
+            try:
+                if file_type == "application/pdf":
+                    text = analyzer.extract_text_from_pdf(uploaded_file)
+                elif file_type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
+                    text = analyzer.extract_text_from_docx(uploaded_file)
+                else:  # txt
+                    text = analyzer.extract_text_from_txt(uploaded_file)
+            except Exception as e:
+                st.error(f"Error extracting text: {str(e)}")
+                return
+        
+        if "Error" not in text and text.strip():
             # Process the resume
             st.success("✅ Resume uploaded and processed successfully!")
             
             # Store resume context for chatbot
             st.session_state.resume_context = text
             
-            # Extract data for analysis
-            sections = analyzer.extract_sections(text)
-            tech_skills, soft_skills = analyzer.extract_skills(text)
-            found_keywords, match_percentage = analyzer.keyword_matching(text, selected_role)
-            ats_score = analyzer.calculate_ats_score(text, sections)
-            
-            # Create tabs for different analyses
-            tab1, tab2, tab3, tab4, tab5, tab6 = st.tabs([
-                "📊 Overview", "🎯 Skills Analysis", "📝 Section Breakdown", 
-                "🔍 ATS Analysis", "📋 Report & Suggestions", "🤖 AI Assistant"
-            ])
-            
-            with tab1:
-                st.header("Resume Overview")
-                
-                col1, col2 = st.columns(2)
-                
-                with col1:
-                    # Basic stats
-                    word_count = len(text.split())
-                    char_count = len(text)
+            try:
+                # Extract data for analysis
+                sections = analyzer.extract_sections(text)
+                tech_skills, soft_skills = analyzer.extract_skills(text)
+                found_keywords, match_percentage = analyzer.keyword_matching(text, selected_role)
+                ats_score = analyzer.calculate_ats_score(text, sections)
+                
+                # Create tabs for different analyses
+                tab1, tab2, tab3, tab4, tab5, tab6 = st.tabs([
+                    "📊 Overview", "🎯 Skills Analysis", "📝 Section Breakdown", 
+                    "🔍 ATS Analysis", "📋 Report & Suggestions", "🤖 AI Assistant"
+                ])
+                
+                with tab1:
+                    st.header("Resume Overview")
                     
-                    st.metric("Word Count", word_count)
-                    st.metric("Character Count", char_count)
-                    st.metric("Sections Found", len([s for s in sections.values() if s]))
-                
-                with col2:
-                    # Generate persona summary
-                    persona_summary = analyzer.generate_persona_summary(text, sections)
-                    st.subheader("🎭 AI Persona Summary")
-                    st.info(persona_summary)
-                
-                # Word cloud
-                st.subheader("☁️ Word Cloud")
-                preprocessed_tokens = analyzer.preprocess_text(text)
-                if preprocessed_tokens:
-                    wordcloud_text = ' '.join(preprocessed_tokens)
-                    try:
-                        wordcloud = WordCloud(width=800, height=400, background_color='white').generate(wordcloud_text)
+                    col1, col2 = st.columns(2)
+                    
+                    with col1:
+                        # Basic stats
+                        word_count = len(text.split())
+                        char_count = len(text)
                         
-                        fig, ax = plt.subplots(figsize=(12, 6))
-                        ax.imshow(wordcloud, interpolation='bilinear')
-                        ax.axis('off')
-                        st.pyplot(fig)
-                    except Exception as e:
-                        st.warning("Could not generate word cloud. Showing top words instead.")
-                        word_freq = Counter(preprocessed_tokens)
-                        top_words = word_freq.most_common(20)
+                        st.metric("Word Count", word_count)
+                        st.metric("Character Count", char_count)
+                        st.metric("Sections Found", len([s for s in sections.values() if s]))
+                    
+                    with col2:
+                        # Generate persona summary
+                        persona_summary = analyzer.generate_persona_summary(text, sections)
+                        st.subheader("🎭 AI Persona Summary")
+                        st.info(persona_summary)
+                    
+                    # Word cloud
+                    st.subheader("☁️ Word Cloud")
+                    preprocessed_tokens = analyzer.preprocess_text(text)
+                    if preprocessed_tokens:
+                        wordcloud_text = ' '.join(preprocessed_tokens)
+                        try:
+                            wordcloud = WordCloud(width=800, height=400, background_color='white').generate(wordcloud_text)
+                            
+                            fig, ax = plt.subplots(figsize=(12, 6))
+                            ax.imshow(wordcloud, interpolation='bilinear')
+                            ax.axis('off')
+                            st.pyplot(fig)
+                        except Exception as e:
+                            st.warning("Could not generate word cloud. Showing top words instead.")
+                            word_freq = Counter(preprocessed_tokens)
+                            top_words = word_freq.most_common(20)
+                            
+                            words_df = pd.DataFrame(top_words, columns=['Word', 'Frequency'])
+                            fig = px.bar(words_df, x='Word', y='Frequency', title='Top 20 Words')
+                            st.plotly_chart(fig)
+                
+                with tab2:
+                    st.header("Skills Analysis")
+                    
+                    col1, col2 = st.columns(2)
+                    
+                    with col1:
+                        st.subheader("🔧 Technical Skills")
+                        if tech_skills:
+                            skills_text = " • ".join(tech_skills)
+                            st.success(f"Found {len(tech_skills)} technical skills:")
+                            st.write(skills_text)
+                            
+                            if len(tech_skills) > 5:
+                                skills_df = pd.DataFrame({
+                                    'Skill': tech_skills[:10],
+                                    'Count': [1] * len(tech_skills[:10])
+                                })
+                                fig = px.pie(skills_df, values='Count', names='Skill', 
+                                           title='Technical Skills Distribution')
+                                st.plotly_chart(fig, use_container_width=True)
+                            else:
+                                skills_df = pd.DataFrame({
+                                    'Skill': tech_skills,
+                                    'Count': [1] * len(tech_skills)
+                                })
+                                fig = px.bar(skills_df, x='Skill', y='Count', 
+                                           title='Technical Skills Found')
+                                fig.update_xaxis(tickangle=45)
+                                st.plotly_chart(fig, use_container_width=True)
+                        else:
+                            st.warning("No soft skills detected")
+                            st.info("💡 Consider highlighting soft skills like leadership, communication, teamwork")
+                    
+                    # Role-specific keyword analysis
+                    st.subheader(f"🎯 {selected_role} Keywords")
+                    if found_keywords:
+                        st.success(f"Found {len(found_keywords)} relevant keywords for {selected_role}:")
+                        keywords_text = " • ".join(found_keywords)
+                        st.write(keywords_text)
+                        st.info(f"Match Percentage: {match_percentage:.1f}%")
                         
-                        words_df = pd.DataFrame(top_words, columns=['Word', 'Frequency'])
-                        fig = px.bar(words_df, x='Word', y='Frequency', title='Top 20 Words')
-                        st.plotly_chart(fig)
-            
-            with tab2:
-                st.header("Skills Analysis")
-                
-                col1, col2 = st.columns(2)
+                        # Progress bar for match percentage
+                        st.progress(match_percentage / 100)
+                    else:
+                        st.warning(f"No {selected_role}-specific keywords found")
+                        missing_keywords = [kw for kw in analyzer.job_keywords[selected_role] if kw not in text.lower()]
+                        if missing_keywords:
+                            st.info(f"💡 Consider adding these keywords: {', '.join(missing_keywords[:5])}")
                 
-                with col1:
-                    st.subheader("🔧 Technical Skills")
-                    if tech_skills:
-                        # Create a nice display for skills
-                        skills_text = " • ".join(tech_skills)
-                        st.success(f"Found {len(tech_skills)} technical skills:")
-                        st.write(skills_text)
-                        
-                        # Skills distribution chart
-                        if len(tech_skills) > 5:
-                            skills_df = pd.DataFrame({
-                                'Skill': tech_skills[:10],
-                                'Count': [1] * len(tech_skills[:10])
-                            })
-                            fig = px.pie(skills_df, values='Count', names='Skill', 
-                                       title='Technical Skills Distribution')
-                            st.plotly_chart(fig, use_container_width=True)
+                with tab3:
+                    st.header("Section Breakdown")
+                    
+                    for section_name, section_content in sections.items():
+                        if section_content:
+                            with st.expander(f"📑 {section_name.title()} Section"):
+                                st.text_area(
+                                    f"{section_name.title()} Content",
+                                    section_content,
+                                    height=200,
+                                    key=f"section_{section_name}"
+                                )
+                                
+                                # Section-specific analysis
+                                word_count = len(section_content.split())
+                                st.metric(f"{section_name.title()} Word Count", word_count)
+                                
+                                if section_name == "experience":
+                                    # Analyze experience section
+                                    years_mentioned = len(re.findall(r'\b(19|20)\d{2}\b', section_content))
+                                    companies_mentioned = len(re.findall(r'\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*\b', section_content))
+                                    st.metric("Years/Dates Mentioned", years_mentioned)
+                                    st.metric("Potential Companies", companies_mentioned)
+                                
+                                elif section_name == "education":
+                                    # Analyze education section
+                                    degrees = re.findall(r'\b(bachelor|master|phd|degree|diploma|certificate)\b', section_content.lower())
+                                    st.metric("Degrees/Certificates Found", len(degrees))
                         else:
-                            # Simple bar chart for fewer skills
-                            skills_df = pd.DataFrame({
-                                'Skill': tech_skills,
-                                'Count': [1] * len(tech_skills)
-                            })
-                            fig = px.bar(skills_df, x='Skill', y='Count', 
-                                       title='Technical Skills Found')
-                            fig.update_xaxis(tickangle=45)
-                            st.plotly_chart(fig, use_container_width=True)
-                    else:
-                        st.warning("No technical skills detected")
-                        st.info("💡 Consider adding technical skills relevant to your field")
+                            st.warning(f"⚠️ {section_name.title()} section not found or empty")
                 
-                with col2:
-                    st.subheader("🤝 Soft Skills")
-                    if soft_skills:
-                        skills_text = " • ".join(soft_skills)
-                        st.success(f"Found {len(soft_skills)} soft skills:")
-                        st.write(skills_text)
+                with tab4:
+                    st.header("ATS Analysis")
+                    
+                    col1, col2 = st.columns(2)
+                    
+                    with col1:
+                        st.subheader("📊 ATS Score Breakdown")
+                        st.metric("Overall ATS Score", f"{ats_score}/100")
                         
-                        # Soft skills chart
-                        if len(soft_skills) > 3:
-                            soft_df = pd.DataFrame({
-                                'Skill': soft_skills[:8],
-                                'Count': [1] * len(soft_skills[:8])
-                            })
-                            fig = px.bar(soft_df, x='Skill', y='Count', 
-                                       title='Soft Skills Found',
-                                       color='Skill')
-                            fig.update_xaxis(tickangle=45)
-                            st.plotly_chart(fig, use_container_width=True)
+                        # ATS score visualization
+                        fig = go.Figure(go.Indicator(
+                            mode = "gauge+number+delta",
+                            value = ats_score,
+                            domain = {'x': [0, 1], 'y': [0, 1]},
+                            title = {'text': "ATS Score"},
+                            delta = {'reference': 70},
+                            gauge = {
+                                'axis': {'range': [None, 100]},
+                                'bar': {'color': "darkblue"},
+                                'steps': [
+                                    {'range': [0, 50], 'color': "lightgray"},
+                                    {'range': [50, 70], 'color': "yellow"},
+                                    {'range': [70, 100], 'color': "green"}
+                                ],
+                                'threshold': {
+                                    'line': {'color': "red", 'width': 4},
+                                    'thickness': 0.75,
+                                    'value': 90
+                                }
+                            }
+                        ))
+                        st.plotly_chart(fig, use_container_width=True)
+                    
+                    with col2:
+                        st.subheader("🎯 Role Match Analysis")
+                        st.metric("Role Match Score", f"{match_percentage:.1f}%")
+                        
+                        # Combined score
+                        combined_score = (ats_score + match_percentage) / 2
+                        st.metric("Combined Score", f"{combined_score:.1f}/100")
+                        
+                        # Score interpretation
+                        if combined_score >= 80:
+                            st.success("🎉 Excellent! Your resume is well-optimized")
+                        elif combined_score >= 60:
+                            st.warning("👍 Good, but room for improvement")
                         else:
-                            # Display as simple list for fewer skills
-                            for skill in soft_skills:
-                                st.write(f"✅ {skill}")
+                            st.error("⚠️ Needs significant improvement")
+                    
+                    # Grammar check
+                    st.subheader("📝 Grammar & Language Quality")
+                    with st.spinner("Checking grammar..."):
+                        grammar_issues = analyzer.grammar_check(text)
+                    
+                    if grammar_issues:
+                        st.warning(f"Found {len(grammar_issues)} potential grammar issues:")
+                        for i, issue in enumerate(grammar_issues[:10]):  # Show first 10 issues
+                            if hasattr(issue, 'message'):
+                                st.write(f"• {issue.message}")
+                            else:
+                                st.write(f"• {str(issue)}")
+                        
+                        if len(grammar_issues) > 10:
+                            st.info(f"... and {len(grammar_issues) - 10} more issues")
                     else:
-                        st.warning("No soft skills detected")
-                        st.info("💡 Consider highlighting leadership, communication, and teamwork skills")
-                
-                # Skills comparison section
-                st.subheader("📊 Skills Overview")
-                
-                # Create metrics row
-                col1, col2, col3, col4 = st.columns(4)
-                
-                with col1:
-                    st.metric("Technical Skills", len(tech_skills))
-                
-                with col2:
-                    st.metric("Soft Skills", len(soft_skills))
-                
-                with col3:
-                    total_skills = len(tech_skills) + len(soft_skills)
-                    st.metric("Total Skills", total_skills)
+                        st.success("✅ No major grammar issues detected!")
                 
-                with col4:
-                    # Calculate skills balance
-                    if total_skills > 0:
-                        tech_ratio = len(tech_skills) / total_skills * 100
-                        st.metric("Tech/Soft Ratio", f"{tech_ratio:.0f}%/{100-tech_ratio:.0f}%")
+                with tab5:
+                    st.header("Report & Suggestions")
+                    
+                    # Get AI analysis from Claude
+                    if os.getenv('OPENROUTER_API_KEY'):
+                        st.subheader("🤖 AI-Powered Analysis")
+                        with st.spinner("Getting AI analysis from Claude..."):
+                            claude_analysis = analyzer.get_claude_analysis(
+                                text, sections, selected_role, ats_score, match_percentage
+                            )
+                        st.markdown(claude_analysis)
                     else:
-                        st.metric("Tech/Soft Ratio", "0%/0%")
-                
-                # Skills recommendations
-                st.subheader("💡 Skills Recommendations")
-                
-                recommendations = []
-                
-                # Technical skills recommendations
-                if len(tech_skills) < 5:
-                    recommendations.append("📈 Add more technical skills relevant to your field")
-                
-                # Soft skills recommendations
-                if len(soft_skills) < 3:
-                    recommendations.append("🤝 Highlight more soft skills like leadership and communication")
-                
-                # Balance recommendations
-                if len(tech_skills) > 0 and len(soft_skills) == 0:
-                    recommendations.append("⚖️ Balance technical skills with soft skills")
-                elif len(soft_skills) > 0 and len(tech_skills) == 0:
-                    recommendations.append("⚖️ Add technical skills to complement your soft skills")
-                
-                if recommendations:
+                        st.info("Claude API not available. Showing basic recommendations.")
+                    
+                    # Basic recommendations
+                    st.subheader("📋 Quick Recommendations")
+                    recommendations = []
+                    
+                    if ats_score < 70:
+                        recommendations.append("🔹 Improve ATS compatibility by adding more bullet points and clear section headers")
+                    
+                    if match_percentage < 60:
+                        recommendations.append(f"🔹 Add more {selected_role}-specific keywords to improve role match")
+                    
+                    if len(tech_skills) < 5:
+                        recommendations.append("🔹 Include more technical skills relevant to your field")
+                    
+                    if not sections.get('projects'):
+                        recommendations.append("🔹 Consider adding a projects section to showcase your work")
+                    
+                    if len(text.split()) < 300:
+                        recommendations.append("🔹 Expand your resume content - it seems too brief")
+                    elif len(text.split()) > 800:
+                        recommendations.append("🔹 Consider condensing your resume - it might be too lengthy")
+                    
                     for rec in recommendations:
-                        st.info(rec)
-                else:
-                    st.success("✅ Good balance of technical and soft skills!")
-                
-                # Role-specific keyword analysis
-                st.subheader(f"🎯 {selected_role} Keywords Analysis")
-                
-                col1, col2 = st.columns(2)
-                
-                with col1:
-                    # Match percentage visualization
-                    fig = go.Figure(go.Indicator(
-                        mode = "gauge+number",
-                        value = match_percentage,
-                        domain = {'x': [0, 1], 'y': [0, 1]},
-                        title = {'text': f"{selected_role} Match"},
-                        gauge = {
-                            'axis': {'range': [None, 100]},
-                            'bar': {'color': "darkgreen"},
-                            'steps': [
-                                {'range': [0, 40], 'color': "lightcoral"},
-                                {'range': [40, 70], 'color': "yellow"},
-                                {'range': [70, 100], 'color': "lightgreen"}
-                            ],
-                            'threshold': {
-                                'line': {'color': "red", 'width': 4},
-                                'thickness': 0.75,
-                                'value': 80
-                            }
-                        }
-                    ))
-                    fig.update_layout(height=300)
-                    st.plotly_chart(fig, use_container_width=True)
-                
-                with col2:
-                    st.metric("Keywords Found", len(found_keywords))
-                    st.metric("Match Percentage", f"{match_percentage:.1f}%")
+                        st.markdown(rec)
                     
-                    # Match level indicator
-                    if match_percentage >= 80:
-                        st.success("🎉 Excellent match!")
-                    elif match_percentage >= 60:
-                        st.warning("👍 Good match")
-                    elif match_percentage >= 40:
-                        st.warning("⚠️ Fair match")
-                    else:
-                        st.error("❌ Poor match")
-                
-                # Keywords found section
-                if found_keywords:
-                    st.subheader("✅ Keywords Found")
+                    # PDF Report Generation
+                    st.subheader("📄 Download Report")
+                    if st.button("Generate PDF Report"):
+                        try:
+                            pdf_buffer = analyzer.create_pdf_report(
+                                text, sections, ats_score, match_percentage, 
+                                selected_role, tech_skills, soft_skills, found_keywords
+                            )
+                            
+                            st.download_button(
+                                label="📥 Download PDF Report",
+                                data=pdf_buffer,
+                                file_name=f"resume_analysis_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf",
+                                mime="application/pdf"
+                            )
+                        except Exception as e:
+                            st.error(f"Error generating PDF: {str(e)}")
+                
+                with tab6:
+                    st.header("🤖 AI Assistant Chat")
                     
-                    # Display found keywords in a nice format
-                    keyword_cols = st.columns(3)
-                    for i, keyword in enumerate(found_keywords):
-                        with keyword_cols[i % 3]:
-                            st.success(f"✓ {keyword}")
-                else:
-                    st.warning("❌ No role-specific keywords found")
-                
-                # Missing keywords section
-                all_keywords = analyzer.job_keywords[selected_role]
-                missing_keywords = [kw for kw in all_keywords if kw not in found_keywords]
-                
-                if missing_keywords:
-                    st.subheader("🔍 Suggested Keywords to Add")
-                    st.info(f"Consider adding these {selected_role}-specific keywords to improve your match score:")
+                    if not os.getenv('OPENROUTER_API_KEY'):
+                        st.error("Claude API key not configured. Please set OPENROUTER_API_KEY environment variable.")
+                        return
                     
-                    # Show missing keywords in expandable sections
-                    with st.expander(f"View all {len(missing_keywords)} missing keywords", expanded=len(missing_keywords) <= 10):
-                        missing_cols = st.columns(3)
-                        for i, keyword in enumerate(missing_keywords):
-                            with missing_cols[i % 3]:
-                                st.write(f"📝 {keyword}")
-                
-                # Skills gap analysis
-                st.subheader("📋 Skills Gap Analysis")
-                
-                # Calculate skills coverage for the role
-                role_technical_skills = [skill for skill in analyzer.technical_skills 
-                                       if skill in analyzer.job_keywords[selected_role]]
-                
-                found_role_skills = [skill for skill in tech_skills if skill in role_technical_skills]
-                missing_role_skills = [skill for skill in role_technical_skills if skill not in tech_skills]
-                
-                if role_technical_skills:
-                    coverage_percentage = (len(found_role_skills) / len(role_technical_skills)) * 100
+                    # Display chat history
+                    for chat in st.session_state.chat_history:
+                        with st.chat_message(chat["role"]):
+                            st.markdown(chat["content"])
                     
+                    # Chat input
+                    if prompt := st.chat_input("Ask me anything about your resume..."):
+                        # Add user message to chat history
+                        st.session_state.chat_history.append({"role": "user", "content": prompt})
+                        
+                        # Display user message
+                        with st.chat_message("user"):
+                            st.markdown(prompt)
+                        
+                        # Generate AI response
+                        with st.chat_message("assistant"):
+                            with st.spinner("Thinking..."):
+                                response = analyzer.chatbot.generate_response(
+                                    prompt, 
+                                    st.session_state.resume_context
+                                )
+                            st.markdown(response)
+                        
+                        # Add assistant response to chat history
+                        st.session_state.chat_history.append({"role": "assistant", "content": response})
+                    
+                    # Suggested questions
+                    st.subheader("💡 Suggested Questions")
                     col1, col2 = st.columns(2)
                     
                     with col1:
-                        st.metric("Role Skills Coverage", f"{coverage_percentage:.1f}%")
-                        
-                        if coverage_percentage >= 80:
-                            st.success("🎯 Excellent coverage of role-specific skills!")
-                        elif coverage_percentage >= 60:
-                            st.warning("👍 Good coverage, consider adding a few more")
-                        else:
-                            st.error("⚠️ Low coverage, focus on adding role-specific skills")
+                        if st.button("How can I improve my resume?"):
+                            st.session_state.chat_history.append({
+                                "role": "user", 
+                                "content": "How can I improve my resume?"
+                            })
+                            st.experimental_rerun()
                     
                     with col2:
-                        if missing_role_skills:
-                            st.write("**Priority skills to add:**")
-                            for skill in missing_role_skills[:5]:
-                                st.write(f"🎯 {skill}")
-                        else:
-                            st.success("✅ All key role skills covered!")
-                
-                # Skills trend analysis (if we had historical data)
-                st.subheader("📈 Skills Insights")
-                
-                insights = []
-                
-                # Programming languages analysis
-                programming_langs = ['python', 'java', 'javascript', 'c++', 'c#', 'php', 'ruby', 'go']
-                found_langs = [lang for lang in programming_langs if lang in [s.lower() for s in tech_skills]]
-                
-                if len(found_langs) >= 3:
-                    insights.append(f"💻 Strong programming portfolio with {len(found_langs)} languages")
-                elif len(found_langs) >= 1:
-                    insights.append(f"💻 Programming experience in {', '.join(found_langs)}")
-                
-                # Cloud skills analysis
-                cloud_skills = ['aws', 'azure', 'gcp', 'docker', 'kubernetes']
-                found_cloud = [skill for skill in cloud_skills if skill in [s.lower() for s in tech_skills]]
-                
-                if found_cloud:
-                    insights.append(f"☁️ Cloud-ready with {', '.join(found_cloud)} experience")
-                
-                # Data skills analysis
-                data_skills = ['sql', 'python', 'tableau', 'power bi', 'excel', 'pandas', 'numpy']
-                found_data = [skill for skill in data_skills if skill in [s.lower() for s in tech_skills]]
-                
-                if len(found_data) >= 3:
-                    insights.append(f"📊 Strong data analysis capabilities")
-                
-                if insights:
-                    for insight in insights:
-                        st.info(insight)
-                else:
-                    st.info("💡 Add more technical skills to unlock insights about your profile")
+                        if st.button("What skills should I add?"):
+                            st.session_state.chat_history.append({
+                                "role": "user", 
+                                "content": f"What skills should I add for a {selected_role} position?"
+                            })
+                            st.experimental_rerun()
+                    
+                    # Clear chat button
+                    if st.button("🗑️ Clear Chat History"):
+                        st.session_state.chat_history = []
+                        st.experimental_rerun()
+            
+            except Exception as e:
+                st.error(f"Error during analysis: {str(e)}")
+        else:
+            st.error("Could not extract text from the uploaded file. Please try a different file.")
+    
+    # Footer
+    st.markdown("---")
+    st.markdown("### 📝 Tips for Better Resume Analysis")
+    st.markdown("""
+    - **Upload clear, well-formatted documents** for better text extraction
+    - **Select the appropriate job role** to get relevant keyword matching
+    - **Use the AI Assistant** to get personalized advice
+    - **Download the PDF report** for offline reference
+    - **Check multiple job roles** to see how your resume performs across different positions
+    """)
+    
+    # Instructions for API setup
+    if not os.getenv('OPENROUTER_API_KEY'):
+        with st.expander("🔧 Setup Instructions for Claude AI"):
+            st.markdown("""
+            To enable the AI Assistant feature:
+            1. Get an API key from [OpenRouter](https://openrouter.ai/)
+            2. Set the environment variable: `OPENROUTER_API_KEY=your_key_here`
+            3. Restart the application
+            """)
 
 if __name__ == "__main__":
-    main()
+    main()
+