Update app.py

app.py

@@ -1,210 +1,462 @@
 import streamlit as st
-import os
-import requests
-import re
-import fitz  # PyMuPDF
-from docx import Document
-import json
-
-# --- Configuration ---
+import io
+from reportlab.lib.pagesizes import letter
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, HRFlowable
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.enums import TA_CENTER, TA_LEFT, TA_RIGHT
+from reportlab.lib import colors
+from reportlab.lib.units import inch
+import time
+import pandas as pd
+
+# --- Configuration & Theming ---
 st.set_page_config(
-    page_title="LinkedIn Job Finder",
-    page_icon="🤖",
+    page_title="AI Resume Tailor",
+    page_icon="📄",
     layout="wide",
     initial_sidebar_state="expanded",
 )
 
-# --- Hugging Face Secrets & API Keys ---
-# Load API key from Streamlit secrets (for deployed apps on Hugging Face)
-try:
-    SCRAPINGDOG_API_KEY = st.secrets["SCRAPINGDOG_API_KEY"]
-except (KeyError, AttributeError):
-    # Fallback for local development (optional)
-    SCRAPINGDOG_API_KEY = os.getenv("SCRAPINGDOG_API_KEY")
-
-# --- Core Functions ---
-
-def parse_cv(uploaded_file):
-    """Parses text from uploaded PDF, DOCX, or TXT files."""
-    try:
-        file_type = uploaded_file.type
-        if "pdf" in file_type:
-            with fitz.open(stream=uploaded_file.read(), filetype="pdf") as doc:
-                return "".join(page.get_text() for page in doc)
-        elif "vnd.openxmlformats-officedocument.wordprocessingml.document" in file_type:
-            doc = Document(uploaded_file)
-            return "\n".join([para.text for para in doc.paragraphs])
-        elif "text/plain" in file_type:
-            return uploaded_file.getvalue().decode("utf-8")
-        else:
-            st.error(f"Unsupported file type: {file_type}")
-            return None
-    except Exception as e:
-        st.error(f"Error parsing CV: {e}")
-        return None
-
-def extract_technical_skills(text):
-    """Extracts technical skills from text using a predefined list and regex."""
-    if not text:
-        return []
-
-    # Comprehensive list of technical skills (can be expanded)
-    skills_list = [
-        'Python', 'Java', 'C++', 'C#', 'JavaScript', 'TypeScript', 'Go', 'Rust', 'Ruby', 'PHP', 'Swift', 'Kotlin',
-        'SQL', 'NoSQL', 'PostgreSQL', 'MySQL', 'MongoDB', 'Redis', 'Cassandra', 'GraphQL',
-        'React', 'Angular', 'Vue.js', 'Node.js', 'Django', 'Flask', 'Spring Boot', 'Ruby on Rails',
-        'TensorFlow', 'PyTorch', 'scikit-learn', 'Keras', 'Pandas', 'NumPy', 'Matplotlib',
-        'AWS', 'Azure', 'Google Cloud', 'GCP', 'Docker', 'Kubernetes', 'Terraform', 'Ansible',
-        'CI/CD', 'Jenkins', 'Git', 'GitHub', 'GitLab', 'Linux', 'Bash', 'PowerShell',
-        'Agile', 'Scrum', 'JIRA', 'Data Science', 'Machine Learning', 'Deep Learning', 'NLP',
-        'Big Data', 'Hadoop', 'Spark', 'Cybersecurity', 'API', 'REST', 'Microservices'
-    ]
+# Custom CSS for modern styling and theme support
+st.markdown("""
+<style>
+    /* General App Styling */
+    .stApp {
+        background-color: var(--background-color);
+        color: var(--text-color);
+    }
+    .st-emotion-cache-16txtl3 {
+        padding: 2rem 2rem;
+    }
+
+    /* Custom button styling */
+    .stDownloadButton > button, .stButton > button {
+        border-radius: 12px;
+        padding: 10px 20px;
+        font-weight: bold;
+        transition: all 0.2s ease-in-out;
+        border: 2px solid #2ECC71; /* Accent color border */
+        background-color: transparent;
+        color: #2ECC71;
+    }
+    .stDownloadButton > button:hover, .stButton > button:hover {
+        background-color: #2ECC71;
+        color: white;
+        transform: translateY(-2px);
+        box-shadow: 0 4px 8px rgba(0,0,0,0.1);
+    }
+
+    /* Sidebar styling */
+    .st-emotion-cache-1jicfl2 {
+        background-color: var(--secondary-background-color);
+    }
     
-    found_skills = set()
-    text_lower = text.lower()
+    /* Expander styling */
+    .st-emotion-cache-p5msec {
+        border-radius: 10px;
+        border: 1px solid var(--separator-color);
+    }
+
+    /* Match Score Badge */
+    .match-score {
+        background-color: #2ECC71;
+        color: white;
+        padding: 5px 12px;
+        border-radius: 15px;
+        font-size: 0.9em;
+        font-weight: bold;
+    }
+
+    /* Tabs styling */
+    .st-emotion-cache-1vbkxwb button {
+        border-radius: 8px 8px 0 0;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# --- PDF Generation (ReportLab) ---
+
+def build_pdf(user_data, resume_text, cover_letter_text=None) -> io.BytesIO:
+    """
+    Generates a modern, professional PDF resume using ReportLab.
+    """
+    buffer = io.BytesIO()
+    doc = SimpleDocTemplate(buffer, pagesize=letter,
+                            rightMargin=0.75*inch, leftMargin=0.75*inch,
+                            topMargin=0.75*inch, bottomMargin=0.75*inch)
+    
+    story = []
+    styles = getSampleStyleSheet()
+
+    # --- Custom Styles ---
+    accent_color = colors.HexColor("#2C3E50") # Dark Slate Blue
+    secondary_accent_color = colors.HexColor("#2ECC71") # Green accent for score
+
+    styles.add(ParagraphStyle(name='NameStyle',
+                              fontName='Helvetica-Bold',
+                              fontSize=28,
+                              leading=34,
+                              alignment=TA_CENTER,
+                              textColor=accent_color))
+    
+    styles.add(ParagraphStyle(name='ContactStyle',
+                              fontName='Helvetica',
+                              fontSize=10,
+                              alignment=TA_CENTER,
+                              leading=14))
+
+    styles.add(ParagraphStyle(name='HeadingStyle',
+                              fontName='Helvetica-Bold',
+                              fontSize=14,
+                              leading=18,
+                              textColor=accent_color,
+                              spaceAfter=6))
+    
+    styles.add(ParagraphStyle(name='BodyStyle',
+                              fontName='Helvetica',
+                              fontSize=10,
+                              alignment=TA_LEFT,
+                              leading=14))
+                              
+    styles.add(ParagraphStyle(name='JobTitleStyle',
+                              fontName='Helvetica-Bold',
+                              fontSize=11))
+
+    # --- 1. Header Section ---
+    name = Paragraph(user_data.get('name', 'Your Name'), styles['NameStyle'])
+    contact_info = user_data.get('email', '') + " | " + user_data.get('phone', '')
+    contact = Paragraph(contact_info, styles['ContactStyle'])
+    story.append(name)
+    story.append(contact)
+    story.append(Spacer(1, 0.25*inch))
+    story.append(HRFlowable(width="100%", thickness=1, color=colors.lightgrey))
+    story.append(Spacer(1, 0.2*inch))
     
-    # Use regex to find whole words to avoid matching substrings
-    for skill in skills_list:
-        pattern = r'\b' + re.escape(skill.lower()) + r'\b'
-        if re.search(pattern, text_lower):
-            found_skills.add(skill)
-            
-    return sorted(list(found_skills))
-
-def safe_get(data, key, default='N/A'):
-    """Safely gets a value from a dictionary."""
-    return data.get(key, default) if data else default
-
-class JobDataNormalizer:
-    """Normalizes LinkedIn job data into a common schema."""
-    @staticmethod
-    def normalize_linkedin(job):
-        return {
-            "id": hash(safe_get(job, 'link')), # Create a simple unique ID
-            "title": safe_get(job, 'title'),
-            "company": safe_get(job, 'company'),
-            "location": safe_get(job, 'location'),
-            "description": safe_get(job, 'description'),
-            "date_posted": safe_get(job, 'date'),
-            "job_url": safe_get(job, 'link'),
-            "source": "LinkedIn"
-        }
-
-def search_linkedin_jobs(keywords, location):
-    """Searches for jobs on LinkedIn via the ScrapingDog API."""
-    if not SCRAPINGDOG_API_KEY:
-        st.error("Please set SCRAPINGDOG_API_KEY in Hugging Face secrets.")
-        return []
-
-    query = " ".join(keywords)
-    api_url = f"https://api.scrapingdog.com/linkedinjobs/?api_key={SCRAPINGDOG_API_KEY}&q={query}&geoid={location}"
+    # --- 2. Resume Content ---
+    # The AI-generated text is assumed to have sections marked with headers.
+    # We will parse this text and format it.
     
-    try:
-        response = requests.get(api_url)
-        response.raise_for_status()
-        jobs_data = response.json()
-        if isinstance(jobs_data, list):
-            return [JobDataNormalizer.normalize_linkedin(job) for job in jobs_data]
-    except requests.exceptions.HTTPError as e:
-        st.error(f"API Error: {e}. Check your ScrapingDog API key and usage limits.")
-    except requests.exceptions.RequestException as e:
-        st.error(f"Network error: {e}")
-    except json.JSONDecodeError:
-        st.error("Failed to parse API response. The service might be temporarily down.")
-    return []
-
-# --- UI Rendering ---
-
-def display_job(job):
-    """Renders a single job listing in a card format."""
-    st.markdown(f"""
-    <div style="border: 1px solid #e1e4e8; border-radius: 8px; padding: 16px; margin-bottom: 16px; box-shadow: 0 2px 4px rgba(0,0,0,0.05);">
-        <h3 style="margin-bottom: 8px;"><a href="{job['job_url']}" target="_blank" style="text-decoration: none; color: #0077b5;">{job['title']}</a></h3>
-        <p style="margin: 0;"><strong>🏢 Company:</strong> {job['company']}</p>
-        <p style="margin: 0;"><strong>📍 Location:</strong> {job['location']}</p>
-        <p style="margin: 0; color: #586069;"><strong>🗓️ Posted:</strong> {job['date_posted']}</p>
-        <div style="margin-top: 12px;">
-            <span style="background-color: #0077b5; color: white; padding: 4px 8px; border-radius: 12px; font-size: 12px; font-weight: bold;">{job['source']}</span>
-        </div>
-    </div>
-    """, unsafe_allow_html=True)
-    with st.expander("Show Job Description Snippet"):
-        clean_description = re.sub('<[^<]+?>', '', job['description'])
-        st.write(clean_description[:500] + "...")
-
-# --- Main Application ---
+    # Simple parser: splits text into sections by looking for "Header:" lines.
+    sections = {}
+    current_section = "Summary" # Default section
+    sections[current_section] = []
+
+    for line in resume_text.split('\n'):
+        line = line.strip()
+        if line.endswith(':') and len(line.split()) < 4: # Likely a header
+            current_section = line[:-1].strip()
+            sections[current_section] = []
+        elif line:
+            sections[current_section].append(line)
+
+    # Order of sections in the resume
+    section_order = ["Summary", "Experience", "Skills", "Education", "Projects"]
+
+    for section_title in section_order:
+        if section_title in sections and sections[section_title]:
+            story.append(Paragraph(section_title.upper(), styles['HeadingStyle']))
+            content = sections[section_title]
+
+            if section_title == "Skills":
+                # Format skills into a two-column grid
+                skills_list = [s.strip() for s in " ".join(content).split(',') if s.strip()]
+                num_skills = len(skills_list)
+                if num_skills > 0:
+                    num_cols = 2
+                    data = []
+                    row = []
+                    for i, skill in enumerate(skills_list):
+                        row.append(f"• {skill}")
+                        if len(row) == num_cols or i == num_skills - 1:
+                            data.append(row)
+                            row = []
+                    
+                    # Ensure all rows have num_cols items
+                    for r in data:
+                        while len(r) < num_cols:
+                            r.append('')
+
+                    table = Table(data, colWidths=[2.7*inch] * num_cols)
+                    table.setStyle(TableStyle([
+                        ('VALIGN', (0,0), (-1,-1), 'TOP'),
+                        ('LEFTPADDING', (0,0), (-1,-1), 0),
+                        ('RIGHTPADDING', (0,0), (-1,-1), 0),
+                        ('BOTTOMPADDING', (0,0), (-1,-1), 3),
+                        ('TOPPADDING', (0,0), (-1,-1), 0),
+                    ]))
+                    story.append(table)
+
+            elif section_title == "Experience":
+                 # Format experience with left/right alignment using a Table
+                # Assuming format: "Job Title at Company Name | Location | MM/YYYY - MM/YYYY"
+                # And bullet points follow
+                current_entry = []
+                for line in content:
+                    if '|' in line and ('/' in line or 'Present' in line):
+                        if current_entry:
+                            story.extend(current_entry)
+                        current_entry = []
+                        parts = [p.strip() for p in line.split('|')]
+                        
+                        job_company = Paragraph(parts[0], styles['JobTitleStyle'])
+                        dates = Paragraph(parts[-1], styles['BodyStyle'])
+                        
+                        header_table = Table([[job_company, dates]], colWidths=['75%', '25%'])
+                        header_table.setStyle(TableStyle([
+                             ('ALIGN', (1,0), (1,0), 'RIGHT'),
+                             ('VALIGN', (0,0), (-1,-1), 'TOP'),
+                             ('LEFTPADDING', (0,0), (-1,-1), 0),
+                        ]))
+                        current_entry.append(header_table)
+                    elif line.startswith(('•', '*', '-')):
+                        p = Paragraph(line, styles['BodyStyle'], bulletText='•')
+                        p.leftIndent = 18
+                        current_entry.append(p)
+                if current_entry:
+                    story.extend(current_entry)
+
+
+            else: # For Summary, Education, Projects etc.
+                for line in content:
+                    story.append(Paragraph(line, styles['BodyStyle']))
+
+            story.append(Spacer(1, 0.2*inch))
+
+
+    # --- 3. Optional Cover Letter ---
+    if cover_letter_text:
+        story.append(Spacer(1, 0.3*inch))
+        story.append(HRFlowable(width="100%", thickness=2, color=accent_color))
+        story.append(Spacer(1, 0.3*inch))
+        story.append(Paragraph("COVER LETTER", styles['NameStyle']))
+        story.append(Spacer(1, 0.2*inch))
+        
+        for para in cover_letter_text.split('\n\n'):
+            story.append(Paragraph(para, styles['BodyStyle']))
+            story.append(Spacer(1, 12))
+
+
+    doc.build(story)
+    buffer.seek(0)
+    return buffer
+
+# --- MOCK/PLACEHOLDER FUNCTIONS ---
+
+def parse_resume(file):
+    # Placeholder: In a real app, use libraries like python-docx, pypdf
+    time.sleep(1) # Simulate processing
+    return "This is the parsed text content of the uploaded resume. It includes sections for skills, experience, and education."
+
+def get_job_postings():
+    # Placeholder: In a real app, this would fetch from a database or API
+    data = {
+        'id': [1, 2, 3, 4, 5],
+        'title': ['Senior Python Developer', 'Data Scientist', 'Frontend Engineer (React)', 'UX/UI Designer', 'Product Manager'],
+        'company': ['TechCorp', 'Data Inc.', 'Innovate LLC', 'Creative Designs', 'Productify'],
+        'location': ['Remote', 'New York, NY', 'San Francisco, CA', 'Remote', 'Austin, TX'],
+        'job_type': ['Full-time', 'Full-time', 'Contract', 'Full-time', 'Full-time'],
+        'salary_min': [120000, 110000, 130000, 90000, 140000],
+        'salary_max': [160000, 145000, 170000, 120000, 180000],
+        'description': [
+            "Seeking a Senior Python Developer with expertise in Django and AWS...",
+            "Join our data science team to build machine learning models for customer analytics...",
+            "We need a React developer to build beautiful and responsive user interfaces...",
+            "Design intuitive and engaging user experiences for our web and mobile applications...",
+            "Lead the development and launch of new products from conception to launch..."
+        ]
+    }
+    return pd.DataFrame(data)
+
+def match_jobs_with_resume(resume_text, jobs_df):
+    # Placeholder: In a real app, use embeddings (e.g., SentenceTransformers) + FAISS
+    time.sleep(2) # Simulate matching
+    jobs_df['match_score'] = [95, 88, 76, 65, 82]
+    return jobs_df.sort_values(by='match_score', ascending=False)
+
+def generate_ai_content(resume_text, job_description, content_type="resume"):
+    # Placeholder: In a real app, this would call a generative AI model (e.g., Gemini API)
+    time.sleep(3) # Simulate AI generation
+    if content_type == "resume":
+        return """
+Summary:
+A highly skilled and motivated professional with over 5 years of experience in software development, specializing in Python and cloud technologies. Proven ability to lead projects and deliver high-quality solutions. Tailored this summary to highlight alignment with the Senior Python Developer role at TechCorp.
+
+Experience:
+Senior Software Engineer at PreviousCompany | San Francisco, CA | 01/2020 - Present
+• Led the development of a key microservice using Python and Django, resulting in a 20% performance improvement.
+• Mentored junior developers and conducted code reviews to ensure code quality and standards.
+• Deployed applications to AWS using Docker and Kubernetes.
+
+Software Engineer at AnotherCompany | Boston, MA | 06/2017 - 12/2019
+• Developed and maintained REST APIs for the main product.
+• Worked in an Agile team to deliver features on a bi-weekly sprint schedule.
+
+Skills:
+Python, Django, Flask, FastAPI, JavaScript, React, AWS, GCP, Docker, Kubernetes, Terraform, SQL, PostgreSQL, MongoDB, Git
+
+Education:
+Master of Science in Computer Science | University of Technology | 2017
+Bachelor of Science in Software Engineering | State University | 2015
+"""
+    else: # Cover Letter
+        return """
+Dear Hiring Manager,
+
+I am writing to express my enthusiastic interest in the Senior Python Developer position at TechCorp, which I found advertised on [Platform]. With my extensive experience in Python development, particularly with Django and AWS, and a proven track record of delivering scalable and efficient solutions, I am confident that I possess the skills and qualifications necessary to excel in this role and contribute significantly to your team.
+
+In my previous role at PreviousCompany, I led the development of a critical microservice that enhanced system performance by 20%. This project required deep expertise in Python, architectural design, and cloud deployment, all of which are key requirements for the position at TechCorp. I am particularly drawn to your company's innovative work in [mention a specific company project or value], and I am eager to bring my passion for building high-quality software to your organization.
+
+Thank you for considering my application. I have attached my resume for your review and welcome the opportunity to discuss how my background, skills, and enthusiasm can be a valuable asset to TechCorp.
+
+Sincerely,
+[Your Name]
+"""
+
+
+# --- STREAMLIT UI ---
 
 # Initialize session state
-if 'skills' not in st.session_state:
-    st.session_state.skills = []
-if 'jobs' not in st.session_state:
-    st.session_state.jobs = []
-if 'searched' not in st.session_state:
-    st.session_state.searched = False
+if 'resume_text' not in st.session_state:
+    st.session_state.resume_text = ""
+if 'matched_jobs' not in st.session_state:
+    st.session_state.matched_jobs = None
+if 'tailored_resume' not in st.session_state:
+    st.session_state.tailored_resume = ""
+if 'cover_letter' not in st.session_state:
+    st.session_state.cover_letter = ""
 
 # --- Sidebar ---
 with st.sidebar:
-    st.image("https://images.emojiterra.com/twitter/v14.0/512px/1f916.png", width=80)
-    st.title("LinkedIn Job Finder")
-    st.markdown("""
-    Find your next role on LinkedIn by leveraging the power of AI.
+    st.markdown("## 📄 AI Resume Tailor")
+    st.markdown("---")
     
-    **How to use:**
-    1.  **Upload your CV** to automatically identify your technical skills.
-    2.  **Refine the skills list** by adding or removing keywords.
-    3.  **Enter a location** and hit search!
+    st.markdown("### 1. Your Information")
+    user_name = st.text_input("Full Name", placeholder="e.g., Jane Doe")
+    user_email = st.text_input("Email", placeholder="e.g., jane.doe@email.com")
+    user_phone = st.text_input("Phone Number", placeholder="e.g., (123) 456-7890")
     
-    **API Key Required:**
-    This app uses the ScrapingDog API. You'll need to get a free API key and set it up in your Hugging Face Space secrets as `SCRAPINGDOG_API_KEY`.
-    """)
-
-# --- Main Content Panel ---
-st.header("1. Upload Your CV")
-uploaded_file = st.file_uploader(
-    "Upload to extract technical skills (PDF, DOCX, TXT). Personal details are ignored.",
-    type=["pdf", "docx", "txt"]
-)
+    user_data = {"name": user_name, "email": user_email, "phone": user_phone}
+    
+    st.markdown("### 2. Upload Your Resume")
+    uploaded_file = st.file_uploader("Upload your resume (PDF, DOCX)", type=['pdf', 'docx'])
+    
+    if uploaded_file:
+        with st.spinner('Analyzing your resume...'):
+            st.session_state.resume_text = parse_resume(uploaded_file)
+            all_jobs = get_job_postings()
+            st.session_state.matched_jobs = match_jobs_with_resume(st.session_state.resume_text, all_jobs)
+        st.success("Resume analyzed successfully!")
 
-if uploaded_file:
-    with st.spinner("Analyzing CV for technical skills... 🧠"):
-        cv_text = parse_cv(uploaded_file)
-        if cv_text:
-            st.session_state.skills = extract_technical_skills(cv_text)
-            st.success("Successfully extracted skills from your CV!")
-
-st.header("2. Refine Skills and Search")
-manual_keywords = st.text_input(
-    "Add more skills or keywords (comma-separated)",
-    placeholder="e.g., Go, Cybersecurity, REST"
-)
+# --- Main Page ---
+st.title("Find and Apply for Your Next Job")
+st.markdown("Upload your resume on the left to get started. We'll match you with relevant job postings and help you tailor your application materials instantly.")
 
-added_skills = [k.strip() for k in manual_keywords.split(',') if k.strip()]
-combined_skills = sorted(list(set(st.session_state.skills + added_skills)))
+if st.session_state.matched_jobs is not None:
+    st.markdown("---")
+    st.header("✨ Top Job Matches")
 
-selected_skills = st.multiselect(
-    "Select the skills to search for:",
-    options=combined_skills,
-    default=st.session_state.skills
-)
+    # --- Filtering UI ---
+    jobs_df = st.session_state.matched_jobs
+    
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        locations = ['All'] + sorted(jobs_df['location'].unique().tolist())
+        location_filter = st.selectbox("Location", options=locations)
+    with col2:
+        job_types = ['All'] + sorted(jobs_df['job_type'].unique().tolist())
+        type_filter = st.selectbox("Job Type", options=job_types)
+    with col3:
+        min_sal, max_sal = int(jobs_df['salary_min'].min()), int(jobs_df['salary_max'].max())
+        salary_filter = st.slider("Salary Range ($)", min_sal, max_sal, (min_sal, max_sal), 1000)
 
-location = st.text_input("Enter Location", "Remote")
+    keyword_filter = st.text_input("Search by keyword in title or description", "")
+    
+    # Apply filters
+    filtered_jobs = jobs_df.copy()
+    if location_filter != 'All':
+        filtered_jobs = filtered_jobs[filtered_jobs['location'] == location_filter]
+    if type_filter != 'All':
+        filtered_jobs = filtered_jobs[filtered_jobs['job_type'] == type_filter]
+    filtered_jobs = filtered_jobs[
+        (filtered_jobs['salary_min'] >= salary_filter[0]) &
+        (filtered_jobs['salary_max'] <= salary_filter[1])
+    ]
+    if keyword_filter:
+        filtered_jobs = filtered_jobs[
+            filtered_jobs['title'].str.contains(keyword_filter, case=False) |
+            filtered_jobs['description'].str.contains(keyword_filter, case=False)
+        ]
 
-if st.button("🚀 Search Jobs on LinkedIn", type="primary", use_container_width=True):
-    if not selected_skills:
-        st.warning("Please select at least one skill to search.")
+    if filtered_jobs.empty:
+        st.warning("No jobs match your current filter criteria.")
     else:
-        st.session_state.jobs = []
-        st.session_state.searched = True
-        with st.spinner("Searching LinkedIn... This may take a moment."):
-            jobs = search_linkedin_jobs(selected_skills, location)
-            st.session_state.jobs = sorted(jobs, key=lambda x: x.get('date_posted', ''), reverse=True)
-
-# --- Display Results ---
-if st.session_state.searched:
-    st.header(f"💼 Job Results ({len(st.session_state.jobs)} Found)")
-    if st.session_state.jobs:
-        for job in st.session_state.jobs:
-            display_job(job)
-    else:
-        st.info("No jobs found for the selected keywords. Try refining your search.")
+        # --- Display Matched Jobs ---
+        for index, job in filtered_jobs.iterrows():
+            with st.expander(f"**{job['title']}** at {job['company']}"):
+                col1, col2 = st.columns([4, 1])
+                with col1:
+                    st.markdown(f"**Location:** {job['location']} | **Type:** {job['job_type']}")
+                    st.markdown(f"**Salary:** ${job['salary_min']:,} - ${job['salary_max']:,}")
+                    st.write(job['description'])
+                with col2:
+                    st.markdown(f"<div style='text-align: right;'><span class='match-score'>🔥 {job['match_score']}% Match</span></div>", unsafe_allow_html=True)
+
+                # Action buttons
+                action_col1, action_col2, _ = st.columns([1, 1, 3])
+                if action_col1.button("Tailor Resume", key=f"resume_{job['id']}"):
+                    with st.spinner(f"Generating tailored resume for {job['title']}..."):
+                        st.session_state.tailored_resume = generate_ai_content(
+                            st.session_state.resume_text, job['description'], "resume"
+                        )
+                    st.success("Resume tailored!")
+                
+                if action_col2.button("Generate Cover Letter", key=f"cover_{job['id']}"):
+                    with st.spinner(f"Generating cover letter for {job['title']}..."):
+                        st.session_state.cover_letter = generate_ai_content(
+                            st.session_state.resume_text, job['description'], "cover_letter"
+                        )
+                    st.success("Cover letter generated!")
+
+
+    # --- Output Section ---
+    if st.session_state.tailored_resume or st.session_state.cover_letter:
+        st.markdown("---")
+        st.header("📝 Your Generated Documents")
+        st.info("You can edit the text below before exporting to PDF.")
+
+        tab1, tab2 = st.tabs(["Tailored Resume", "Cover Letter"])
+
+        with tab1:
+            if st.session_state.tailored_resume:
+                st.session_state.tailored_resume = st.text_area(
+                    "Resume Content", value=st.session_state.tailored_resume, height=400
+                )
+                
+                pdf_resume = build_pdf(user_data, st.session_state.tailored_resume)
+                st.download_button(
+                    label="📥 Download Resume PDF",
+                    data=pdf_resume,
+                    file_name=f"{user_name.replace(' ', '_')}_Resume.pdf",
+                    mime="application/pdf"
+                )
+            else:
+                st.write("Generate a tailored resume from a job match above.")
+
+        with tab2:
+            if st.session_state.cover_letter:
+                st.session_state.cover_letter = st.text_area(
+                    "Cover Letter Content", value=st.session_state.cover_letter, height=400
+                )
+                
+                pdf_cl = build_pdf(user_data, "", st.session_state.cover_letter)
+                st.download_button(
+                    label="📥 Download Cover Letter PDF",
+                    data=pdf_cl,
+                    file_name=f"{user_name.replace(' ', '_')}_Cover_Letter.pdf",
+                    mime="application/pdf"
+                )
+            else:
+                st.write("Generate a cover letter from a job match above.")
 
+else:
+    st.info("Upload your resume in the sidebar to find job matches.")