code/collect_filings.py

"""Step 4: Download SEC filings (PDF + Markdown) and XBRL company facts.

Uses:
  - SecEdgarDownloader  from projects.tools.sec_edgar.downloader
  - playwright.html_to_pdf  from projects.tools.utils.playwright
  - html2text (project dependency) for HTML -> Markdown conversion
  - SEC XBRL CompanyFacts API for structured financial data

Pipeline per ticker:
  1. Resolve CIK (direct ticker lookup, then fuzzy match by company name)
  2. Download HTML filings to a temp dir via SecEdgarDownloader.download()
  3. Convert HTML -> PDF via playwright.html_to_pdf()  (human-readable)
  4. Convert HTML -> Markdown via html2text              (LLM-friendly)
  5. Download XBRL company facts JSON from SEC CompanyFacts API

CIK resolution strategy (every US-listed company MUST have a CIK):
  1. Direct ticker → CIK lookup via SEC company_tickers.json
  2. If that fails, fuzzy match by company name via SEC company_tickers_exchange.json
  3. Only if both fail is the ticker skipped (logged as warning)

Parallel tickers via asyncio.Semaphore.

Output:
  data/filings/{TICKER}/*.pdf       -- human-readable PDFs
  data/filings/{TICKER}/*.md        -- LLM-friendly Markdown
  data/xbrl/raw/{TICKER}.json       -- structured XBRL facts
  data/xbrl/cik_map.json            -- ticker → CIK mapping
"""

from __future__ import annotations

import asyncio
import json
import logging
import os
import tempfile
from pathlib import Path

import html2text
import httpx
import pandas as pd
from bs4 import BeautifulSoup

from projects.tools.sec_edgar.downloader import SecEdgarDownloader
from projects.tools.utils.playwright import html_to_pdf

from . import config

logger = logging.getLogger(__name__)

# Shared html2text converter configuration
_h2t = html2text.HTML2Text()
_h2t.ignore_links = False
_h2t.ignore_images = True
_h2t.body_width = 0  # no line wrapping -- let the consumer handle it
_h2t.protect_links = True
_h2t.wrap_links = False

# Inline XBRL tag names to strip (they contain machine-readable noise)
_XBRL_STRIP_TAGS = ["ix:header", "ix:hidden"]


def _html_to_markdown(html_path: Path, md_path: Path) -> None:
    """Convert an SEC filing HTML directly to Markdown using html2text.

    Strips inline XBRL metadata (ix:header, ix:hidden) before conversion
    so the resulting Markdown contains only the human-readable filing text.
    """
    html_content = html_path.read_text(encoding="utf-8", errors="replace")
    soup = BeautifulSoup(html_content, "html.parser")
    for tag_name in _XBRL_STRIP_TAGS:
        for tag in soup.find_all(tag_name):
            tag.decompose()
    markdown_text: str = _h2t.handle(str(soup))
    _ = md_path.write_text(markdown_text, encoding="utf-8")


# ---------------------------------------------------------------------------
# XBRL Company Facts helpers
# ---------------------------------------------------------------------------

_XBRL_RAW_DIR = config.XBRL_DIR / "raw"


def _atomic_json_write(data: dict, dest: Path) -> None:
    """Write JSON atomically (tempfile + os.replace)."""
    dest.parent.mkdir(parents=True, exist_ok=True)
    fd, tmp = tempfile.mkstemp(suffix=".json", dir=dest.parent)
    try:
        os.close(fd)
        with open(tmp, "w", encoding="utf-8") as fh:
            json.dump(data, fh, ensure_ascii=False)
        os.replace(tmp, dest)
    except BaseException:
        try:
            os.unlink(tmp)
        except OSError:
            pass
        raise


async def _resolve_cik_map(
    client: httpx.AsyncClient,
    tickers: list[str],
) -> dict[str, str]:
    """Build ticker → zero-padded CIK mapping (single API call, cached)."""
    url = "https://www.sec.gov/files/company_tickers.json"
    resp = await client.get(url)
    resp.raise_for_status()
    await asyncio.sleep(0.1)

    raw: dict = resp.json()
    sec_map: dict[str, str] = {}
    for entry in raw.values():
        t = str(entry.get("ticker", "")).upper()
        cik = str(entry.get("cik_str", ""))
        if t and cik:
            sec_map[t] = cik.zfill(10)

    result: dict[str, str] = {}
    missing: list[str] = []
    for ticker in tickers:
        cik = sec_map.get(ticker.upper())
        if cik:
            result[ticker] = cik
        else:
            missing.append(ticker)

    if missing:
        logger.info(
            "CIK map: %d resolved, %d missing (will try fuzzy match during filing download)",
            len(result), len(missing),
        )
    return result


async def _download_xbrl_facts(
    client: httpx.AsyncClient,
    ticker: str,
    cik: str,
) -> bool:
    """Download one company's XBRL facts JSON.  Returns True on success."""
    dest = _XBRL_RAW_DIR / f"{ticker}.json"
    if dest.exists() and dest.stat().st_size > 100:
        return True  # already collected

    url = config.XBRL_COMPANY_FACTS_URL.format(cik=cik)

    for attempt in range(3):
        try:
            resp = await client.get(url)
            if resp.status_code == 404:
                _atomic_json_write(
                    {"_no_xbrl": True, "cik": cik, "ticker": ticker}, dest,
                )
                return True

            resp.raise_for_status()
            _atomic_json_write(resp.json(), dest)
            return True

        except httpx.HTTPStatusError as exc:
            if exc.response.status_code == 429:
                await asyncio.sleep(2 ** (attempt + 1))
            elif exc.response.status_code >= 500:
                await asyncio.sleep(2 ** attempt)
            else:
                logger.warning("XBRL HTTP %d for %s", exc.response.status_code, ticker)
                return False
        except (httpx.ConnectError, httpx.ReadTimeout):
            await asyncio.sleep(2 ** attempt)

    logger.warning("XBRL download failed for %s after 3 attempts", ticker)
    return False


# ---------------------------------------------------------------------------
# Filing download helpers
# ---------------------------------------------------------------------------

_MAX_RETRIES = 3


async def _retry_async(coro_factory, description: str, retries: int = _MAX_RETRIES):
    """Call *coro_factory()* up to *retries* times with exponential backoff.

    ValueError is never retried (it signals a deterministic failure like
    missing CIK, not a transient network issue).
    """
    for attempt in range(retries):
        try:
            return await coro_factory()
        except ValueError:
            raise  # deterministic – retrying won't help
        except Exception as exc:
            if attempt < retries - 1:
                wait = 2 ** attempt * 3  # 3s, 6s, 12s
                logger.warning("%s failed (attempt %d/%d), retrying in %ds: %s",
                               description, attempt + 1, retries, wait, exc)
                await asyncio.sleep(wait)
            else:
                raise


async def _download_with_fallback(
    ticker: str,
    company_name: str,
    downloader: SecEdgarDownloader,
    output_dir: Path,
) -> list[Path]:
    """Download filings, falling back to CIK-by-company-name if ticker lookup fails.

    Every US-listed company has a CIK.  The direct ticker→CIK map sometimes
    misses tickers (recent renames, class shares, etc.), so we fall back to
    fuzzy-matching the company name against the SEC title database.
    """
    try:
        return await downloader.download(
            ticker=ticker,
            filing_types=config.SEC_FILING_TYPES,  # type: ignore[arg-type]
            from_year=config.START_YEAR,
            to_year=config.END_YEAR,
            output_dir=output_dir,
        )
    except ValueError:
        pass  # ticker not in CIK map – try fallback

    if not company_name:
        raise ValueError(f"Ticker {ticker} not in SEC CIK map and no company name for fallback.")

    logger.info("%s: ticker lookup failed, trying fuzzy match for '%s' ...", ticker, company_name)
    matches = await downloader.score_title_fuzzy_match(company_name)
    if not matches:
        raise ValueError(f"Ticker {ticker}: no fuzzy matches for '{company_name}'.")

    best = matches[0]
    if best.score < 60:
        raise ValueError(
            f"Ticker {ticker}: best fuzzy match '{best.title}' (CIK={best.cik}) "
            f"scored only {best.score:.0f} – too low to trust."
        )

    logger.info("%s: fuzzy matched → '%s' (CIK=%s, score=%.0f)", ticker, best.title, best.cik, best.score)
    return await downloader.download(
        cik=best.cik,
        filing_types=config.SEC_FILING_TYPES,  # type: ignore[arg-type]
        from_year=config.START_YEAR,
        to_year=config.END_YEAR,
        output_dir=output_dir,
    )


async def _download_ticker_filings(
    ticker: str,
    company_name: str,
    downloader: SecEdgarDownloader,
    semaphore: asyncio.Semaphore,
    xbrl_client: httpx.AsyncClient | None = None,
    cik: str | None = None,
) -> int:
    """Download filings + XBRL for a single ticker.  Returns number of filings processed."""
    ticker_dir = config.FILINGS_DIR / ticker
    done_flag = ticker_dir / ".done"
    filings_done = done_flag.exists()

    xbrl_path = _XBRL_RAW_DIR / f"{ticker}.json"
    xbrl_done = xbrl_path.exists() and xbrl_path.stat().st_size > 100

    if filings_done and xbrl_done:
        return 0  # everything already done

    async with semaphore:
        filing_count = 0

        # ── Filing documents (PDF + Markdown) ─────────────────────────
        if not filings_done:
            logger.info("Downloading filings for %s ...", ticker)
            ticker_dir.mkdir(parents=True, exist_ok=True)
            all_conversions_ok = True

            try:
                with tempfile.TemporaryDirectory(prefix="whatif_sec_") as tmpdir:
                    tmpdir_path = Path(tmpdir)
                    html_paths = await _retry_async(
                        lambda: _download_with_fallback(
                            ticker, company_name, downloader, tmpdir_path,
                        ),
                        description=f"SEC download {ticker}",
                    )

                    for htm_path in html_paths:
                        base_name = htm_path.parent.name
                        pdf_path = ticker_dir / (base_name + ".pdf")
                        md_path = ticker_dir / (base_name + ".md")

                        # HTML -> PDF (human-readable; skip if already exists)
                        if not pdf_path.exists():
                            try:
                                await _retry_async(
                                    lambda _h=htm_path, _p=pdf_path: html_to_pdf(_h, _p),
                                    description=f"PDF {ticker}/{htm_path.name}",
                                )
                            except Exception as exc:
                                logger.warning("PDF conversion failed for %s/%s after retries: %s",
                                               ticker, htm_path.name, exc)
                                all_conversions_ok = False

                        # HTML -> Markdown (LLM-friendly; skip if already exists)
                        if not md_path.exists():
                            try:
                                _html_to_markdown(htm_path, md_path)
                            except Exception as exc:
                                logger.warning("Markdown conversion failed for %s/%s: %s",
                                               ticker, htm_path.name, exc)
                                all_conversions_ok = False

                        filing_count += 1

                # Only mark as done if ALL conversions succeeded
                if all_conversions_ok:
                    _ = done_flag.write_text(f"filings={filing_count}")
                logger.info("%s: %d filings processed (PDF + MD).%s",
                            ticker, filing_count,
                            "" if all_conversions_ok else " (some conversions failed, will retry)")
            except ValueError as exc:
                logger.warning("Ticker %s: CIK resolution failed after all strategies: %s", ticker, exc)
            except Exception as exc:
                logger.warning("Filing download failed for %s: %s", ticker, exc)

        # ── XBRL company facts ────────────────────────────────────────
        if not xbrl_done and xbrl_client is not None and cik:
            try:
                await _download_xbrl_facts(xbrl_client, ticker, cik)
            except Exception as exc:
                logger.warning("XBRL download failed for %s: %s", ticker, exc)

    return filing_count


def _load_company_names() -> dict[str, str]:
    """Load ticker → company name mapping from the universe CSV."""
    univ_path = config.UNIVERSE_DIR / "benchmark_universe.csv"
    if not univ_path.exists():
        return {}
    df = pd.read_csv(univ_path)
    if "ticker" in df.columns and "name" in df.columns:
        return dict(zip(df["ticker"], df["name"].fillna("")))
    return {}


async def run_async(tickers: list[str] | None = None) -> dict[str, int]:
    """Execute Step 4 (async): download filings + XBRL facts.

    Returns ``{ticker: filing_count}``.
    """
    config.FILINGS_DIR.mkdir(parents=True, exist_ok=True)
    _XBRL_RAW_DIR.mkdir(parents=True, exist_ok=True)

    user_agent = os.getenv("SEC_EDGAR_USER_AGENT")
    if not user_agent:
        raise ValueError("Set SEC_EDGAR_USER_AGENT environment variable.")

    if tickers is None:
        universe_path = config.UNIVERSE_DIR / "benchmark_universe.csv"
        if not universe_path.exists():
            raise FileNotFoundError(f"Run Step 1 first: {universe_path}")
        tickers = pd.read_csv(universe_path)["ticker"].tolist()

    # Load company names for CIK fuzzy-match fallback
    company_names = _load_company_names()

    # Resolve CIK map for XBRL (single API call, reused across all tickers)
    headers = {"User-Agent": user_agent, "Accept-Encoding": "gzip, deflate"}
    async with httpx.AsyncClient(
        headers=headers, timeout=30.0, follow_redirects=True,
    ) as xbrl_client:
        cik_map = await _resolve_cik_map(xbrl_client, tickers)

        # Persist CIK map for reference
        cik_map_path = config.XBRL_DIR / "cik_map.json"
        config.XBRL_DIR.mkdir(parents=True, exist_ok=True)
        _atomic_json_write(cik_map, cik_map_path)

        logger.info(
            "Downloading SEC filings + XBRL for %d tickers "
            "(%d with company names, %d with CIK) ...",
            len(tickers), len(company_names), len(cik_map),
        )

        downloader = SecEdgarDownloader(user_agent=user_agent)
        semaphore = asyncio.Semaphore(config.SEC_FILING_WORKERS)

        tasks = [
            _download_ticker_filings(
                t,
                company_names.get(t, ""),
                downloader,
                semaphore,
                xbrl_client=xbrl_client,
                cik=cik_map.get(t),
            )
            for t in tickers
        ]
        results = await asyncio.gather(*tasks, return_exceptions=True)

    summary: dict[str, int] = {}
    for ticker, result in zip(tickers, results):
        if isinstance(result, BaseException):
            logger.warning("Ticker %s raised: %s", ticker, result)
            summary[ticker] = 0
        else:
            summary[ticker] = result

    total = sum(summary.values())
    xbrl_count = sum(1 for f in _XBRL_RAW_DIR.glob("*.json") if f.stat().st_size > 100)
    logger.info(
        "SEC Step 4 complete: %d filings across %d tickers, %d XBRL facts downloaded.",
        total, len(tickers), xbrl_count,
    )
    return summary


def run(tickers: list[str] | None = None) -> dict[str, int]:
    """Sync wrapper around the async implementation."""
    return asyncio.run(run_async(tickers))