legex/scrapers/sg.py

import logging
import re
import time
from datetime import date, datetime
from typing import Any

import requests

from legex.models.base import Case
from legex.scrapers.base import BaseScraper

log = logging.getLogger(__name__)

BASE = "https://sgcaselaw.com/cases/"
HEADERS = {"User-Agent": "Mozilla/5.0 (compatible; LegalResearch/1.0)"}
TARGET_COURTS = {"SGCA", "SGHC", "SGHC(A)"}
PAGES = range(1, 29)
DELAY_SECONDS = 0.5
DETAIL_DELAY_SECONDS = 0.3

_CASE_RE = re.compile(r"/cases/(\d{4}-[A-Z]+(?:\([A-Z]\))?-\d+)/")


def _extract_date_from_listing(html: str, case_id: str) -> str:
    """Try to extract a decision date adjacent to a case link."""
    pattern = (
        rf"{re.escape(case_id)}.*?"
        r"(\d{1,2}\s+(?:January|February|March|April|May|June|July|August|September|October|November|December)\s+\d{4})"
    )
    m = re.search(pattern, html, re.DOTALL)
    if m:
        try:
            return datetime.strptime(m.group(1), "%d %B %Y").strftime("%Y-%m-%d")
        except ValueError:
            pass
    return ""


def _scrape_date_for_case(link: str) -> str:
    """Fallback: fetch the individual case page and pluck the first long-form date."""
    try:
        r = requests.get(link, headers=HEADERS, timeout=15)
        m = re.search(
            r"(\d{1,2})\s+(January|February|March|April|May|June|July|August|September|October|November|December)\s+(\d{4})",
            r.text,
        )
        if m:
            dt = datetime.strptime(f"{m.group(1)} {m.group(2)} {m.group(3)}", "%d %B %Y")
            return dt.strftime("%Y-%m-%d")
    except Exception:
        pass
    return ""


def _scrape_index() -> list[dict[str, Any]]:
    rows: list[dict[str, Any]] = []
    for page in PAGES:
        url = f"{BASE}?page={page}" if page > 1 else BASE
        try:
            r = requests.get(url, headers=HEADERS, timeout=30)
            r.raise_for_status()
        except Exception as e:
            log.warning("SG page %d: %s", page, e)
            continue

        for case_id in _CASE_RE.findall(r.text):
            parts = case_id.split("-")
            if len(parts) < 3:
                continue
            court = "-".join(parts[1:-1])
            if court not in TARGET_COURTS:
                continue
            link = f"https://sgcaselaw.com/cases/{case_id}/"
            decision_date = _extract_date_from_listing(r.text, case_id)
            rows.append({"decision_date": decision_date, "link": link, "case_id": case_id})

        log.info("SG page %d: running %d", page, len(rows))
        time.sleep(DELAY_SECONDS)
    return rows


class SGScraper(BaseScraper):
    country = "Singapur"

    def scrape(
        self,
        start_date: date | None = None,
        end_date: date | None = None,
    ) -> list[Case]:
        rows = _scrape_index()

        # Dedupe by link (preserve first occurrence).
        seen: set[str] = set()
        unique: list[dict[str, Any]] = []
        for row in rows:
            if row["link"] in seen:
                continue
            seen.add(row["link"])
            unique.append(row)
        log.info("SG unique civil cases: %d", len(unique))

        # Back-fill missing dates from individual case pages.
        missing = [row for row in unique if not row["decision_date"]]
        log.info("SG missing dates: %d", len(missing))
        for i, row in enumerate(missing):
            if i % 10 == 0:
                log.info("SG fetching dates %d/%d", i, len(missing))
            row["decision_date"] = _scrape_date_for_case(row["link"])
            time.sleep(DETAIL_DELAY_SECONDS)

        cases: list[Case] = []
        for row in unique:
            decision_date: date | None = None
            if row["decision_date"]:
                try:
                    decision_date = date.fromisoformat(row["decision_date"])
                except ValueError:
                    decision_date = None

            if start_date and decision_date and decision_date < start_date:
                continue
            if end_date and decision_date and decision_date > end_date:
                continue

            case_id = row["case_id"]
            parts = case_id.split("-")
            court = "-".join(parts[1:-1]) if len(parts) >= 3 else None

            cases.append(Case(
                case_id=case_id,
                link=row["link"],
                decision_date=decision_date,
                jurisdiction="sg",
                language="en",
                full_text=None,
                metadata={"court": court} if court else {},
            ))

        cases.sort(key=lambda c: c.decision_date or date.min, reverse=True)
        log.info("Collected %d Singapore civil cases", len(cases))
        return cases