tools.py

"""
Deterministic tool functions for the SchemeEligibilityAgent.

These are plain Python functions — no LLM calls.
Each tool performs one focused task and returns structured data.
"""

import json
import os


# ---------------------------------------------------------------------------
# Constants for rule evaluation
# ---------------------------------------------------------------------------

INCOME_UPPER_BOUNDS = {
    "Below 1 Lakh": 100000,
    "1-2.5 Lakh": 250000,
    "2.5-5 Lakh": 500000,
    "5-8 Lakh": 800000,
    "8-10 Lakh": 1000000,
    "Above 10 Lakh": float("inf"),
}

EDUCATION_RANK = {
    "Below 10th": 1,
    "10th Pass": 2,
    "12th Pass": 3,
    "Diploma/ITI": 4,
    "Graduate": 5,
    "Post Graduate": 6,
    "PhD": 7,
}


# ---------------------------------------------------------------------------
# Tool 1: Load schemes from JSON database
# ---------------------------------------------------------------------------

def load_schemes(filepath: str = "schemes.json") -> list[dict]:
    """
    Load all government schemes from the local JSON database.

    Reads the JSON file and returns a list of scheme dictionaries.
    Uses the script's directory for path resolution so it works
    regardless of the working directory.
    """
    base_dir = os.path.dirname(os.path.abspath(__file__))
    full_path = os.path.join(base_dir, filepath)
    with open(full_path, "r", encoding="utf-8") as f:
        data = json.load(f)
    return data["schemes"]


# ---------------------------------------------------------------------------
# Tool 2: Check eligibility for a single scheme
# ---------------------------------------------------------------------------

def check_eligibility(user_profile: dict, scheme: dict) -> dict:
    """
    Compare a user profile against a single scheme's eligibility rules.

    Evaluates 7 dimensions:
      1. Age range
      2. Income threshold
      3. Education level
      4. Social category
      5. Employment status
      6. Gender
      7. State

    Returns a dict with:
      - scheme_id: str
      - scheme_name: str
      - eligible: bool
      - reasons: list[str] — one entry per dimension checked
    """
    rules = scheme["rules"]
    reasons = []
    eligible = True

    # --- 1. Age check ---
    age = user_profile["age"]
    age_min = rules.get("age_min")
    age_max = rules.get("age_max")

    if age_min is not None and age < age_min:
        eligible = False
        reasons.append(f"Rejected: Age {age} is below minimum {age_min}")
    elif age_max is not None and age > age_max:
        eligible = False
        reasons.append(f"Rejected: Age {age} exceeds maximum {age_max}")
    else:
        lo = age_min if age_min is not None else "any"
        hi = age_max if age_max is not None else "any"
        reasons.append(f"Passed: Age {age} is within range [{lo}-{hi}]")

    # --- 2. Income check ---
    income_max = rules.get("income_max")
    if income_max is not None:
        user_income_upper = INCOME_UPPER_BOUNDS.get(
            user_profile["income_range"], 0
        )
        if user_income_upper > income_max:
            eligible = False
            reasons.append(
                f"Rejected: Income range '{user_profile['income_range']}' "
                f"exceeds limit of Rs {income_max:,}"
            )
        else:
            reasons.append(
                f"Passed: Income range '{user_profile['income_range']}' "
                f"is within limit of Rs {income_max:,}"
            )
    else:
        reasons.append("Passed: No income restriction")

    # --- 3. Education check ---
    min_edu = rules.get("min_education")
    if min_edu is not None:
        user_rank = EDUCATION_RANK.get(user_profile["education"], 0)
        required_rank = EDUCATION_RANK.get(min_edu, 0)
        if user_rank < required_rank:
            eligible = False
            reasons.append(
                f"Rejected: Education '{user_profile['education']}' "
                f"is below minimum '{min_edu}'"
            )
        else:
            reasons.append(
                f"Passed: Education '{user_profile['education']}' "
                f"meets minimum '{min_edu}'"
            )
    else:
        reasons.append("Passed: No education restriction")

    # --- 4. Category check ---
    eligible_cats = rules.get("eligible_categories", ["All"])
    if "All" not in eligible_cats and user_profile["category"] not in eligible_cats:
        eligible = False
        reasons.append(
            f"Rejected: Category '{user_profile['category']}' "
            f"not in {eligible_cats}"
        )
    else:
        reasons.append(
            f"Passed: Category '{user_profile['category']}' is eligible"
        )

    # --- 5. Employment status check ---
    eligible_emp = rules.get("eligible_employment", ["All"])
    if "All" not in eligible_emp and user_profile["employment_status"] not in eligible_emp:
        eligible = False
        reasons.append(
            f"Rejected: Employment status '{user_profile['employment_status']}' "
            f"not in {eligible_emp}"
        )
    else:
        reasons.append(
            f"Passed: Employment status '{user_profile['employment_status']}' "
            f"is eligible"
        )

    # --- 6. Gender check ---
    eligible_gender = rules.get("eligible_gender", ["All"])
    if "All" not in eligible_gender and user_profile["gender"] not in eligible_gender:
        eligible = False
        reasons.append(
            f"Rejected: Gender '{user_profile['gender']}' "
            f"not in {eligible_gender}"
        )
    else:
        reasons.append(
            f"Passed: Gender '{user_profile['gender']}' is eligible"
        )

    # --- 7. State check ---
    eligible_states = rules.get("eligible_states", ["All"])
    user_state = user_profile["state"]
    if (
        "All" not in eligible_states
        and user_state != "Any"
        and user_state not in eligible_states
    ):
        eligible = False
        reasons.append(
            f"Rejected: State '{user_state}' not in eligible states"
        )
    else:
        reasons.append(f"Passed: State '{user_state}' is eligible")

    return {
        "scheme_id": scheme["id"],
        "scheme_name": scheme["name"],
        "eligible": eligible,
        "reasons": reasons,
    }


# ---------------------------------------------------------------------------
# Tool 3: Summarize benefits in human-friendly language
# ---------------------------------------------------------------------------

def summarize_benefits(scheme: dict) -> str:
    """
    Convert a scheme's benefits list into a simple, human-friendly
    bullet-point summary string.

    No LLM — pure string formatting.
    """
    name = scheme["name"]
    description = scheme.get("description", "")
    benefits = scheme.get("benefits", [])

    lines = [name]
    if description:
        lines.append(f"  {description}")
    lines.append("  Key Benefits:")
    for benefit in benefits:
        lines.append(f"    - {benefit}")
    return "\n".join(lines)