Update app.py

app.py

@@ -1,462 +1,528 @@
 import streamlit as st
-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
+import requests
+import pdfplumber
+import docx
+from sentence_transformers import SentenceTransformer
+import faiss
+from groq import Groq
+from reportlab.lib.pagesizes import A4
 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="AI Resume Tailor",
-    page_icon="📄",
-    layout="wide",
-    initial_sidebar_state="expanded",
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.platypus import (
+    SimpleDocTemplate,
+    Paragraph,
+    Spacer,
+    ListFlowable,
+    ListItem,
+    Table,
+    TableStyle,
+    Image as RLImage,
 )
+from reportlab.lib.units import mm
+from reportlab.pdfbase import pdfmetrics
+from reportlab.pdfbase.ttfonts import TTFont
+import io
+from PIL import Image
+import tempfile
+import os
+from typing import List
+
+# -----------------------------
+# CONFIG
+# -----------------------------
+REMOTEOK_URL = "https://remoteok.com/api"
+EMBED_MODEL = "BAAI/bge-small-en-v1.5"
+AI_MODEL = "openai/gpt-oss-120b"   # Groq model
+
+# Register font fallback (optional - requires the .ttf to exist if you want specific fonts)
+# If you have fonts, register them; otherwise default fonts will be used.
+# Example: pdfmetrics.registerFont(TTFont('HelveticaNeue', '/path/to/HelveticaNeue.ttf'))
+
+# -----------------------------
+# CACHED MODELS
+# -----------------------------
+@st.cache_resource
+def load_embedding_model():
+    return SentenceTransformer(EMBED_MODEL)
+
+model = load_embedding_model()
+
+@st.cache_resource
+def init_groq():
+    return Groq(api_key=st.secrets.get("GROQ_API_KEY", None))
+
+groq_client = init_groq()
+
+# -----------------------------
+# UTIL / PARSING FUNCTIONS
+# -----------------------------
+def extract_text_from_resume(file) -> str:
+    """Extract text from PDF or DOCX file"""
+    name = getattr(file, "name", "")
+    if name.lower().endswith(".pdf"):
+        text = ""
+        with pdfplumber.open(file) as pdf:
+            for page in pdf.pages:
+                text += page.extract_text() or ""
+        return text
+
+    elif name.lower().endswith(".docx"):
+        doc = docx.Document(file)
+        text = "\n".join([p.text for p in doc.paragraphs])
+        return text
 
-# 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);
-    }
-    
-    /* 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:
+    else:
+        st.error("Unsupported file type. Please upload PDF or DOCX.")
+        return ""
+
+def fetch_jobs() -> List[dict]:
+    try:
+        resp = requests.get(REMOTEOK_URL, timeout=10)
+        if resp.status_code == 200:
+            jobs = resp.json()[1:]  # skip metadata
+            return jobs
+    except Exception as e:
+        st.warning(f"Failed to fetch jobs: {e}")
+    return []
+
+def embed_texts(texts):
+    # returns numpy array
+    return model.encode(texts, convert_to_numpy=True, normalize_embeddings=True)
+
+def match_jobs(resume_text, jobs, top_k=5):
+    if not jobs:
+        return []
+
+    job_texts = [f"{job.get('position','')} {job.get('company','')} {job.get('description','')}" for job in jobs]
+    resume_vec = embed_texts([resume_text])
+    job_vecs = embed_texts(job_texts)
+
+    dim = job_vecs.shape[1]
+    index = faiss.IndexFlatIP(dim)
+    index.add(job_vecs)
+
+    scores, idx = index.search(resume_vec, top_k)
+    results = []
+    for i, score in zip(idx[0], scores[0]):
+        results.append((jobs[i], float(score)))
+    return results
+
+# -----------------------------
+# AI GENERATION
+# -----------------------------
+def generate_resume(resume_text, job):
+    prompt = f"""
+You are an AI career assistant.
+Given this resume:\n{resume_text}\n
+and this job description:\n{job.get('description','')}\n
+Generate a structured resume in this format:
+
+Summary
+-----------------
+[2-3 line summary tailored for the job]
+
+Skills
+-----------------
+- Skill 1
+- Skill 2
+- Skill 3
+
+Experience
+-----------------
+Job Title | Company | Dates
+• Achievement 1
+• Achievement 2
+
+Education
+-----------------
+Degree | Institution | Year
+"""
+    chat_completion = groq_client.chat.completions.create(
+        model=AI_MODEL,
+        messages=[{"role": "user", "content": prompt}],
+        temperature=0.7,
+    )
+    return chat_completion.choices[0].message.content
+
+def generate_cover_letter(resume_text, job, name, email, phone):
+    prompt = f"""
+You are an AI career assistant.
+Given this resume:\n{resume_text}\n
+and this job description:\n{job.get('description','')}\n
+Generate a professional, one-page cover letter tailored to this role.
+Format it like this:
+
+Dear Hiring Manager,
+
+[Intro paragraph: Show enthusiasm and alignment with company/role]
+[Body paragraph: Highlight 2-3 most relevant skills/experiences from resume]
+[Closing paragraph: Express eagerness and thank them]
+
+Sincerely,
+{name}
+{email} | {phone}
+"""
+    chat_completion = groq_client.chat.completions.create(
+        model=AI_MODEL,
+        messages=[{"role": "user", "content": prompt}],
+        temperature=0.7,
+    )
+    return chat_completion.choices[0].message.content
+
+# -----------------------------
+# PDF BUILDING - Improved professional template
+# -----------------------------
+def build_pdf(content: str,
+              title: str = "Resume",
+              name: str = "John Doe",
+              email: str = "john.doe@email.com",
+              phone: str = "+1 234 567 890",
+              profile_image_bytes: bytes = None) -> io.BytesIO:
     """
-    Generates a modern, professional PDF resume using ReportLab.
+    Build a polished PDF resume.
+    content: assumed to be a structured text (the output from the AI generation).
     """
     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 = []
+    doc = SimpleDocTemplate(
+        buffer,
+        pagesize=A4,
+        leftMargin=30,
+        rightMargin=30,
+        topMargin=30,
+        bottomMargin=30,
+    )
     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))
-    
-    # --- 2. Resume Content ---
-    # The AI-generated text is assumed to have sections marked with headers.
-    # We will parse this text and format it.
-    
-    # Simple parser: splits text into sections by looking for "Header:" lines.
+    # Custom styles
+    header_style = ParagraphStyle(
+        "Header",
+        parent=styles["Heading1"],
+        fontSize=20,
+        spaceAfter=6,
+        textColor=colors.HexColor("#2C3E50"),
+        alignment=1,
+        leading=22,
+    )
+    contact_style = ParagraphStyle(
+        "Contact",
+        parent=styles["Normal"],
+        fontSize=10,
+        textColor=colors.HexColor("#566573"),
+        alignment=1,
+    )
+    section_style = ParagraphStyle(
+        "Section",
+        parent=styles["Heading2"],
+        fontSize=12,
+        spaceBefore=12,
+        spaceAfter=6,
+        textColor=colors.HexColor("#1B2631"),
+    )
+    normal_style = ParagraphStyle("Normal", parent=styles["Normal"], fontSize=11, leading=15)
+    bullet_style = ParagraphStyle("Bullet", parent=styles["Normal"], fontSize=11, leading=15, leftIndent=6)
+
+    story = []
+
+    # Header with optional profile image: split header into a two-column table
+    header_data = []
+    header_cells = []
+
+    # Name & contact block
+    header_text = f"<b>{name}</b>"
+    header_text += f"<br/>{email} | {phone}"
+    header_para = Paragraph(header_text, ParagraphStyle("HeaderLeft", parent=styles["Normal"], alignment=0, fontSize=10, leading=12))
+
+    # If profile image is provided, create a small reportlab Image
+    if profile_image_bytes:
+        try:
+            tmp = io.BytesIO(profile_image_bytes)
+            pil = Image.open(tmp)
+            pil.thumbnail((150, 150))
+            img_temp = io.BytesIO()
+            pil.save(img_temp, format="PNG")
+            img_temp.seek(0)
+            rl_img = RLImage(img_temp, width=40 * mm, height=40 * mm)
+            header_cells = [[rl_img, header_para]]
+            header_table = Table(header_cells, colWidths=[45 * mm, 120 * mm])
+        except Exception:
+            # fallback to no image
+            header_table = Table([[header_para]], colWidths=[165 * mm])
+    else:
+        header_table = Table([[header_para]], colWidths=[165 * mm])
+
+    header_table.setStyle(
+        TableStyle(
+            [
+                ("VALIGN", (0, 0), (-1, -1), "MIDDLE"),
+                ("LEFTPADDING", (0, 0), (-1, -1), 0),
+                ("RIGHTPADDING", (0, 0), (-1, -1), 0),
+                ("BOTTOMPADDING", (0, 0), (-1, -1), 6),
+            ]
+        )
+    )
+
+    story.append(header_table)
+    story.append(Spacer(1, 8))
+    # Thin accent line
+    story.append(Table([[""]], colWidths=[165 * mm], style=[("LINEBELOW", (0, 0), (-1, -1), 1, colors.HexColor("#2C3E50"))]))
+    story.append(Spacer(1, 6))
+
+    # Parse content into sections. We expect structured AI output with headings e.g. "Summary", "Skills", etc.
+    # We'll split by lines and detect sections by headings
+    lines = [l for l in content.splitlines()]
+    current_section = None
     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()
+    for ln in lines:
+        ln_stripped = ln.strip()
+        if not ln_stripped:
+            continue
+        # heuristics for section headings
+        llow = ln_stripped.lower()
+        if llow.startswith("summary") or llow.startswith("skills") or llow.startswith("experience") or llow.startswith("education") or llow.startswith("projects"):
+            current_section = ln_stripped
             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))
-
+        else:
+            if current_section is None:
+                # put in summary fallback
+                sections.setdefault("Summary", []).append(ln_stripped)
+            else:
+                sections[current_section].append(ln_stripped)
+
+    # If no detected sections, treat whole content as a summary paragraph
+    if not sections:
+        sections["Summary"] = lines
+
+    # Build PDF content by section
+    accent = colors.HexColor("#2C3E50")
+
+    for sec_title, sec_lines in sections.items():
+        # Standardize title text (use 'Skills' instead of 'Skills:')
+        title_clean = sec_title.strip().rstrip(":").title()
+        story.append(Paragraph(title_clean, section_style))
+
+        # Skills: render as two-column table with small cells
+        if title_clean.lower().startswith("skills"):
+            # flatten bullets and commas
+            skills = []
+            for l in sec_lines:
+                # remove leading bullets if present
+                l2 = l.lstrip("-• ")
+                parts = [p.strip() for p in l2.replace(",", "\n").splitlines() if p.strip()]
+                skills.extend(parts)
+            if not skills:
+                story.append(Paragraph("No skills detected.", normal_style))
+            else:
+                # create two-column table
+                left_col = skills[0::2]
+                right_col = skills[1::2] + [""] * max(0, len(left_col) - len(skills[1::2]))
+                table_data = list(zip(left_col, right_col))
+                skills_table = Table(table_data, colWidths=[75 * mm, 75 * mm])
+                skills_table.setStyle(
+                    TableStyle(
+                        [
+                            ("VALIGN", (0, 0), (-1, -1), "TOP"),
+                            ("INNERGRID", (0, 0), (-1, -1), 0.25, colors.HexColor("#E5E7EB")),
+                            ("BOX", (0, 0), (-1, -1), 0, colors.white),
+                            ("LEFTPADDING", (0, 0), (-1, -1), 6),
+                            ("RIGHTPADDING", (0, 0), (-1, -1), 6),
+                        ]
+                    )
+                )
+                story.append(skills_table)
+        # Experience: detect lines and format with title/company left and dates right
+        elif title_clean.lower().startswith("experience"):
+            # We will try to parse blocks starting with something that looks like "Job Title | Company | Dates"
+            # We will treat each blank-line separated block as an entry
+            entries = []
+            current = []
+            for l in sec_lines:
+                if l.strip() == "":
+                    if current:
+                        entries.append(current)
+                        current = []
+                else:
+                    current.append(l)
+            if current:
+                entries.append(current)
+
+            # Fallback: if entries is empty, treat all lines as one block
+            if not entries and sec_lines:
+                entries = [sec_lines]
+
+            for entry in entries:
+                # first non-empty line often has job title | company | date or similar
+                header_line = entry[0]
+                parts = [p.strip() for p in header_line.split("|")]
+                if len(parts) >= 3:
+                    title_company = f"<b>{parts[0]}</b> | {parts[1]}"
+                    dates = parts[2]
+                elif len(parts) == 2:
+                    title_company = f"<b>{parts[0]}</b> | {parts[1]}"
+                    dates = ""
+                else:
+                    title_company = header_line
+                    dates = ""
+
+                table = Table([[Paragraph(title_company, normal_style), Paragraph(dates, ParagraphStyle("Right", parent=normal_style, alignment=2))]],
+                              colWidths=[115 * mm, 40 * mm])
+                table.setStyle(TableStyle([("VALIGN", (0, 0), (-1, -1), "TOP"), ("LEFTPADDING", (0, 0), (-1, -1), 0)]))
+                story.append(table)
+                # rest of lines are bullets or descriptions
+                for desc in entry[1:]:
+                    # convert leading dashes to bullets
+                    desc_clean = desc.lstrip("-• ").strip()
+                    story.append(Paragraph("• " + desc_clean, bullet_style))
+                story.append(Spacer(1, 6))
+        else:
+            # Generic paragraph or list
+            for l in sec_lines:
+                # bullet detection
+                if l.startswith("- ") or l.startswith("• "):
+                    text = l.lstrip("-• ").strip()
+                    story.append(Paragraph("• " + text, bullet_style))
+                else:
+                    story.append(Paragraph(l, normal_style))
+        story.append(Spacer(1, 8))
 
     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 '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 = ""
+# -----------------------------
+# STREAMLIT UI
+# -----------------------------
+st.set_page_config(page_title="MATCHHIVE - AI Job Matcher", layout="wide", initial_sidebar_state="expanded")
+# Custom CSS for nicer buttons and spacing
+st.markdown(
+    """
+    <style>
+    .stButton>button { border-radius: 8px; padding:8px 12px; }
+    .download-btn { background-color:#2ECC71 !important; color:white !important; }
+    .job-card { padding:10px; border:1px solid #E5E7EB; border-radius:8px; margin-bottom:8px; }
+    </style>
+    """,
+    unsafe_allow_html=True,
+)
 
-# --- Sidebar ---
+# Header area with optional logo upload
+col1, col2 = st.columns([1, 6])
+with col1:
+    logo_file = st.file_uploader("Upload logo (optional)", type=["png", "jpg", "jpeg"], help="Optional: upload your company/app logo")
+    if logo_file:
+        img = Image.open(logo_file)
+        st.image(img, width=100)
+with col2:
+    st.title("MATCHHIVE - AI Job Matcher")
+    st.caption("Upload a resume, match to jobs, generate tailored resumes & cover letters (PDF).")
+
+# Sidebar: user contact info + options
 with st.sidebar:
-    st.markdown("## 📄 AI Resume Tailor")
+    st.header("Candidate Info")
+    name = st.text_input("Full Name", "John Doe")
+    email = st.text_input("Email", "john.doe@email.com")
+    phone = st.text_input("Phone", "+1 234 567 890")
+    profile_pic = st.file_uploader("Profile photo (optional)", type=["png", "jpg", "jpeg"], help="Small circular/headshot for resume header")
     st.markdown("---")
-    
-    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")
-    
-    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!")
-
-# --- 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.")
-
-if st.session_state.matched_jobs is not None:
+    st.header("Job Filters (optional)")
+    location_filter = st.text_input("Location keyword (e.g. Remote, USA, Canada)", "")
+    keyword_filter = st.text_input("Job keyword (e.g. Python, ML, DevOps)", "")
+    min_score = st.slider("Minimum match score", min_value=0.0, max_value=1.0, value=0.0, step=0.01)
+    top_k = st.number_input("Number of matches to show", min_value=1, max_value=20, value=5)
     st.markdown("---")
-    st.header("✨ Top Job Matches")
-
-    # --- 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)
-
-    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 filtered_jobs.empty:
-        st.warning("No jobs match your current filter criteria.")
-    else:
-        # --- 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.")
+    st.caption("Note: Job data comes from remoteok.com API and match scores are semantic similarity approximations.")
 
+# Main upload & processing area
+st.header("Upload Resume (PDF or DOCX)")
+resume_file = st.file_uploader("Upload your resume", type=["pdf", "docx"])
+if not resume_file:
+    st.info("Please upload a resume (PDF or DOCX) to start matching.")
 else:
-    st.info("Upload your resume in the sidebar to find job matches.")
+    with st.spinner("Extracting resume text..."):
+        resume_text = extract_text_from_resume(resume_file)
+
+    if not resume_text.strip():
+        st.error("Could not extract text from the resume. Try a different file or ensure the PDF is text-based (not scanned).")
+    else:
+        # Fetch jobs and filter
+        with st.spinner("Fetching remote jobs..."):
+            jobs = fetch_jobs()
+
+        # Apply simple filters
+        def job_matches_filters(job):
+            if location_filter:
+                loc = job.get("location") or job.get("company_location") or ""
+                if location_filter.lower() not in str(loc).lower():
+                    return False
+            if keyword_filter:
+                combined = f"{job.get('position','')} {job.get('company','')} {job.get('description','')}"
+                if keyword_filter.lower() not in combined.lower():
+                    return False
+            return True
+
+        filtered_jobs = [j for j in jobs if job_matches_filters(j)]
+
+        # Do matching & display results
+        with st.spinner("Computing semantic match scores..."):
+            matches = match_jobs(resume_text, filtered_jobs, top_k=top_k)
+
+        # apply min_score filter
+        matches = [(job, score) for job, score in matches if score >= min_score]
+
+        if not matches:
+            st.warning("No matches found with given filters/score. Try lowering minimum score or removing filters.")
+        else:
+            st.subheader(f"Top {len(matches)} Matches")
+            for job, score in matches:
+                # Use an expander for each job
+                title = job.get("position", "Unknown Position")
+                company = job.get("company", "Unknown Company")
+                url = job.get("url", "#")
+                posted = job.get("date", "")
+                exp_label = f"{title} at {company} — Score: {score:.2f}"
+                with st.expander(exp_label, expanded=False):
+                    st.markdown(f"**Location:** {job.get('location','N/A')}  \n**Posted:** {posted}  \n[View Job Posting]({url})")
+                    st.markdown("---")
+                    cols = st.columns([1, 1, 1])
+                    # Buttons for generation in-line
+                    if cols[0].button("Generate Resume (AI)", key=f"resume_{job.get('id', title)}"):
+                        with st.spinner("Generating tailored resume..."):
+                            tailored_resume = generate_resume(resume_text, job)
+                        # show in a tabbed output
+                        tab1, tab2 = st.tabs(["Tailored Resume", "Cover Letter"])
+                        with tab1:
+                            edited_resume = st.text_area("Tailored Resume (editable)", tailored_resume, height=300)
+                            if st.button("Export Tailored Resume as PDF", key=f"export_resume_{job.get('id', title)}"):
+                                prof_bytes = None
+                                if profile_pic:
+                                    prof_bytes = profile_pic.getvalue()
+                                pdf_buffer = build_pdf(edited_resume, title="Resume", name=name, email=email, phone=phone, profile_image_bytes=prof_bytes)
+                                st.download_button(
+                                    label="📥 Download Resume (PDF)",
+                                    data=pdf_buffer,
+                                    file_name=f"{name.replace(' ', '_')}_resume.pdf",
+                                    mime="application/pdf",
+                                )
+                        with tab2:
+                            # generate cover letter on demand
+                            if cols[1].button("Generate Cover Letter (AI)", key=f"clgen_{job.get('id', title)}"):
+                                with st.spinner("Generating cover letter..."):
+                                    tailored_cl = generate_cover_letter(resume_text, job, name, email, phone)
+                                edited_cl = st.text_area("Cover Letter (editable)", tailored_cl, height=300, key=f"cltext_{job.get('id', title)}")
+                                if st.button("Export Cover Letter as PDF", key=f"export_cl_{job.get('id', title)}"):
+                                    prof_bytes = None
+                                    if profile_pic:
+                                        prof_bytes = profile_pic.getvalue()
+                                    pdf_buffer = build_pdf(edited_cl, title="Cover Letter", name=name, email=email, phone=phone, profile_image_bytes=prof_bytes)
+                                    st.download_button(
+                                        label="📥 Download Cover Letter (PDF)",
+                                        data=pdf_buffer,
+                                        file_name=f"{name.replace(' ', '_')}_cover_letter.pdf",
+                                        mime="application/pdf",
+                                    )
+
+                    # Quick preview of job description (collapsible)
+                    if cols[2].button("Show Job Description", key=f"desc_{job.get('id', title)}"):
+                        st.info(job.get("description", "No description available"))
+
+            st.success("Done — select a match and generate your tailored resume or cover letter.")