code/build_ontology.py

"""Build industry-level XBRL ontology + company-level extracted fields.

Reads raw XBRL company facts (``data/xbrl/raw/{TICKER}.json``) and the
universe file to:

1. **Parse** all 10-K / 10-Q facts into a normalised table.
2. **Group** by sector and industry (from ``company_info.csv``).
3. **Classify** each tag per industry:
   - **core**   – appears in ≥70 % of companies in the industry
   - **common** – appears in ≥30 %
   - **extension** – appears in <30 % (often company-specific XBRL extensions)
4. **Output**:
   - ``data/xbrl/parsed/company_facts.parquet`` – all extracted facts
   - ``data/xbrl/parsed/company_tags.parquet``  – per-company tag list (latest value)
   - ``data/xbrl/ontology/industry_ontology.json`` – per-industry tag classification
   - ``data/xbrl/ontology/tag_catalog.parquet``    – master tag catalog with labels
"""

from __future__ import annotations

import json
import logging
from collections import defaultdict
from pathlib import Path

import numpy as np
import pandas as pd

from . import config

logger = logging.getLogger(__name__)

_RAW_DIR = config.XBRL_DIR / "raw"
_PARSED_DIR = config.XBRL_DIR / "parsed"
_ONTOLOGY_DIR = config.XBRL_DIR / "ontology"


# ---------------------------------------------------------------------------
# Step 1: Parse raw company facts into a flat table
# ---------------------------------------------------------------------------

def _parse_single_company(
    ticker: str,
    path: Path,
    allowed_forms: set[str],
) -> tuple[list[dict], dict[str, dict]]:
    """Parse one company's raw XBRL JSON.

    Returns
    -------
    facts : list[dict]
        Flat rows of (ticker, taxonomy, tag, label, unit, period_start,
        period_end, value, form, fiscal_year, fiscal_period, filed).
    tag_meta : dict[str, dict]
        ``{taxonomy:tag: {label, description, taxonomy}}``
    """
    try:
        raw = json.loads(path.read_text(encoding="utf-8"))
    except (json.JSONDecodeError, UnicodeDecodeError):
        logger.warning("Corrupt JSON for %s, skipping", ticker)
        return [], {}

    if raw.get("_no_xbrl"):
        return [], {}

    facts_root = raw.get("facts", {})
    rows: list[dict] = []
    tag_meta: dict[str, dict] = {}

    for taxonomy, tags in facts_root.items():
        for tag_name, tag_data in tags.items():
            label = tag_data.get("label") or tag_name
            description = tag_data.get("description") or ""

            meta_key = f"{taxonomy}:{tag_name}"
            if meta_key not in tag_meta:
                tag_meta[meta_key] = {
                    "taxonomy": taxonomy,
                    "tag": tag_name,
                    "label": label,
                    "description": str(description),
                }

            units = tag_data.get("units", {})
            for unit_name, entries in units.items():
                for entry in entries:
                    form = entry.get("form", "")
                    if form not in allowed_forms:
                        continue

                    rows.append({
                        "ticker": ticker,
                        "taxonomy": taxonomy,
                        "tag": tag_name,
                        "label": label,
                        "unit": unit_name,
                        "period_start": entry.get("start"),
                        "period_end": entry.get("end"),
                        "value": entry.get("val"),
                        "form": form,
                        "fiscal_year": entry.get("fy"),
                        "fiscal_period": entry.get("fp"),
                        "filed": entry.get("filed"),
                        "accession": entry.get("accn", ""),
                    })

    return rows, tag_meta


def _parse_all_companies() -> tuple[pd.DataFrame, pd.DataFrame]:
    """Parse all raw XBRL JSON files.

    Returns ``(facts_df, tag_catalog_df)``
    """
    if not _RAW_DIR.exists():
        raise FileNotFoundError(
            f"XBRL raw directory not found: {_RAW_DIR}. Run collect_filings first (Step 4)."
        )

    json_files = sorted(_RAW_DIR.glob("*.json"))
    if not json_files:
        raise FileNotFoundError("No XBRL JSON files found in " + str(_RAW_DIR))

    allowed_forms = set(config.XBRL_FORMS)
    all_rows: list[dict] = []
    all_meta: dict[str, dict] = {}

    for i, path in enumerate(json_files):
        ticker = path.stem
        rows, meta = _parse_single_company(ticker, path, allowed_forms)
        all_rows.extend(rows)
        all_meta.update(meta)

        if (i + 1) % 500 == 0:
            logger.info("  Parsed %d / %d companies (%d facts so far)",
                        i + 1, len(json_files), len(all_rows))

    logger.info(
        "Parsed %d companies → %d facts, %d unique tags",
        len(json_files), len(all_rows), len(all_meta),
    )

    facts_df = pd.DataFrame(all_rows)
    if not facts_df.empty:
        for col in ("period_start", "period_end", "filed"):
            facts_df[col] = pd.to_datetime(facts_df[col], errors="coerce")

    tag_catalog = pd.DataFrame(list(all_meta.values()))
    return facts_df, tag_catalog


# ---------------------------------------------------------------------------
# Step 2: Build per-industry ontology
# ---------------------------------------------------------------------------

def _load_industry_map() -> dict[str, tuple[str, str]]:
    """Load ticker → (sector, industry) from company_info.csv."""
    ci_path = config.FUNDAMENTALS_DIR / "company_info.csv"
    if not ci_path.exists():
        logger.warning("company_info.csv not found; falling back to universe sectors")
        u_path = config.UNIVERSE_DIR / "benchmark_universe.csv"
        if not u_path.exists():
            return {}
        u = pd.read_csv(u_path)
        return {
            row["ticker"]: (str(row.get("sector", "Unknown")), "Unknown")
            for _, row in u.iterrows()
        }

    ci = pd.read_csv(ci_path)
    return {
        row["ticker"]: (
            str(row.get("sector", "Unknown")),
            str(row.get("industry", "Unknown")),
        )
        for _, row in ci.iterrows()
    }


def _build_ontology(
    facts_df: pd.DataFrame,
    industry_map: dict[str, tuple[str, str]],
) -> dict:
    """Build the industry-level ontology.

    Returns a nested dict::

        {
          "by_sector": {
            "Healthcare": {
              "company_count": 515,
              "tag_count": 1234,
              "tags": {
                "us-gaap:Revenue": {
                  "label": "Revenue",
                  "coverage": 0.95,
                  "classification": "core",
                  "median_value": 123456789,
                  "industries": ["Biotechnology", "Medical Devices", ...]
                },
                ...
              }
            },
            ...
          },
          "by_industry": {
            "Biotechnology": {
              "sector": "Healthcare",
              "company_count": 238,
              "tag_count": 567,
              "tags": { ... }
            },
            ...
          }
        }
    """
    if facts_df.empty:
        return {"by_sector": {}, "by_industry": {}}

    # Attach sector/industry
    facts_df = facts_df.copy()
    facts_df["sector"] = facts_df["ticker"].map(
        lambda t: industry_map.get(t, ("Unknown", "Unknown"))[0]
    )
    facts_df["industry"] = facts_df["ticker"].map(
        lambda t: industry_map.get(t, ("Unknown", "Unknown"))[1]
    )

    # Build a full tag key
    facts_df["tag_key"] = facts_df["taxonomy"] + ":" + facts_df["tag"]

    core_thresh = config.XBRL_CORE_THRESHOLD
    common_thresh = config.XBRL_COMMON_THRESHOLD

    def _classify_tags(
        group_facts: pd.DataFrame,
        group_name: str,
    ) -> dict:
        """Classify tags within a group (sector or industry)."""
        company_count = group_facts["ticker"].nunique()
        if company_count == 0:
            return {
                "company_count": 0,
                "tag_count": 0,
                "tags": {},
            }

        # For each tag: how many companies have reported it
        tag_company_counts = (
            group_facts.groupby("tag_key")["ticker"]
            .nunique()
            .to_dict()
        )
        # Tag labels (modal) — via value_counts + idxmax (vectorized)
        lab_vc = group_facts.groupby(["tag_key", "label"]).size().reset_index(name="n")
        lab_idx = lab_vc.groupby("tag_key")["n"].idxmax()
        tag_labels = dict(
            zip(lab_vc.loc[lab_idx, "tag_key"].values, lab_vc.loc[lab_idx, "label"].values)
        )
        # Median value per (tag, latest fiscal year) — single vectorized groupby
        val_numeric = pd.to_numeric(group_facts["value"], errors="coerce")
        gf = group_facts.assign(_vn=val_numeric).dropna(subset=["_vn"])
        median_values: dict = {}
        if not gf.empty:
            med_by_fy = gf.groupby(["tag_key", "fiscal_year"])["_vn"].median()
            latest_fy_series = gf.groupby("tag_key")["fiscal_year"].max()
            for tk, fy in latest_fy_series.items():
                if (tk, fy) in med_by_fy.index:
                    median_values[tk] = float(med_by_fy.loc[(tk, fy)])

        tags: dict[str, dict] = {}
        for tag_key, n_companies in tag_company_counts.items():
            coverage = n_companies / company_count
            if coverage >= core_thresh:
                classification = "core"
            elif coverage >= common_thresh:
                classification = "common"
            else:
                classification = "extension"

            tags[tag_key] = {
                "label": tag_labels.get(tag_key, ""),
                "company_count": int(n_companies),
                "coverage": round(coverage, 4),
                "classification": classification,
                "median_value": median_values.get(tag_key),
            }

        return {
            "company_count": int(company_count),
            "tag_count": len(tags),
            "tags": dict(sorted(
                tags.items(),
                key=lambda x: (-x[1]["coverage"], x[0]),
            )),
        }

    # By sector
    ontology_by_sector: dict = {}
    for sector, sector_facts in facts_df.groupby("sector"):
        logger.info("  Building ontology for sector: %s", sector)
        ontology_by_sector[sector] = _classify_tags(sector_facts, sector)

    # By industry
    ontology_by_industry: dict = {}
    for industry, ind_facts in facts_df.groupby("industry"):
        sector = ind_facts["sector"].mode()
        sector_name = sector.iloc[0] if len(sector) > 0 else "Unknown"
        result = _classify_tags(ind_facts, industry)
        result["sector"] = sector_name
        ontology_by_industry[industry] = result

    return {
        "by_sector": ontology_by_sector,
        "by_industry": ontology_by_industry,
    }


# ---------------------------------------------------------------------------
# Step 3: Extract company-level tag summaries
# ---------------------------------------------------------------------------

def _build_company_tags(facts_df: pd.DataFrame) -> pd.DataFrame:
    """For each company, extract the latest value per tag.

    Returns a DataFrame with columns:
        ticker, taxonomy, tag, label, unit, value, fiscal_year, fiscal_period, filed
    """
    if facts_df.empty:
        return pd.DataFrame()

    # Keep only the latest filing per ticker × tag × unit
    idx = facts_df.groupby(["ticker", "taxonomy", "tag", "unit"])["filed"].idxmax()
    latest = facts_df.loc[idx].copy()
    latest = latest.sort_values(["ticker", "taxonomy", "tag"])
    return latest[
        ["ticker", "taxonomy", "tag", "label", "unit", "value",
         "fiscal_year", "fiscal_period", "filed"]
    ].reset_index(drop=True)


# ---------------------------------------------------------------------------
# Public API
# ---------------------------------------------------------------------------

def run() -> dict[str, int]:
    """Build XBRL ontology from collected company facts.

    Returns summary dict with counts.
    """
    _PARSED_DIR.mkdir(parents=True, exist_ok=True)
    _ONTOLOGY_DIR.mkdir(parents=True, exist_ok=True)

    # Skip if already built (resume-safe). The ontology only needs rebuilding
    # if the raw XBRL files change, which only happens after collect_filings.
    ontology_path = _ONTOLOGY_DIR / "industry_ontology.json"
    facts_path = _PARSED_DIR / "company_facts.parquet"
    if ontology_path.exists() and ontology_path.stat().st_size > 1000 and facts_path.exists() and facts_path.stat().st_size > 1000:
        ont = json.loads(ontology_path.read_text())
        # The ontology JSON has top-level keys {by_sector, by_industry}; sector
        # and industry counts are the lengths of THOSE inner dicts, not of the
        # top-level dict itself.
        if isinstance(ont, dict):
            n_sectors = len(ont.get("by_sector", {}))
            n_industries = len(ont.get("by_industry", {}))
        else:
            n_sectors = 0
            n_industries = 0
        logger.info("Ontology already exists (%d sectors, %d industries). Skipping rebuild.",
                    n_sectors, n_industries)
        tags = pd.read_parquet(_ONTOLOGY_DIR / "tag_catalog.parquet") if (_ONTOLOGY_DIR / "tag_catalog.parquet").exists() else pd.DataFrame()
        facts = pd.read_parquet(facts_path)
        return {
            "facts": len(facts),
            "unique_tags": len(tags),
            "companies": facts["ticker"].nunique() if "ticker" in facts.columns else 0,
            "sectors": n_sectors,
            "industries": n_industries,
        }

    # ── Step 1: Parse raw JSON ──────────────────────────────────────────
    logger.info("Parsing raw XBRL company facts…")
    facts_df, tag_catalog = _parse_all_companies()

    # Save parsed facts
    facts_path = _PARSED_DIR / "company_facts.parquet"
    if not facts_df.empty:
        facts_df.to_parquet(facts_path, index=False)
        logger.info("Saved %d facts to %s", len(facts_df), facts_path)
    else:
        logger.warning("No facts parsed — empty output")
        return {"facts": 0, "tags": 0, "sectors": 0, "industries": 0}

    # Save tag catalog
    catalog_path = _ONTOLOGY_DIR / "tag_catalog.parquet"
    tag_catalog.to_parquet(catalog_path, index=False)
    logger.info("Saved %d unique tags to %s", len(tag_catalog), catalog_path)

    # ── Step 2: Build industry ontology ─────────────────────────────────
    logger.info("Building industry ontology…")
    industry_map = _load_industry_map()
    ontology = _build_ontology(facts_df, industry_map)

    ontology_path = _ONTOLOGY_DIR / "industry_ontology.json"
    with open(ontology_path, "w", encoding="utf-8") as fh:
        json.dump(ontology, fh, indent=2, ensure_ascii=False, default=str)
    logger.info("Saved ontology to %s", ontology_path)

    # ── Step 3: Company-level tag summary ───────────────────────────────
    logger.info("Building company-level tag summaries…")
    company_tags = _build_company_tags(facts_df)
    company_tags_path = _PARSED_DIR / "company_tags.parquet"
    company_tags.to_parquet(company_tags_path, index=False)
    logger.info("Saved %d company-tag rows to %s", len(company_tags), company_tags_path)

    n_sectors = len(ontology.get("by_sector", {}))
    n_industries = len(ontology.get("by_industry", {}))

    summary = {
        "facts": len(facts_df),
        "unique_tags": len(tag_catalog),
        "companies": facts_df["ticker"].nunique(),
        "sectors": n_sectors,
        "industries": n_industries,
    }
    logger.info("Ontology build complete: %s", summary)

    # Print top-level ontology summary
    for sector, data in sorted(ontology.get("by_sector", {}).items()):
        core = sum(1 for t in data["tags"].values() if t["classification"] == "core")
        common = sum(1 for t in data["tags"].values() if t["classification"] == "common")
        ext = sum(1 for t in data["tags"].values() if t["classification"] == "extension")
        logger.info(
            "  %s: %d companies, %d tags (core=%d, common=%d, extension=%d)",
            sector, data["company_count"], data["tag_count"], core, common, ext,
        )

    return summary