import re
import json
from typing import List, Dict, Optional
import spacy
from spacy.matcher import Matcher

# Load spaCy small English model for entity recognition
# Install via: python -m spacy download en_core_web_sm
try:
    nlp = spacy.load("en_core_web_sm")
except OSError:
    raise RuntimeError("spaCy en_core_web_sm model not found. Install with: python -m spacy download en_core_web_sm")

class ResumeImpactExtractor:
    """Extracts quantified project impacts from resume text to score resume effectiveness."""

    # Regex patterns for common quantifiable metrics: percentages, dollar amounts, time savings, latency, throughput
    QUANT_PATTERNS = [
        r"(\d+\.?\d*%)\s+(reduction|increase|improvement|decrease|growth)",  # e.g., 30% reduction
        r"\$(\d+\.?\d*[kKmMbB]?)\s+(saved|revenue|cost|spend|profit)",       # e.g., $1.2M saved
        r"(\d+\.?\d*)\s+(ms|seconds|minutes|hours|days|weeks)\s+(latency|p99|response time)",  # e.g., 120ms latency
        r"(\d+\.?\d*)\s+(requests per second|RPS|throughput|QPS)",          # e.g., 10k RPS
        r"(\d+\.?\d*)\s+(engineers|developers|team members)\s+(managed|led|mentored)",  # e.g., 8 engineers led
    ]

    def __init__(self):
        self.matcher = Matcher(nlp.vocab)
        self._add_quant_patterns()

    def _add_quant_patterns(self):
        """Add regex-based patterns to spaCy matcher for flexible matching."""
        for idx, pattern in enumerate(self.QUANT_PATTERNS):
            # Convert regex to spaCy token patterns (simplified for demo; full implementation uses regex matcher)
            self.matcher.add(f"QUANT_{idx}", [[{"TEXT": {"REGEX": pattern}}]])

    def extract_impacts(self, resume_text: str) -> List[Dict[str, str]]:
        """
        Process resume text and return list of quantified impacts with context.

        Args:
            resume_text: Raw text extracted from resume PDF/Word doc

        Returns:
            List of dicts with "metric", "value", "context" keys
        """
        if not resume_text or not isinstance(resume_text, str):
            raise ValueError("resume_text must be a non-empty string")

        doc = nlp(resume_text)
        impacts = []

        # Find all matches for quantifiable patterns
        matches = self.matcher(doc)
        for match_id, start, end in matches:
            span = doc[start:end]
            metric_text = span.text

            # Extract surrounding context (2 sentences before/after)
            sent_start = max(0, span.sent.start - 2)
            sent_end = min(len(doc.sents), span.sent.end + 2)
            context = " ".join([sent.text for sent in doc.sents[sent_start:sent_end]])

            # Parse metric value and type
            value = self._parse_metric_value(metric_text)
            metric_type = self._parse_metric_type(metric_text)

            impacts.append({
                "metric": metric_text,
                "value": value,
                "type": metric_type,
                "context": context.strip()
            })

        return impacts

    def _parse_metric_value(self, metric_text: str) -> Optional[float]:
        """Extract numeric value from metric text, handling k/M/B suffixes."""
        num_match = re.search(r"(\d+\.?\d*)", metric_text)
        if not num_match:
            return None
        num = float(num_match.group(1))
        # Handle suffixes
        if "k" in metric_text.lower():
            num *= 1e3
        elif "m" in metric_text.lower():
            num *= 1e6
        elif "b" in metric_text.lower():
            num *= 1e9
        return num

    def _parse_metric_type(self, metric_text: str) -> str:
        """Categorize metric into standard types."""
        metric_text = metric_text.lower()
        if any(term in metric_text for term in ["latency", "p99", "response time"]):
            return "performance"
        elif any(term in metric_text for term in ["saved", "cost", "revenue", "profit"]):
            return "financial"
        elif any(term in metric_text for term in ["reduction", "increase", "improvement"]):
            return "efficiency"
        elif any(term in metric_text for term in ["rps", "qps", "throughput"]):
            return "throughput"
        elif any(term in metric_text for term in ["engineers", "team", "mentored"]):
            return "leadership"
        return "other"

    def score_resume(self, resume_text: str) -> float:
        """
        Score resume from 0-100 based on quantified impacts.
        0 = no impacts, 100 = 10+ high-value impacts.
        """
        impacts = self.extract_impacts(resume_text)
        if not impacts:
            return 0.0
        # Weight high-value metrics (financial, performance) more than others
        weights = {
            "financial": 3.0,
            "performance": 2.5,
            "throughput": 2.0,
            "efficiency": 1.5,
            "leadership": 1.0,
            "other": 0.5
        }
        total_weight = sum(weights[imp["type"]] for imp in impacts)
        # Cap score at 100
        return min(100.0, total_weight * 5)

# Example usage
if __name__ == "__main__":
    sample_resume = """
    Senior Backend Engineer with 8 years of experience.
    Led migration of 12 microservices to Kubernetes, reducing p99 latency from 2.4s to 120ms.
    Built caching layer that increased throughput by 400% to 12k RPS.
    Managed team of 6 engineers, delivered $1.2M in cost savings via resource optimization.
    Responsible for maintaining CI/CD pipelines.
    """
    try:
        extractor = ResumeImpactExtractor()
        impacts = extractor.extract_impacts(sample_resume)
        score = extractor.score_resume(sample_resume)
        print(f"Resume Score: {score}/100")
        print("Extracted Impacts:")
        print(json.dumps(impacts, indent=2))
    except Exception as e:
        print(f"Error processing resume: {e}")

import requests
import json
from typing import Dict, List, Optional
from dataclasses import dataclass
import time

@dataclass
class CompensationPackage:
    """Represents a total compensation package with base, stock, bonus."""
    base: float
    stock: float
    bonus: float
    total: float
    currency: str = "USD"

    def to_dict(self) -> Dict:
        return {
            "base": self.base,
            "stock": self.stock,
            "bonus": self.bonus,
            "total": self.total,
            "currency": self.currency
        }

class SalaryBenchmarker:
    """
    Pulls real-time compensation data from public APIs to generate negotiation baselines.
    Uses levelsdotfyi/levels-api (unofficial wrapper)
    and Glassdoor public endpoints.
    """

    # Public Levels.fyi API endpoint (unofficial, rate limited to 10 req/min)
    LEVELS_API_BASE = "https://www.levels.fyi/api/v1"
    # Glassdoor search endpoint (public, no auth required for basic queries)
    GLASSDOOR_SEARCH = "https://www.glassdoor.com/api/jobsearch/search"

    def __init__(self, levels_api_key: Optional[str] = None):
        self.levels_api_key = levels_api_key
        self.session = requests.Session()
        self.session.headers.update({
            "User-Agent": "SeniorEngineerSalaryTool/1.0 (contact: infoq@example.com)"
        })

    def get_levels_compensation(self, company: str, title: str, yoe: int) -> List[CompensationPackage]:
        """
        Fetch compensation data from Levels.fyi for a given company, title, and years of experience.

        Args:
            company: Company name (e.g., "Google", "Stripe")
            title: Job title (e.g., "Senior Backend Engineer")
            yoe: Years of relevant experience

        Returns:
            List of CompensationPackage objects
        """
        if not all([company, title, isinstance(yoe, int), yoe > 0]):
            raise ValueError("Invalid input: company, title must be non-empty, yoe must be positive int")

        endpoint = f"{self.LEVELS_API_BASE}/salary/search"
        params = {
            "company": company,
            "title": title,
            "yoe": yoe,
            "format": "json"
        }
        if self.levels_api_key:
            params["api_key"] = self.levels_api_key

        try:
            response = self.session.get(endpoint, params=params, timeout=10)
            response.raise_for_status()
            data = response.json()
        except requests.exceptions.RequestException as e:
            print(f"Levels.fyi API error: {e}")
            return []
        except json.JSONDecodeError:
            print("Failed to parse Levels.fyi response")
            return []

        packages = []
        for entry in data.get("data", []):
            try:
                total = entry.get("totalCompensation", 0)
                base = entry.get("baseSalary", 0)
                stock = entry.get("stockGrant", 0)
                bonus = entry.get("bonus", 0)
                # Convert to annual USD if needed (simplified)
                packages.append(CompensationPackage(
                    base=float(base),
                    stock=float(stock),
                    bonus=float(bonus),
                    total=float(total)
                ))
            except (ValueError, TypeError):
                continue
        return packages

    def get_glassdoor_compensation(self, company: str, title: str, location: str = "San Francisco, CA") -> Optional[CompensationPackage]:
        """
        Fetch average compensation from Glassdoor for a given role and location.
        Note: Glassdoor may block automated requests; use sparingly.
        """
        params = {
            "jobTitle": title,
            "employerName": company,
            "location": location,
            "format": "json"
        }
        try:
            response = self.session.get(self.GLASSDOOR_SEARCH, params=params, timeout=10)
            response.raise_for_status()
            data = response.json()
        except requests.exceptions.RequestException as e:
            print(f"Glassdoor API error: {e}")
            return None

        if not data.get("results"):
            return None

        result = data["results"][0]
        try:
            base = float(result.get("basePay", {}).get("average", 0))
            total = float(result.get("totalPay", {}).get("average", 0))
            # Estimate stock/bonus as 30% of total if not provided (industry average for tech)
            stock = float(result.get("stockPay", {}).get("average", total * 0.2))
            bonus = float(result.get("bonusPay", {}).get("average", total * 0.1))
            return CompensationPackage(base=base, stock=stock, bonus=bonus, total=total)
        except (ValueError, TypeError):
            return None

    def generate_negotiation_baseline(self, company: str, title: str, yoe: int, location: str = "San Francisco, CA") -> Dict:
        """
        Generate a combined baseline from multiple sources for negotiation.
        Returns 25th, 50th (median), 75th percentile of total compensation.
        """
        levels_data = self.get_levels_compensation(company, title, yoe)
        glassdoor_data = self.get_glassdoor_compensation(company, title, location)

        all_totals = [pkg.total for pkg in levels_data]
        if glassdoor_data:
            all_totals.append(glassdoor_data.total)

        if not all_totals:
            return {"error": "No compensation data found for given parameters"}

        all_totals.sort()
        n = len(all_totals)
        return {
            "25th_percentile": all_totals[int(n * 0.25)],
            "median": all_totals[int(n * 0.5)],
            "75th_percentile": all_totals[int(n * 0.75)],
            "sample_size": n,
            "sources": ["Levels.fyi", "Glassdoor"]
        }

# Example usage
if __name__ == "__main__":
    benchmarker = SalaryBenchmarker()
    try:
        baseline = benchmarker.generate_negotiation_baseline(
            company="Stripe",
            title="Senior Backend Engineer",
            yoe=8,
            location="San Francisco, CA"
        )
        print("Negotiation Baseline for Stripe Senior Backend Engineer (8 YOE):")
        print(json.dumps(baseline, indent=2))
    except Exception as e:
        print(f"Error generating baseline: {e}")

import json
from typing import Dict, List, Optional
from dataclasses import dataclass
from enum import Enum

class LeverageFactor(Enum):
    """Factors that increase negotiation leverage."""
    COMPETING_OFFER = "competing_offer"
    RARE_SKILL = "rare_skill"
    TEAM_CRITICAL = "team_critical"
    UNDERMARKET = "undermarket"
    REMOTE_FLEX = "remote_flex"

@dataclass
class Offer:
    """Represents a job offer with compensation and perks."""
    company: str
    title: str
    base: float
    stock: float
    bonus: float
    total: float
    perks: List[str]
    expiration_days: int

    def to_dict(self) -> Dict:
        return {
            "company": self.company,
            "title": self.title,
            "base": self.base,
            "stock": self.stock,
            "bonus": self.bonus,
            "total": self.total,
            "perks": self.perks,
            "expiration_days": self.expiration_days
        }

class CounterOfferGenerator:
    """
    Generates data-backed counter-offer letters and talking points for salary negotiations.
    Uses benchmarks from jackson/salary-negotiation-toolkit v2.1.0.
    """

    # Negotiation multipliers based on leverage factors (increase ask by this %)
    LEVERAGE_MULTIPLIERS = {
        LeverageFactor.COMPETING_OFFER: 1.15,
        LeverageFactor.RARE_SKILL: 1.10,
        LeverageFactor.TEAM_CRITICAL: 1.12,
        LeverageFactor.UNDERMARKET: 1.20,
        LeverageFactor.REMOTE_FLEX: 1.05
    }

    def __init__(self, baseline_median: float, baseline_75th: float):
        """
        Initialize with market baseline data.

        Args:
            baseline_median: Median total compensation for role
            baseline_75th: 75th percentile total compensation for role
        """
        if baseline_median <= 0 or baseline_75th <= 0:
            raise ValueError("Baseline values must be positive floats")
        if baseline_75th < baseline_median:
            raise ValueError("75th percentile baseline must be higher than median")
        self.baseline_median = baseline_median
        self.baseline_75th = baseline_75th

    def calculate_ask(self, current_offer: Offer, leverage_factors: List[LeverageFactor]) -> float:
        """
        Calculate counter-offer ask based on current offer and leverage.

        Args:
            current_offer: The initial offer received
            leverage_factors: List of leverage factors the candidate has

        Returns:
            Total compensation ask (float)
        """
        if not isinstance(current_offer, Offer):
            raise TypeError("current_offer must be an Offer instance")
        if not all(isinstance(f, LeverageFactor) for f in leverage_factors):
            raise TypeError("All leverage factors must be LeverageFactor enum values")

        # Start with max of current offer total and baseline median
        base_ask = max(current_offer.total, self.baseline_median)

        # Apply leverage multipliers (compound)
        for factor in leverage_factors:
            multiplier = self.LEVERAGE_MULTIPLIERS.get(factor, 1.0)
            base_ask *= multiplier

        # Cap ask at 75th percentile baseline to remain reasonable
        return min(base_ask, self.baseline_75th * 1.05)

    def generate_counter_letter(self, current_offer: Offer, ask: float, leverage_factors: List[LeverageFactor]) -> str:
        """
        Generate a professional counter-offer letter with data-backed justification.
        """
        if ask <= current_offer.total:
            raise ValueError("Ask must be higher than current offer total")

        # Calculate breakdown of ask (proportional to current offer)
        total_current = current_offer.total
        base_pct = current_offer.base / total_current
        stock_pct = current_offer.stock / total_current
        bonus_pct = current_offer.bonus / total_current

        ask_breakdown = {
            "base": round(ask * base_pct, 2),
            "stock": round(ask * stock_pct, 2),
            "bonus": round(ask * bonus_pct, 2),
            "total": round(ask, 2)
        }

        # Build leverage justification
        leverage_text = "\n".join([f"- {factor.value.replace('_', ' ').title()}" for factor in leverage_factors])

        letter = f"""
        Dear {current_offer.company} Hiring Team,

        Thank you for extending the offer for the {current_offer.title} position. I’m excited about the team’s work on [specific project/mission] and believe my 8 years of backend engineering experience align perfectly with your needs.

        After reviewing market compensation data for similar roles (median: ${self.baseline_median:,.0f}, 75th percentile: ${self.baseline_75th:,.0f}), I’d like to discuss adjusting the offer to ${ask_breakdown['total']:,.0f} total compensation, broken down as:
        - Base Salary: ${ask_breakdown['base']:,.0f}
        - Stock Grant: ${ask_breakdown['stock']:,.0f}
        - Annual Bonus: ${ask_breakdown['bonus']:,.0f}

        This ask is supported by the following factors:
        {leverage_text}

        I’m flexible on the breakdown of the package and open to discussing how we can align this with the team’s compensation structure. Please let me know if we can schedule a call to discuss further.

        Best regards,
        [Your Name]
        """
        return letter.strip()

    def get_talking_points(self, current_offer: Offer, ask: float, leverage_factors: List[LeverageFactor]) -> List[str]:
        """Generate bullet-point talking points for verbal negotiation."""
        points = [
            f"Market data shows median total comp for this role is ${self.baseline_median:,.0f}, with 75th percentile at ${self.baseline_75th:,.0f}.",
            f"My current offer of ${current_offer.total:,.0f} is {'below' if current_offer.total < self.baseline_median else 'near'} the median.",
            f"I’m asking for ${ask:,.0f} total, which is within the 75th percentile range for my experience level."
        ]
        for factor in leverage_factors:
            if factor == LeverageFactor.COMPETING_OFFER:
                points.append("I have a competing offer at $X from [Company], which I’d prefer to turn down in favor of joining your team.")
            elif factor == LeverageFactor.RARE_SKILL:
                points.append("My experience with [specific rare skill, e.g., Kafka stream processing] is directly applicable to your Q3 throughput goals.")
        return points

# Example usage
if __name__ == "__main__":
    # Sample current offer
    current_offer = Offer(
        company="Stripe",
        title="Senior Backend Engineer",
        base=180000,
        stock=50000,
        bonus=20000,
        total=250000,
        perks=["remote", "health insurance", "401k match"],
        expiration_days=7
    )
    # Baseline from earlier example
    baseline_median = 280000
    baseline_75th = 320000

    try:
        generator = CounterOfferGenerator(baseline_median, baseline_75th)
        leverage_factors = [LeverageFactor.COMPETING_OFFER, LeverageFactor.RARE_SKILL]
        ask = generator.calculate_ask(current_offer, leverage_factors)
        letter = generator.generate_counter_letter(current_offer, ask, leverage_factors)
        points = generator.get_talking_points(current_offer, ask, leverage_factors)

        print(f"Counter Offer Ask: ${ask:,.0f}")
        print("\nCounter Letter:")
        print(letter)
        print("\nTalking Points:")
        for p in points:
            print(f"- {p}")
    except Exception as e:
        print(f"Error generating counter offer: {e}")

extractor = ResumeImpactExtractor()
score = extractor.score_resume(your_resume_text)
print(f"Resume Score: {score}/100")  # Aim for 70+

benchmarker = SalaryBenchmarker()
baseline = benchmarker.generate_negotiation_baseline("Google", "Senior Backend Engineer", 8)
print(f"Median: ${baseline['median']:,.0f}")  # Use this as your floor

doc = nlp(your_resume_text)
skills_found = [ent.text for ent in doc.ents if ent.label_ == "SKILL"]
print(f"ATS Parsed Skills: {skills_found}")  # Match to posting keywords